diff --git a/docs/html/custom_memory_pools.html b/docs/html/custom_memory_pools.html index 573c0fb..017fcf6 100644 --- a/docs/html/custom_memory_pools.html +++ b/docs/html/custom_memory_pools.html @@ -80,7 +80,11 @@ $(function() {

Example:

// Create a pool that could have at most 2 blocks, 128 MiB each.
VmaPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.memoryTypeIndex = ...
poolCreateInfo.blockSize = 128ull * 1024 * 1024;
poolCreateInfo.maxBlockCount = 2;
VmaPool pool;
vmaCreatePool(allocator, &poolCreateInfo, &pool);
// Allocate a buffer out of it.
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
bufCreateInfo.size = 1024;
bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.pool = pool;
VkBuffer buf;
VmaAllocation alloc;
VmaAllocationInfo allocInfo;
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

You have to free all allocations made from this pool before destroying it.

-
vmaDestroyBuffer(allocator, buf, alloc);
vmaDestroyPool(allocator, pool);
+
vmaDestroyBuffer(allocator, buf, alloc);
vmaDestroyPool(allocator, pool);

+Choosing memory type index

+

When creating a pool, you must explicitly specify memory type index. To find the one suitable for your buffers or images, you can use code similar to the following:

+
VkBufferCreateInfo dummyBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
dummyBufCreateInfo.size = 1024; // Whatever.
dummyBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; // Change if needed.
VkBuffer dummyBuf;
vkCreateBuffer(device, &dummyBufCreateInfo, nullptr, &dummyBuf);
VkMemoryRequirements memReq;
vkGetBufferMemoryRequirements(device, dummyBuf, &memReq);
VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; // Change if needed.
uint32_t memTypeIndex;
vmaFindMemoryTypeIndex(allocator, memReq.memoryTypeBits, &allocCreateInfo, &memTypeIndex);
vkDestroyBuffer(device, dummyBuf, nullptr);
VmaPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.memoryTypeIndex = memTypeIndex;
// ...

Dummy buffer is needed to query driver for memReq.memoryTypeBits. Memory is never allocated for this buffer. You should fill structures dummyBufCreateInfo and allocCreateInfo with the same parameters as you are going to use for buffers created in your pool.

+
Generated by   diff --git a/docs/html/vk__mem__alloc_8h.html b/docs/html/vk__mem__alloc_8h.html index b91e678..d1d5ad2 100644 --- a/docs/html/vk__mem__alloc_8h.html +++ b/docs/html/vk__mem__alloc_8h.html @@ -711,7 +711,7 @@ Functions -

Allocation may still end up in HOST_VISIBLE memory on some implementations. In such case, you are free to map it. You can use VMA_ALLOCATION_CREATE_MAPPED_BIT with this usage type.

- -
Enumerator
VMA_MEMORY_USAGE_UNKNOWN 

No intended memory usage specified. Use other members of VmaAllocationCreateInfo to specify your requirements.

VMA_MEMORY_USAGE_GPU_ONLY 

Memory will be used on device only, so fast access from the device is preferred. It usually means device-local GPU (video) memory. No need to be mappable on host.

+
VMA_MEMORY_USAGE_GPU_ONLY 

Memory will be used on device only, so fast access from the device is preferred. It usually means device-local GPU (video) memory. No need to be mappable on host. It is roughly equivalent of D3D12_HEAP_TYPE_DEFAULT.

Usage:

  • Resources written and read by device, e.g. images used as attachments.
    • @@ -719,13 +719,13 @@ Functions
VMA_MEMORY_USAGE_CPU_ONLY 

Memory will be mappable on host. It usually means CPU (system) memory. Resources created in this pool are still accessible to the device, but access to them can be slower. Guarantees to be HOST_VISIBLE and HOST_COHERENT. CPU read may be uncached.

+
VMA_MEMORY_USAGE_CPU_ONLY 

Memory will be mappable on host. It usually means CPU (system) memory. Resources created in this pool are still accessible to the device, but access to them can be slower. Guarantees to be HOST_VISIBLE and HOST_COHERENT. CPU read may be uncached. It is roughly equivalent of D3D12_HEAP_TYPE_UPLOAD.

Usage: Staging copy of resources used as transfer source.

VMA_MEMORY_USAGE_CPU_TO_GPU 

Memory that is both mappable on host (guarantees to be HOST_VISIBLE) and preferably fast to access by GPU. CPU reads may be uncached and very slow.

Usage: Resources written frequently by host (dynamic), read by device. E.g. textures, vertex buffers, uniform buffers updated every frame or every draw call.

VMA_MEMORY_USAGE_GPU_TO_CPU 

Memory mappable on host (guarantees to be HOST_VISIBLE) and cached.

+
VMA_MEMORY_USAGE_GPU_TO_CPU 

Memory mappable on host (guarantees to be HOST_VISIBLE) and cached. It is roughly equivalent of D3D12_HEAP_TYPE_READBACK.

Usage:

  • Resources written by device, read by host - results of some computations, e.g. screen capture, average scene luminance for HDR tone mapping.
    • diff --git a/docs/html/vk__mem__alloc_8h_source.html b/docs/html/vk__mem__alloc_8h_source.html index f8eec9e..10e0a72 100644 --- a/docs/html/vk__mem__alloc_8h_source.html +++ b/docs/html/vk__mem__alloc_8h_source.html @@ -62,154 +62,154 @@ $(function() {
    vk_mem_alloc.h
    -Go to the documentation of this file.
    1 //
    2 // Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved.
    3 //
    4 // Permission is hereby granted, free of charge, to any person obtaining a copy
    5 // of this software and associated documentation files (the "Software"), to deal
    6 // in the Software without restriction, including without limitation the rights
    7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    8 // copies of the Software, and to permit persons to whom the Software is
    9 // furnished to do so, subject to the following conditions:
    10 //
    11 // The above copyright notice and this permission notice shall be included in
    12 // all copies or substantial portions of the Software.
    13 //
    14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    20 // THE SOFTWARE.
    21 //
    22 
    23 #ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
    24 #define AMD_VULKAN_MEMORY_ALLOCATOR_H
    25 
    26 #ifdef __cplusplus
    27 extern "C" {
    28 #endif
    29 
    688 #include <vulkan/vulkan.h>
    689 
    690 VK_DEFINE_HANDLE(VmaAllocator)
    691 
    692 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
    694  VmaAllocator allocator,
    695  uint32_t memoryType,
    696  VkDeviceMemory memory,
    697  VkDeviceSize size);
    699 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
    700  VmaAllocator allocator,
    701  uint32_t memoryType,
    702  VkDeviceMemory memory,
    703  VkDeviceSize size);
    704 
    712 typedef struct VmaDeviceMemoryCallbacks {
    714  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
    716  PFN_vmaFreeDeviceMemoryFunction pfnFree;
    717 } VmaDeviceMemoryCallbacks;
    718 
    720 typedef enum VmaAllocatorCreateFlagBits {
    725  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
    747  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
    748 
    749  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    750 } VmaAllocatorCreateFlagBits;
    751 typedef VkFlags VmaAllocatorCreateFlags;
    752 
    757 typedef struct VmaVulkanFunctions {
    758  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
    759  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
    760  PFN_vkAllocateMemory vkAllocateMemory;
    761  PFN_vkFreeMemory vkFreeMemory;
    762  PFN_vkMapMemory vkMapMemory;
    763  PFN_vkUnmapMemory vkUnmapMemory;
    764  PFN_vkBindBufferMemory vkBindBufferMemory;
    765  PFN_vkBindImageMemory vkBindImageMemory;
    766  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
    767  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
    768  PFN_vkCreateBuffer vkCreateBuffer;
    769  PFN_vkDestroyBuffer vkDestroyBuffer;
    770  PFN_vkCreateImage vkCreateImage;
    771  PFN_vkDestroyImage vkDestroyImage;
    772  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
    773  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
    774 } VmaVulkanFunctions;
    775 
    777 typedef struct VmaAllocatorCreateInfo
    778 {
    780  VmaAllocatorCreateFlags flags;
    782 
    783  VkPhysicalDevice physicalDevice;
    785 
    786  VkDevice device;
    788 
    789  VkDeviceSize preferredLargeHeapBlockSize;
    791 
    792  const VkAllocationCallbacks* pAllocationCallbacks;
    794 
    795  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
    809  uint32_t frameInUseCount;
    833  const VkDeviceSize* pHeapSizeLimit;
    845  const VmaVulkanFunctions* pVulkanFunctions;
    846 } VmaAllocatorCreateInfo;
    847 
    849 VkResult vmaCreateAllocator(
    850  const VmaAllocatorCreateInfo* pCreateInfo,
    851  VmaAllocator* pAllocator);
    852 
    854 void vmaDestroyAllocator(
    855  VmaAllocator allocator);
    856 
    861 void vmaGetPhysicalDeviceProperties(
    862  VmaAllocator allocator,
    863  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
    864 
    869 void vmaGetMemoryProperties(
    870  VmaAllocator allocator,
    871  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
    872 
    879 void vmaGetMemoryTypeProperties(
    880  VmaAllocator allocator,
    881  uint32_t memoryTypeIndex,
    882  VkMemoryPropertyFlags* pFlags);
    883 
    892 void vmaSetCurrentFrameIndex(
    893  VmaAllocator allocator,
    894  uint32_t frameIndex);
    895 
    898 typedef struct VmaStatInfo
    899 {
    901  uint32_t blockCount;
    903  uint32_t allocationCount;
    905  uint32_t unusedRangeCount;
    907  VkDeviceSize usedBytes;
    909  VkDeviceSize unusedBytes;
    910  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
    911  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
    912 } VmaStatInfo;
    913 
    915 typedef struct VmaStats
    916 {
    917  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
    918  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
    919  VmaStatInfo total;
    920 } VmaStats;
    921 
    923 void vmaCalculateStats(
    924  VmaAllocator allocator,
    925  VmaStats* pStats);
    926 
    927 #define VMA_STATS_STRING_ENABLED 1
    928 
    929 #if VMA_STATS_STRING_ENABLED
    930 
    932 
    934 void vmaBuildStatsString(
    935  VmaAllocator allocator,
    936  char** ppStatsString,
    937  VkBool32 detailedMap);
    938 
    939 void vmaFreeStatsString(
    940  VmaAllocator allocator,
    941  char* pStatsString);
    942 
    943 #endif // #if VMA_STATS_STRING_ENABLED
    944 
    945 VK_DEFINE_HANDLE(VmaPool)
    946 
    947 typedef enum VmaMemoryUsage
    948 {
    952  VMA_MEMORY_USAGE_UNKNOWN = 0,
    968  VMA_MEMORY_USAGE_GPU_ONLY = 1,
    977  VMA_MEMORY_USAGE_CPU_ONLY = 2,
    984  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
    992  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
    993  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
    994 } VmaMemoryUsage;
    995 
    997 typedef enum VmaAllocationCreateFlagBits {
    1009  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
    1010 
    1020  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
    1033  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
    1046  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
    1053  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
    1059  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
    1060 
    1061  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    1062 } VmaAllocationCreateFlagBits;
    1063 typedef VkFlags VmaAllocationCreateFlags;
    1064 
    1065 typedef struct VmaAllocationCreateInfo
    1066 {
    1068  VmaAllocationCreateFlags flags;
    1074  VmaMemoryUsage usage;
    1079  VkMemoryPropertyFlags requiredFlags;
    1084  VkMemoryPropertyFlags preferredFlags;
    1092  uint32_t memoryTypeBits;
    1098  VmaPool pool;
    1105  void* pUserData;
    1106 } VmaAllocationCreateInfo;
    1107 
    1122 VkResult vmaFindMemoryTypeIndex(
    1123  VmaAllocator allocator,
    1124  uint32_t memoryTypeBits,
    1125  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    1126  uint32_t* pMemoryTypeIndex);
    1127 
    1129 typedef enum VmaPoolCreateFlagBits {
    1147  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
    1148 
    1149  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    1150 } VmaPoolCreateFlagBits;
    1151 typedef VkFlags VmaPoolCreateFlags;
    1152 
    1155 typedef struct VmaPoolCreateInfo {
    1158  uint32_t memoryTypeIndex;
    1161  VmaPoolCreateFlags flags;
    1166  VkDeviceSize blockSize;
    1171  size_t minBlockCount;
    1179  size_t maxBlockCount;
    1193  uint32_t frameInUseCount;
    1194 } VmaPoolCreateInfo;
    1195 
    1198 typedef struct VmaPoolStats {
    1201  VkDeviceSize size;
    1204  VkDeviceSize unusedSize;
    1207  size_t allocationCount;
    1210  size_t unusedRangeCount;
    1217  VkDeviceSize unusedRangeSizeMax;
    1218 } VmaPoolStats;
    1219 
    1226 VkResult vmaCreatePool(
    1227  VmaAllocator allocator,
    1228  const VmaPoolCreateInfo* pCreateInfo,
    1229  VmaPool* pPool);
    1230 
    1233 void vmaDestroyPool(
    1234  VmaAllocator allocator,
    1235  VmaPool pool);
    1236 
    1243 void vmaGetPoolStats(
    1244  VmaAllocator allocator,
    1245  VmaPool pool,
    1246  VmaPoolStats* pPoolStats);
    1247 
    1254 void vmaMakePoolAllocationsLost(
    1255  VmaAllocator allocator,
    1256  VmaPool pool,
    1257  size_t* pLostAllocationCount);
    1258 
    1259 VK_DEFINE_HANDLE(VmaAllocation)
    1260 
    1261 
    1263 typedef struct VmaAllocationInfo {
    1268  uint32_t memoryType;
    1277  VkDeviceMemory deviceMemory;
    1282  VkDeviceSize offset;
    1287  VkDeviceSize size;
    1296  void* pMappedData;
    1301  void* pUserData;
    1302 } VmaAllocationInfo;
    1303 
    1314 VkResult vmaAllocateMemory(
    1315  VmaAllocator allocator,
    1316  const VkMemoryRequirements* pVkMemoryRequirements,
    1317  const VmaAllocationCreateInfo* pCreateInfo,
    1318  VmaAllocation* pAllocation,
    1319  VmaAllocationInfo* pAllocationInfo);
    1320 
    1327 VkResult vmaAllocateMemoryForBuffer(
    1328  VmaAllocator allocator,
    1329  VkBuffer buffer,
    1330  const VmaAllocationCreateInfo* pCreateInfo,
    1331  VmaAllocation* pAllocation,
    1332  VmaAllocationInfo* pAllocationInfo);
    1333 
    1335 VkResult vmaAllocateMemoryForImage(
    1336  VmaAllocator allocator,
    1337  VkImage image,
    1338  const VmaAllocationCreateInfo* pCreateInfo,
    1339  VmaAllocation* pAllocation,
    1340  VmaAllocationInfo* pAllocationInfo);
    1341 
    1343 void vmaFreeMemory(
    1344  VmaAllocator allocator,
    1345  VmaAllocation allocation);
    1346 
    1348 void vmaGetAllocationInfo(
    1349  VmaAllocator allocator,
    1350  VmaAllocation allocation,
    1351  VmaAllocationInfo* pAllocationInfo);
    1352 
    1366 void vmaSetAllocationUserData(
    1367  VmaAllocator allocator,
    1368  VmaAllocation allocation,
    1369  void* pUserData);
    1370 
    1381 void vmaCreateLostAllocation(
    1382  VmaAllocator allocator,
    1383  VmaAllocation* pAllocation);
    1384 
    1419 VkResult vmaMapMemory(
    1420  VmaAllocator allocator,
    1421  VmaAllocation allocation,
    1422  void** ppData);
    1423 
    1428 void vmaUnmapMemory(
    1429  VmaAllocator allocator,
    1430  VmaAllocation allocation);
    1431 
    1433 typedef struct VmaDefragmentationInfo {
    1438  VkDeviceSize maxBytesToMove;
    1443  uint32_t maxAllocationsToMove;
    1444 } VmaDefragmentationInfo;
    1445 
    1447 typedef struct VmaDefragmentationStats {
    1449  VkDeviceSize bytesMoved;
    1451  VkDeviceSize bytesFreed;
    1453  uint32_t allocationsMoved;
    1455  uint32_t deviceMemoryBlocksFreed;
    1456 } VmaDefragmentationStats;
    1457 
    1534 VkResult vmaDefragment(
    1535  VmaAllocator allocator,
    1536  VmaAllocation* pAllocations,
    1537  size_t allocationCount,
    1538  VkBool32* pAllocationsChanged,
    1539  const VmaDefragmentationInfo *pDefragmentationInfo,
    1540  VmaDefragmentationStats* pDefragmentationStats);
    1541 
    1568 VkResult vmaCreateBuffer(
    1569  VmaAllocator allocator,
    1570  const VkBufferCreateInfo* pBufferCreateInfo,
    1571  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    1572  VkBuffer* pBuffer,
    1573  VmaAllocation* pAllocation,
    1574  VmaAllocationInfo* pAllocationInfo);
    1575 
    1587 void vmaDestroyBuffer(
    1588  VmaAllocator allocator,
    1589  VkBuffer buffer,
    1590  VmaAllocation allocation);
    1591 
    1593 VkResult vmaCreateImage(
    1594  VmaAllocator allocator,
    1595  const VkImageCreateInfo* pImageCreateInfo,
    1596  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    1597  VkImage* pImage,
    1598  VmaAllocation* pAllocation,
    1599  VmaAllocationInfo* pAllocationInfo);
    1600 
    1612 void vmaDestroyImage(
    1613  VmaAllocator allocator,
    1614  VkImage image,
    1615  VmaAllocation allocation);
    1616 
    1617 #ifdef __cplusplus
    1618 }
    1619 #endif
    1620 
    1621 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
    1622 
    1623 // For Visual Studio IntelliSense.
    1624 #ifdef __INTELLISENSE__
    1625 #define VMA_IMPLEMENTATION
    1626 #endif
    1627 
    1628 #ifdef VMA_IMPLEMENTATION
    1629 #undef VMA_IMPLEMENTATION
    1630 
    1631 #include <cstdint>
    1632 #include <cstdlib>
    1633 #include <cstring>
    1634 
    1635 /*******************************************************************************
    1636 CONFIGURATION SECTION
    1637 
    1638 Define some of these macros before each #include of this header or change them
    1639 here if you need other then default behavior depending on your environment.
    1640 */
    1641 
    1642 /*
    1643 Define this macro to 1 to make the library fetch pointers to Vulkan functions
    1644 internally, like:
    1645 
    1646  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
    1647 
    1648 Define to 0 if you are going to provide you own pointers to Vulkan functions via
    1649 VmaAllocatorCreateInfo::pVulkanFunctions.
    1650 */
    1651 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
    1652 #define VMA_STATIC_VULKAN_FUNCTIONS 1
    1653 #endif
    1654 
    1655 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
    1656 //#define VMA_USE_STL_CONTAINERS 1
    1657 
    1658 /* Set this macro to 1 to make the library including and using STL containers:
    1659 std::pair, std::vector, std::list, std::unordered_map.
    1660 
    1661 Set it to 0 or undefined to make the library using its own implementation of
    1662 the containers.
    1663 */
    1664 #if VMA_USE_STL_CONTAINERS
    1665  #define VMA_USE_STL_VECTOR 1
    1666  #define VMA_USE_STL_UNORDERED_MAP 1
    1667  #define VMA_USE_STL_LIST 1
    1668 #endif
    1669 
    1670 #if VMA_USE_STL_VECTOR
    1671  #include <vector>
    1672 #endif
    1673 
    1674 #if VMA_USE_STL_UNORDERED_MAP
    1675  #include <unordered_map>
    1676 #endif
    1677 
    1678 #if VMA_USE_STL_LIST
    1679  #include <list>
    1680 #endif
    1681 
    1682 /*
    1683 Following headers are used in this CONFIGURATION section only, so feel free to
    1684 remove them if not needed.
    1685 */
    1686 #include <cassert> // for assert
    1687 #include <algorithm> // for min, max
    1688 #include <mutex> // for std::mutex
    1689 #include <atomic> // for std::atomic
    1690 
    1691 #if !defined(_WIN32)
    1692  #include <malloc.h> // for aligned_alloc()
    1693 #endif
    1694 
    1695 // Normal assert to check for programmer's errors, especially in Debug configuration.
    1696 #ifndef VMA_ASSERT
    1697  #ifdef _DEBUG
    1698  #define VMA_ASSERT(expr) assert(expr)
    1699  #else
    1700  #define VMA_ASSERT(expr)
    1701  #endif
    1702 #endif
    1703 
    1704 // Assert that will be called very often, like inside data structures e.g. operator[].
    1705 // Making it non-empty can make program slow.
    1706 #ifndef VMA_HEAVY_ASSERT
    1707  #ifdef _DEBUG
    1708  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
    1709  #else
    1710  #define VMA_HEAVY_ASSERT(expr)
    1711  #endif
    1712 #endif
    1713 
    1714 #ifndef VMA_NULL
    1715  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
    1716  #define VMA_NULL nullptr
    1717 #endif
    1718 
    1719 #ifndef VMA_ALIGN_OF
    1720  #define VMA_ALIGN_OF(type) (__alignof(type))
    1721 #endif
    1722 
    1723 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
    1724  #if defined(_WIN32)
    1725  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
    1726  #else
    1727  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
    1728  #endif
    1729 #endif
    1730 
    1731 #ifndef VMA_SYSTEM_FREE
    1732  #if defined(_WIN32)
    1733  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
    1734  #else
    1735  #define VMA_SYSTEM_FREE(ptr) free(ptr)
    1736  #endif
    1737 #endif
    1738 
    1739 #ifndef VMA_MIN
    1740  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
    1741 #endif
    1742 
    1743 #ifndef VMA_MAX
    1744  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
    1745 #endif
    1746 
    1747 #ifndef VMA_SWAP
    1748  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
    1749 #endif
    1750 
    1751 #ifndef VMA_SORT
    1752  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
    1753 #endif
    1754 
    1755 #ifndef VMA_DEBUG_LOG
    1756  #define VMA_DEBUG_LOG(format, ...)
    1757  /*
    1758  #define VMA_DEBUG_LOG(format, ...) do { \
    1759  printf(format, __VA_ARGS__); \
    1760  printf("\n"); \
    1761  } while(false)
    1762  */
    1763 #endif
    1764 
    1765 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
    1766 #if VMA_STATS_STRING_ENABLED
    1767  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
    1768  {
    1769  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
    1770  }
    1771  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
    1772  {
    1773  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
    1774  }
    1775  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
    1776  {
    1777  snprintf(outStr, strLen, "%p", ptr);
    1778  }
    1779 #endif
    1780 
    1781 #ifndef VMA_MUTEX
    1782  class VmaMutex
    1783  {
    1784  public:
    1785  VmaMutex() { }
    1786  ~VmaMutex() { }
    1787  void Lock() { m_Mutex.lock(); }
    1788  void Unlock() { m_Mutex.unlock(); }
    1789  private:
    1790  std::mutex m_Mutex;
    1791  };
    1792  #define VMA_MUTEX VmaMutex
    1793 #endif
    1794 
    1795 /*
    1796 If providing your own implementation, you need to implement a subset of std::atomic:
    1797 
    1798 - Constructor(uint32_t desired)
    1799 - uint32_t load() const
    1800 - void store(uint32_t desired)
    1801 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
    1802 */
    1803 #ifndef VMA_ATOMIC_UINT32
    1804  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
    1805 #endif
    1806 
    1807 #ifndef VMA_BEST_FIT
    1808 
    1820  #define VMA_BEST_FIT (1)
    1821 #endif
    1822 
    1823 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
    1824 
    1828  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
    1829 #endif
    1830 
    1831 #ifndef VMA_DEBUG_ALIGNMENT
    1832 
    1836  #define VMA_DEBUG_ALIGNMENT (1)
    1837 #endif
    1838 
    1839 #ifndef VMA_DEBUG_MARGIN
    1840 
    1844  #define VMA_DEBUG_MARGIN (0)
    1845 #endif
    1846 
    1847 #ifndef VMA_DEBUG_GLOBAL_MUTEX
    1848 
    1852  #define VMA_DEBUG_GLOBAL_MUTEX (0)
    1853 #endif
    1854 
    1855 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
    1856 
    1860  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
    1861 #endif
    1862 
    1863 #ifndef VMA_SMALL_HEAP_MAX_SIZE
    1864  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
    1866 #endif
    1867 
    1868 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
    1869  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
    1871 #endif
    1872 
    1873 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
    1874 
    1875 /*******************************************************************************
    1876 END OF CONFIGURATION
    1877 */
    1878 
    1879 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
    1880  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
    1881 
    1882 // Returns number of bits set to 1 in (v).
    1883 static inline uint32_t VmaCountBitsSet(uint32_t v)
    1884 {
    1885  uint32_t c = v - ((v >> 1) & 0x55555555);
    1886  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
    1887  c = ((c >> 4) + c) & 0x0F0F0F0F;
    1888  c = ((c >> 8) + c) & 0x00FF00FF;
    1889  c = ((c >> 16) + c) & 0x0000FFFF;
    1890  return c;
    1891 }
    1892 
    1893 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
    1894 // Use types like uint32_t, uint64_t as T.
    1895 template <typename T>
    1896 static inline T VmaAlignUp(T val, T align)
    1897 {
    1898  return (val + align - 1) / align * align;
    1899 }
    1900 
    1901 // Division with mathematical rounding to nearest number.
    1902 template <typename T>
    1903 inline T VmaRoundDiv(T x, T y)
    1904 {
    1905  return (x + (y / (T)2)) / y;
    1906 }
    1907 
    1908 #ifndef VMA_SORT
    1909 
    1910 template<typename Iterator, typename Compare>
    1911 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
    1912 {
    1913  Iterator centerValue = end; --centerValue;
    1914  Iterator insertIndex = beg;
    1915  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
    1916  {
    1917  if(cmp(*memTypeIndex, *centerValue))
    1918  {
    1919  if(insertIndex != memTypeIndex)
    1920  {
    1921  VMA_SWAP(*memTypeIndex, *insertIndex);
    1922  }
    1923  ++insertIndex;
    1924  }
    1925  }
    1926  if(insertIndex != centerValue)
    1927  {
    1928  VMA_SWAP(*insertIndex, *centerValue);
    1929  }
    1930  return insertIndex;
    1931 }
    1932 
    1933 template<typename Iterator, typename Compare>
    1934 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
    1935 {
    1936  if(beg < end)
    1937  {
    1938  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
    1939  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
    1940  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
    1941  }
    1942 }
    1943 
    1944 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
    1945 
    1946 #endif // #ifndef VMA_SORT
    1947 
    1948 /*
    1949 Returns true if two memory blocks occupy overlapping pages.
    1950 ResourceA must be in less memory offset than ResourceB.
    1951 
    1952 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
    1953 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
    1954 */
    1955 static inline bool VmaBlocksOnSamePage(
    1956  VkDeviceSize resourceAOffset,
    1957  VkDeviceSize resourceASize,
    1958  VkDeviceSize resourceBOffset,
    1959  VkDeviceSize pageSize)
    1960 {
    1961  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
    1962  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
    1963  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
    1964  VkDeviceSize resourceBStart = resourceBOffset;
    1965  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
    1966  return resourceAEndPage == resourceBStartPage;
    1967 }
    1968 
    1969 enum VmaSuballocationType
    1970 {
    1971  VMA_SUBALLOCATION_TYPE_FREE = 0,
    1972  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
    1973  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
    1974  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
    1975  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
    1976  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
    1977  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
    1978 };
    1979 
    1980 /*
    1981 Returns true if given suballocation types could conflict and must respect
    1982 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
    1983 or linear image and another one is optimal image. If type is unknown, behave
    1984 conservatively.
    1985 */
    1986 static inline bool VmaIsBufferImageGranularityConflict(
    1987  VmaSuballocationType suballocType1,
    1988  VmaSuballocationType suballocType2)
    1989 {
    1990  if(suballocType1 > suballocType2)
    1991  {
    1992  VMA_SWAP(suballocType1, suballocType2);
    1993  }
    1994 
    1995  switch(suballocType1)
    1996  {
    1997  case VMA_SUBALLOCATION_TYPE_FREE:
    1998  return false;
    1999  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
    2000  return true;
    2001  case VMA_SUBALLOCATION_TYPE_BUFFER:
    2002  return
    2003  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
    2004  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    2005  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
    2006  return
    2007  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
    2008  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
    2009  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    2010  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
    2011  return
    2012  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    2013  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
    2014  return false;
    2015  default:
    2016  VMA_ASSERT(0);
    2017  return true;
    2018  }
    2019 }
    2020 
    2021 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
    2022 struct VmaMutexLock
    2023 {
    2024 public:
    2025  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
    2026  m_pMutex(useMutex ? &mutex : VMA_NULL)
    2027  {
    2028  if(m_pMutex)
    2029  {
    2030  m_pMutex->Lock();
    2031  }
    2032  }
    2033 
    2034  ~VmaMutexLock()
    2035  {
    2036  if(m_pMutex)
    2037  {
    2038  m_pMutex->Unlock();
    2039  }
    2040  }
    2041 
    2042 private:
    2043  VMA_MUTEX* m_pMutex;
    2044 };
    2045 
    2046 #if VMA_DEBUG_GLOBAL_MUTEX
    2047  static VMA_MUTEX gDebugGlobalMutex;
    2048  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
    2049 #else
    2050  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
    2051 #endif
    2052 
    2053 // Minimum size of a free suballocation to register it in the free suballocation collection.
    2054 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
    2055 
    2056 /*
    2057 Performs binary search and returns iterator to first element that is greater or
    2058 equal to (key), according to comparison (cmp).
    2059 
    2060 Cmp should return true if first argument is less than second argument.
    2061 
    2062 Returned value is the found element, if present in the collection or place where
    2063 new element with value (key) should be inserted.
    2064 */
    2065 template <typename IterT, typename KeyT, typename CmpT>
    2066 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)
    2067 {
    2068  size_t down = 0, up = (end - beg);
    2069  while(down < up)
    2070  {
    2071  const size_t mid = (down + up) / 2;
    2072  if(cmp(*(beg+mid), key))
    2073  {
    2074  down = mid + 1;
    2075  }
    2076  else
    2077  {
    2078  up = mid;
    2079  }
    2080  }
    2081  return beg + down;
    2082 }
    2083 
    2085 // Memory allocation
    2086 
    2087 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
    2088 {
    2089  if((pAllocationCallbacks != VMA_NULL) &&
    2090  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
    2091  {
    2092  return (*pAllocationCallbacks->pfnAllocation)(
    2093  pAllocationCallbacks->pUserData,
    2094  size,
    2095  alignment,
    2096  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    2097  }
    2098  else
    2099  {
    2100  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
    2101  }
    2102 }
    2103 
    2104 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
    2105 {
    2106  if((pAllocationCallbacks != VMA_NULL) &&
    2107  (pAllocationCallbacks->pfnFree != VMA_NULL))
    2108  {
    2109  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
    2110  }
    2111  else
    2112  {
    2113  VMA_SYSTEM_FREE(ptr);
    2114  }
    2115 }
    2116 
    2117 template<typename T>
    2118 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
    2119 {
    2120  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
    2121 }
    2122 
    2123 template<typename T>
    2124 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
    2125 {
    2126  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
    2127 }
    2128 
    2129 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
    2130 
    2131 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
    2132 
    2133 template<typename T>
    2134 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
    2135 {
    2136  ptr->~T();
    2137  VmaFree(pAllocationCallbacks, ptr);
    2138 }
    2139 
    2140 template<typename T>
    2141 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
    2142 {
    2143  if(ptr != VMA_NULL)
    2144  {
    2145  for(size_t i = count; i--; )
    2146  {
    2147  ptr[i].~T();
    2148  }
    2149  VmaFree(pAllocationCallbacks, ptr);
    2150  }
    2151 }
    2152 
    2153 // STL-compatible allocator.
    2154 template<typename T>
    2155 class VmaStlAllocator
    2156 {
    2157 public:
    2158  const VkAllocationCallbacks* const m_pCallbacks;
    2159  typedef T value_type;
    2160 
    2161  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
    2162  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
    2163 
    2164  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
    2165  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
    2166 
    2167  template<typename U>
    2168  bool operator==(const VmaStlAllocator<U>& rhs) const
    2169  {
    2170  return m_pCallbacks == rhs.m_pCallbacks;
    2171  }
    2172  template<typename U>
    2173  bool operator!=(const VmaStlAllocator<U>& rhs) const
    2174  {
    2175  return m_pCallbacks != rhs.m_pCallbacks;
    2176  }
    2177 
    2178  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
    2179 };
    2180 
    2181 #if VMA_USE_STL_VECTOR
    2182 
    2183 #define VmaVector std::vector
    2184 
    2185 template<typename T, typename allocatorT>
    2186 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
    2187 {
    2188  vec.insert(vec.begin() + index, item);
    2189 }
    2190 
    2191 template<typename T, typename allocatorT>
    2192 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
    2193 {
    2194  vec.erase(vec.begin() + index);
    2195 }
    2196 
    2197 #else // #if VMA_USE_STL_VECTOR
    2198 
    2199 /* Class with interface compatible with subset of std::vector.
    2200 T must be POD because constructors and destructors are not called and memcpy is
    2201 used for these objects. */
    2202 template<typename T, typename AllocatorT>
    2203 class VmaVector
    2204 {
    2205 public:
    2206  typedef T value_type;
    2207 
    2208  VmaVector(const AllocatorT& allocator) :
    2209  m_Allocator(allocator),
    2210  m_pArray(VMA_NULL),
    2211  m_Count(0),
    2212  m_Capacity(0)
    2213  {
    2214  }
    2215 
    2216  VmaVector(size_t count, const AllocatorT& allocator) :
    2217  m_Allocator(allocator),
    2218  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
    2219  m_Count(count),
    2220  m_Capacity(count)
    2221  {
    2222  }
    2223 
    2224  VmaVector(const VmaVector<T, AllocatorT>& src) :
    2225  m_Allocator(src.m_Allocator),
    2226  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
    2227  m_Count(src.m_Count),
    2228  m_Capacity(src.m_Count)
    2229  {
    2230  if(m_Count != 0)
    2231  {
    2232  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
    2233  }
    2234  }
    2235 
    2236  ~VmaVector()
    2237  {
    2238  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
    2239  }
    2240 
    2241  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
    2242  {
    2243  if(&rhs != this)
    2244  {
    2245  resize(rhs.m_Count);
    2246  if(m_Count != 0)
    2247  {
    2248  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
    2249  }
    2250  }
    2251  return *this;
    2252  }
    2253 
    2254  bool empty() const { return m_Count == 0; }
    2255  size_t size() const { return m_Count; }
    2256  T* data() { return m_pArray; }
    2257  const T* data() const { return m_pArray; }
    2258 
    2259  T& operator[](size_t index)
    2260  {
    2261  VMA_HEAVY_ASSERT(index < m_Count);
    2262  return m_pArray[index];
    2263  }
    2264  const T& operator[](size_t index) const
    2265  {
    2266  VMA_HEAVY_ASSERT(index < m_Count);
    2267  return m_pArray[index];
    2268  }
    2269 
    2270  T& front()
    2271  {
    2272  VMA_HEAVY_ASSERT(m_Count > 0);
    2273  return m_pArray[0];
    2274  }
    2275  const T& front() const
    2276  {
    2277  VMA_HEAVY_ASSERT(m_Count > 0);
    2278  return m_pArray[0];
    2279  }
    2280  T& back()
    2281  {
    2282  VMA_HEAVY_ASSERT(m_Count > 0);
    2283  return m_pArray[m_Count - 1];
    2284  }
    2285  const T& back() const
    2286  {
    2287  VMA_HEAVY_ASSERT(m_Count > 0);
    2288  return m_pArray[m_Count - 1];
    2289  }
    2290 
    2291  void reserve(size_t newCapacity, bool freeMemory = false)
    2292  {
    2293  newCapacity = VMA_MAX(newCapacity, m_Count);
    2294 
    2295  if((newCapacity < m_Capacity) && !freeMemory)
    2296  {
    2297  newCapacity = m_Capacity;
    2298  }
    2299 
    2300  if(newCapacity != m_Capacity)
    2301  {
    2302  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
    2303  if(m_Count != 0)
    2304  {
    2305  memcpy(newArray, m_pArray, m_Count * sizeof(T));
    2306  }
    2307  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
    2308  m_Capacity = newCapacity;
    2309  m_pArray = newArray;
    2310  }
    2311  }
    2312 
    2313  void resize(size_t newCount, bool freeMemory = false)
    2314  {
    2315  size_t newCapacity = m_Capacity;
    2316  if(newCount > m_Capacity)
    2317  {
    2318  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
    2319  }
    2320  else if(freeMemory)
    2321  {
    2322  newCapacity = newCount;
    2323  }
    2324 
    2325  if(newCapacity != m_Capacity)
    2326  {
    2327  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
    2328  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
    2329  if(elementsToCopy != 0)
    2330  {
    2331  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
    2332  }
    2333  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
    2334  m_Capacity = newCapacity;
    2335  m_pArray = newArray;
    2336  }
    2337 
    2338  m_Count = newCount;
    2339  }
    2340 
    2341  void clear(bool freeMemory = false)
    2342  {
    2343  resize(0, freeMemory);
    2344  }
    2345 
    2346  void insert(size_t index, const T& src)
    2347  {
    2348  VMA_HEAVY_ASSERT(index <= m_Count);
    2349  const size_t oldCount = size();
    2350  resize(oldCount + 1);
    2351  if(index < oldCount)
    2352  {
    2353  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
    2354  }
    2355  m_pArray[index] = src;
    2356  }
    2357 
    2358  void remove(size_t index)
    2359  {
    2360  VMA_HEAVY_ASSERT(index < m_Count);
    2361  const size_t oldCount = size();
    2362  if(index < oldCount - 1)
    2363  {
    2364  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
    2365  }
    2366  resize(oldCount - 1);
    2367  }
    2368 
    2369  void push_back(const T& src)
    2370  {
    2371  const size_t newIndex = size();
    2372  resize(newIndex + 1);
    2373  m_pArray[newIndex] = src;
    2374  }
    2375 
    2376  void pop_back()
    2377  {
    2378  VMA_HEAVY_ASSERT(m_Count > 0);
    2379  resize(size() - 1);
    2380  }
    2381 
    2382  void push_front(const T& src)
    2383  {
    2384  insert(0, src);
    2385  }
    2386 
    2387  void pop_front()
    2388  {
    2389  VMA_HEAVY_ASSERT(m_Count > 0);
    2390  remove(0);
    2391  }
    2392 
    2393  typedef T* iterator;
    2394 
    2395  iterator begin() { return m_pArray; }
    2396  iterator end() { return m_pArray + m_Count; }
    2397 
    2398 private:
    2399  AllocatorT m_Allocator;
    2400  T* m_pArray;
    2401  size_t m_Count;
    2402  size_t m_Capacity;
    2403 };
    2404 
    2405 template<typename T, typename allocatorT>
    2406 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
    2407 {
    2408  vec.insert(index, item);
    2409 }
    2410 
    2411 template<typename T, typename allocatorT>
    2412 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
    2413 {
    2414  vec.remove(index);
    2415 }
    2416 
    2417 #endif // #if VMA_USE_STL_VECTOR
    2418 
    2419 template<typename CmpLess, typename VectorT>
    2420 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
    2421 {
    2422  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
    2423  vector.data(),
    2424  vector.data() + vector.size(),
    2425  value,
    2426  CmpLess()) - vector.data();
    2427  VmaVectorInsert(vector, indexToInsert, value);
    2428  return indexToInsert;
    2429 }
    2430 
    2431 template<typename CmpLess, typename VectorT>
    2432 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
    2433 {
    2434  CmpLess comparator;
    2435  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
    2436  vector.begin(),
    2437  vector.end(),
    2438  value,
    2439  comparator);
    2440  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
    2441  {
    2442  size_t indexToRemove = it - vector.begin();
    2443  VmaVectorRemove(vector, indexToRemove);
    2444  return true;
    2445  }
    2446  return false;
    2447 }
    2448 
    2449 template<typename CmpLess, typename VectorT>
    2450 size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)
    2451 {
    2452  CmpLess comparator;
    2453  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
    2454  vector.data(),
    2455  vector.data() + vector.size(),
    2456  value,
    2457  comparator);
    2458  if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))
    2459  {
    2460  return it - vector.begin();
    2461  }
    2462  else
    2463  {
    2464  return vector.size();
    2465  }
    2466 }
    2467 
    2469 // class VmaPoolAllocator
    2470 
    2471 /*
    2472 Allocator for objects of type T using a list of arrays (pools) to speed up
    2473 allocation. Number of elements that can be allocated is not bounded because
    2474 allocator can create multiple blocks.
    2475 */
    2476 template<typename T>
    2477 class VmaPoolAllocator
    2478 {
    2479 public:
    2480  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
    2481  ~VmaPoolAllocator();
    2482  void Clear();
    2483  T* Alloc();
    2484  void Free(T* ptr);
    2485 
    2486 private:
    2487  union Item
    2488  {
    2489  uint32_t NextFreeIndex;
    2490  T Value;
    2491  };
    2492 
    2493  struct ItemBlock
    2494  {
    2495  Item* pItems;
    2496  uint32_t FirstFreeIndex;
    2497  };
    2498 
    2499  const VkAllocationCallbacks* m_pAllocationCallbacks;
    2500  size_t m_ItemsPerBlock;
    2501  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
    2502 
    2503  ItemBlock& CreateNewBlock();
    2504 };
    2505 
    2506 template<typename T>
    2507 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
    2508  m_pAllocationCallbacks(pAllocationCallbacks),
    2509  m_ItemsPerBlock(itemsPerBlock),
    2510  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
    2511 {
    2512  VMA_ASSERT(itemsPerBlock > 0);
    2513 }
    2514 
    2515 template<typename T>
    2516 VmaPoolAllocator<T>::~VmaPoolAllocator()
    2517 {
    2518  Clear();
    2519 }
    2520 
    2521 template<typename T>
    2522 void VmaPoolAllocator<T>::Clear()
    2523 {
    2524  for(size_t i = m_ItemBlocks.size(); i--; )
    2525  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
    2526  m_ItemBlocks.clear();
    2527 }
    2528 
    2529 template<typename T>
    2530 T* VmaPoolAllocator<T>::Alloc()
    2531 {
    2532  for(size_t i = m_ItemBlocks.size(); i--; )
    2533  {
    2534  ItemBlock& block = m_ItemBlocks[i];
    2535  // This block has some free items: Use first one.
    2536  if(block.FirstFreeIndex != UINT32_MAX)
    2537  {
    2538  Item* const pItem = &block.pItems[block.FirstFreeIndex];
    2539  block.FirstFreeIndex = pItem->NextFreeIndex;
    2540  return &pItem->Value;
    2541  }
    2542  }
    2543 
    2544  // No block has free item: Create new one and use it.
    2545  ItemBlock& newBlock = CreateNewBlock();
    2546  Item* const pItem = &newBlock.pItems[0];
    2547  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
    2548  return &pItem->Value;
    2549 }
    2550 
    2551 template<typename T>
    2552 void VmaPoolAllocator<T>::Free(T* ptr)
    2553 {
    2554  // Search all memory blocks to find ptr.
    2555  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
    2556  {
    2557  ItemBlock& block = m_ItemBlocks[i];
    2558 
    2559  // Casting to union.
    2560  Item* pItemPtr;
    2561  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
    2562 
    2563  // Check if pItemPtr is in address range of this block.
    2564  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
    2565  {
    2566  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
    2567  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
    2568  block.FirstFreeIndex = index;
    2569  return;
    2570  }
    2571  }
    2572  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
    2573 }
    2574 
    2575 template<typename T>
    2576 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
    2577 {
    2578  ItemBlock newBlock = {
    2579  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
    2580 
    2581  m_ItemBlocks.push_back(newBlock);
    2582 
    2583  // Setup singly-linked list of all free items in this block.
    2584  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
    2585  newBlock.pItems[i].NextFreeIndex = i + 1;
    2586  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
    2587  return m_ItemBlocks.back();
    2588 }
    2589 
    2591 // class VmaRawList, VmaList
    2592 
    2593 #if VMA_USE_STL_LIST
    2594 
    2595 #define VmaList std::list
    2596 
    2597 #else // #if VMA_USE_STL_LIST
    2598 
    2599 template<typename T>
    2600 struct VmaListItem
    2601 {
    2602  VmaListItem* pPrev;
    2603  VmaListItem* pNext;
    2604  T Value;
    2605 };
    2606 
    2607 // Doubly linked list.
    2608 template<typename T>
    2609 class VmaRawList
    2610 {
    2611 public:
    2612  typedef VmaListItem<T> ItemType;
    2613 
    2614  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
    2615  ~VmaRawList();
    2616  void Clear();
    2617 
    2618  size_t GetCount() const { return m_Count; }
    2619  bool IsEmpty() const { return m_Count == 0; }
    2620 
    2621  ItemType* Front() { return m_pFront; }
    2622  const ItemType* Front() const { return m_pFront; }
    2623  ItemType* Back() { return m_pBack; }
    2624  const ItemType* Back() const { return m_pBack; }
    2625 
    2626  ItemType* PushBack();
    2627  ItemType* PushFront();
    2628  ItemType* PushBack(const T& value);
    2629  ItemType* PushFront(const T& value);
    2630  void PopBack();
    2631  void PopFront();
    2632 
    2633  // Item can be null - it means PushBack.
    2634  ItemType* InsertBefore(ItemType* pItem);
    2635  // Item can be null - it means PushFront.
    2636  ItemType* InsertAfter(ItemType* pItem);
    2637 
    2638  ItemType* InsertBefore(ItemType* pItem, const T& value);
    2639  ItemType* InsertAfter(ItemType* pItem, const T& value);
    2640 
    2641  void Remove(ItemType* pItem);
    2642 
    2643 private:
    2644  const VkAllocationCallbacks* const m_pAllocationCallbacks;
    2645  VmaPoolAllocator<ItemType> m_ItemAllocator;
    2646  ItemType* m_pFront;
    2647  ItemType* m_pBack;
    2648  size_t m_Count;
    2649 
    2650  // Declared not defined, to block copy constructor and assignment operator.
    2651  VmaRawList(const VmaRawList<T>& src);
    2652  VmaRawList<T>& operator=(const VmaRawList<T>& rhs);
    2653 };
    2654 
    2655 template<typename T>
    2656 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
    2657  m_pAllocationCallbacks(pAllocationCallbacks),
    2658  m_ItemAllocator(pAllocationCallbacks, 128),
    2659  m_pFront(VMA_NULL),
    2660  m_pBack(VMA_NULL),
    2661  m_Count(0)
    2662 {
    2663 }
    2664 
    2665 template<typename T>
    2666 VmaRawList<T>::~VmaRawList()
    2667 {
    2668  // Intentionally not calling Clear, because that would be unnecessary
    2669  // computations to return all items to m_ItemAllocator as free.
    2670 }
    2671 
    2672 template<typename T>
    2673 void VmaRawList<T>::Clear()
    2674 {
    2675  if(IsEmpty() == false)
    2676  {
    2677  ItemType* pItem = m_pBack;
    2678  while(pItem != VMA_NULL)
    2679  {
    2680  ItemType* const pPrevItem = pItem->pPrev;
    2681  m_ItemAllocator.Free(pItem);
    2682  pItem = pPrevItem;
    2683  }
    2684  m_pFront = VMA_NULL;
    2685  m_pBack = VMA_NULL;
    2686  m_Count = 0;
    2687  }
    2688 }
    2689 
    2690 template<typename T>
    2691 VmaListItem<T>* VmaRawList<T>::PushBack()
    2692 {
    2693  ItemType* const pNewItem = m_ItemAllocator.Alloc();
    2694  pNewItem->pNext = VMA_NULL;
    2695  if(IsEmpty())
    2696  {
    2697  pNewItem->pPrev = VMA_NULL;
    2698  m_pFront = pNewItem;
    2699  m_pBack = pNewItem;
    2700  m_Count = 1;
    2701  }
    2702  else
    2703  {
    2704  pNewItem->pPrev = m_pBack;
    2705  m_pBack->pNext = pNewItem;
    2706  m_pBack = pNewItem;
    2707  ++m_Count;
    2708  }
    2709  return pNewItem;
    2710 }
    2711 
    2712 template<typename T>
    2713 VmaListItem<T>* VmaRawList<T>::PushFront()
    2714 {
    2715  ItemType* const pNewItem = m_ItemAllocator.Alloc();
    2716  pNewItem->pPrev = VMA_NULL;
    2717  if(IsEmpty())
    2718  {
    2719  pNewItem->pNext = VMA_NULL;
    2720  m_pFront = pNewItem;
    2721  m_pBack = pNewItem;
    2722  m_Count = 1;
    2723  }
    2724  else
    2725  {
    2726  pNewItem->pNext = m_pFront;
    2727  m_pFront->pPrev = pNewItem;
    2728  m_pFront = pNewItem;
    2729  ++m_Count;
    2730  }
    2731  return pNewItem;
    2732 }
    2733 
    2734 template<typename T>
    2735 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
    2736 {
    2737  ItemType* const pNewItem = PushBack();
    2738  pNewItem->Value = value;
    2739  return pNewItem;
    2740 }
    2741 
    2742 template<typename T>
    2743 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
    2744 {
    2745  ItemType* const pNewItem = PushFront();
    2746  pNewItem->Value = value;
    2747  return pNewItem;
    2748 }
    2749 
    2750 template<typename T>
    2751 void VmaRawList<T>::PopBack()
    2752 {
    2753  VMA_HEAVY_ASSERT(m_Count > 0);
    2754  ItemType* const pBackItem = m_pBack;
    2755  ItemType* const pPrevItem = pBackItem->pPrev;
    2756  if(pPrevItem != VMA_NULL)
    2757  {
    2758  pPrevItem->pNext = VMA_NULL;
    2759  }
    2760  m_pBack = pPrevItem;
    2761  m_ItemAllocator.Free(pBackItem);
    2762  --m_Count;
    2763 }
    2764 
    2765 template<typename T>
    2766 void VmaRawList<T>::PopFront()
    2767 {
    2768  VMA_HEAVY_ASSERT(m_Count > 0);
    2769  ItemType* const pFrontItem = m_pFront;
    2770  ItemType* const pNextItem = pFrontItem->pNext;
    2771  if(pNextItem != VMA_NULL)
    2772  {
    2773  pNextItem->pPrev = VMA_NULL;
    2774  }
    2775  m_pFront = pNextItem;
    2776  m_ItemAllocator.Free(pFrontItem);
    2777  --m_Count;
    2778 }
    2779 
    2780 template<typename T>
    2781 void VmaRawList<T>::Remove(ItemType* pItem)
    2782 {
    2783  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
    2784  VMA_HEAVY_ASSERT(m_Count > 0);
    2785 
    2786  if(pItem->pPrev != VMA_NULL)
    2787  {
    2788  pItem->pPrev->pNext = pItem->pNext;
    2789  }
    2790  else
    2791  {
    2792  VMA_HEAVY_ASSERT(m_pFront == pItem);
    2793  m_pFront = pItem->pNext;
    2794  }
    2795 
    2796  if(pItem->pNext != VMA_NULL)
    2797  {
    2798  pItem->pNext->pPrev = pItem->pPrev;
    2799  }
    2800  else
    2801  {
    2802  VMA_HEAVY_ASSERT(m_pBack == pItem);
    2803  m_pBack = pItem->pPrev;
    2804  }
    2805 
    2806  m_ItemAllocator.Free(pItem);
    2807  --m_Count;
    2808 }
    2809 
    2810 template<typename T>
    2811 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
    2812 {
    2813  if(pItem != VMA_NULL)
    2814  {
    2815  ItemType* const prevItem = pItem->pPrev;
    2816  ItemType* const newItem = m_ItemAllocator.Alloc();
    2817  newItem->pPrev = prevItem;
    2818  newItem->pNext = pItem;
    2819  pItem->pPrev = newItem;
    2820  if(prevItem != VMA_NULL)
    2821  {
    2822  prevItem->pNext = newItem;
    2823  }
    2824  else
    2825  {
    2826  VMA_HEAVY_ASSERT(m_pFront == pItem);
    2827  m_pFront = newItem;
    2828  }
    2829  ++m_Count;
    2830  return newItem;
    2831  }
    2832  else
    2833  return PushBack();
    2834 }
    2835 
    2836 template<typename T>
    2837 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
    2838 {
    2839  if(pItem != VMA_NULL)
    2840  {
    2841  ItemType* const nextItem = pItem->pNext;
    2842  ItemType* const newItem = m_ItemAllocator.Alloc();
    2843  newItem->pNext = nextItem;
    2844  newItem->pPrev = pItem;
    2845  pItem->pNext = newItem;
    2846  if(nextItem != VMA_NULL)
    2847  {
    2848  nextItem->pPrev = newItem;
    2849  }
    2850  else
    2851  {
    2852  VMA_HEAVY_ASSERT(m_pBack == pItem);
    2853  m_pBack = newItem;
    2854  }
    2855  ++m_Count;
    2856  return newItem;
    2857  }
    2858  else
    2859  return PushFront();
    2860 }
    2861 
    2862 template<typename T>
    2863 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
    2864 {
    2865  ItemType* const newItem = InsertBefore(pItem);
    2866  newItem->Value = value;
    2867  return newItem;
    2868 }
    2869 
    2870 template<typename T>
    2871 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
    2872 {
    2873  ItemType* const newItem = InsertAfter(pItem);
    2874  newItem->Value = value;
    2875  return newItem;
    2876 }
    2877 
    2878 template<typename T, typename AllocatorT>
    2879 class VmaList
    2880 {
    2881 public:
    2882  class iterator
    2883  {
    2884  public:
    2885  iterator() :
    2886  m_pList(VMA_NULL),
    2887  m_pItem(VMA_NULL)
    2888  {
    2889  }
    2890 
    2891  T& operator*() const
    2892  {
    2893  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2894  return m_pItem->Value;
    2895  }
    2896  T* operator->() const
    2897  {
    2898  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2899  return &m_pItem->Value;
    2900  }
    2901 
    2902  iterator& operator++()
    2903  {
    2904  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2905  m_pItem = m_pItem->pNext;
    2906  return *this;
    2907  }
    2908  iterator& operator--()
    2909  {
    2910  if(m_pItem != VMA_NULL)
    2911  {
    2912  m_pItem = m_pItem->pPrev;
    2913  }
    2914  else
    2915  {
    2916  VMA_HEAVY_ASSERT(!m_pList.IsEmpty());
    2917  m_pItem = m_pList->Back();
    2918  }
    2919  return *this;
    2920  }
    2921 
    2922  iterator operator++(int)
    2923  {
    2924  iterator result = *this;
    2925  ++*this;
    2926  return result;
    2927  }
    2928  iterator operator--(int)
    2929  {
    2930  iterator result = *this;
    2931  --*this;
    2932  return result;
    2933  }
    2934 
    2935  bool operator==(const iterator& rhs) const
    2936  {
    2937  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    2938  return m_pItem == rhs.m_pItem;
    2939  }
    2940  bool operator!=(const iterator& rhs) const
    2941  {
    2942  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    2943  return m_pItem != rhs.m_pItem;
    2944  }
    2945 
    2946  private:
    2947  VmaRawList<T>* m_pList;
    2948  VmaListItem<T>* m_pItem;
    2949 
    2950  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
    2951  m_pList(pList),
    2952  m_pItem(pItem)
    2953  {
    2954  }
    2955 
    2956  friend class VmaList<T, AllocatorT>;
    2957  };
    2958 
    2959  class const_iterator
    2960  {
    2961  public:
    2962  const_iterator() :
    2963  m_pList(VMA_NULL),
    2964  m_pItem(VMA_NULL)
    2965  {
    2966  }
    2967 
    2968  const_iterator(const iterator& src) :
    2969  m_pList(src.m_pList),
    2970  m_pItem(src.m_pItem)
    2971  {
    2972  }
    2973 
    2974  const T& operator*() const
    2975  {
    2976  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2977  return m_pItem->Value;
    2978  }
    2979  const T* operator->() const
    2980  {
    2981  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2982  return &m_pItem->Value;
    2983  }
    2984 
    2985  const_iterator& operator++()
    2986  {
    2987  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2988  m_pItem = m_pItem->pNext;
    2989  return *this;
    2990  }
    2991  const_iterator& operator--()
    2992  {
    2993  if(m_pItem != VMA_NULL)
    2994  {
    2995  m_pItem = m_pItem->pPrev;
    2996  }
    2997  else
    2998  {
    2999  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
    3000  m_pItem = m_pList->Back();
    3001  }
    3002  return *this;
    3003  }
    3004 
    3005  const_iterator operator++(int)
    3006  {
    3007  const_iterator result = *this;
    3008  ++*this;
    3009  return result;
    3010  }
    3011  const_iterator operator--(int)
    3012  {
    3013  const_iterator result = *this;
    3014  --*this;
    3015  return result;
    3016  }
    3017 
    3018  bool operator==(const const_iterator& rhs) const
    3019  {
    3020  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    3021  return m_pItem == rhs.m_pItem;
    3022  }
    3023  bool operator!=(const const_iterator& rhs) const
    3024  {
    3025  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    3026  return m_pItem != rhs.m_pItem;
    3027  }
    3028 
    3029  private:
    3030  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
    3031  m_pList(pList),
    3032  m_pItem(pItem)
    3033  {
    3034  }
    3035 
    3036  const VmaRawList<T>* m_pList;
    3037  const VmaListItem<T>* m_pItem;
    3038 
    3039  friend class VmaList<T, AllocatorT>;
    3040  };
    3041 
    3042  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
    3043 
    3044  bool empty() const { return m_RawList.IsEmpty(); }
    3045  size_t size() const { return m_RawList.GetCount(); }
    3046 
    3047  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
    3048  iterator end() { return iterator(&m_RawList, VMA_NULL); }
    3049 
    3050  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
    3051  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
    3052 
    3053  void clear() { m_RawList.Clear(); }
    3054  void push_back(const T& value) { m_RawList.PushBack(value); }
    3055  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
    3056  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
    3057 
    3058 private:
    3059  VmaRawList<T> m_RawList;
    3060 };
    3061 
    3062 #endif // #if VMA_USE_STL_LIST
    3063 
    3065 // class VmaMap
    3066 
    3067 // Unused in this version.
    3068 #if 0
    3069 
    3070 #if VMA_USE_STL_UNORDERED_MAP
    3071 
    3072 #define VmaPair std::pair
    3073 
    3074 #define VMA_MAP_TYPE(KeyT, ValueT) \
    3075  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
    3076 
    3077 #else // #if VMA_USE_STL_UNORDERED_MAP
    3078 
    3079 template<typename T1, typename T2>
    3080 struct VmaPair
    3081 {
    3082  T1 first;
    3083  T2 second;
    3084 
    3085  VmaPair() : first(), second() { }
    3086  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
    3087 };
    3088 
    3089 /* Class compatible with subset of interface of std::unordered_map.
    3090 KeyT, ValueT must be POD because they will be stored in VmaVector.
    3091 */
    3092 template<typename KeyT, typename ValueT>
    3093 class VmaMap
    3094 {
    3095 public:
    3096  typedef VmaPair<KeyT, ValueT> PairType;
    3097  typedef PairType* iterator;
    3098 
    3099  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
    3100 
    3101  iterator begin() { return m_Vector.begin(); }
    3102  iterator end() { return m_Vector.end(); }
    3103 
    3104  void insert(const PairType& pair);
    3105  iterator find(const KeyT& key);
    3106  void erase(iterator it);
    3107 
    3108 private:
    3109  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
    3110 };
    3111 
    3112 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
    3113 
    3114 template<typename FirstT, typename SecondT>
    3115 struct VmaPairFirstLess
    3116 {
    3117  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
    3118  {
    3119  return lhs.first < rhs.first;
    3120  }
    3121  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
    3122  {
    3123  return lhs.first < rhsFirst;
    3124  }
    3125 };
    3126 
    3127 template<typename KeyT, typename ValueT>
    3128 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
    3129 {
    3130  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
    3131  m_Vector.data(),
    3132  m_Vector.data() + m_Vector.size(),
    3133  pair,
    3134  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
    3135  VmaVectorInsert(m_Vector, indexToInsert, pair);
    3136 }
    3137 
    3138 template<typename KeyT, typename ValueT>
    3139 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
    3140 {
    3141  PairType* it = VmaBinaryFindFirstNotLess(
    3142  m_Vector.data(),
    3143  m_Vector.data() + m_Vector.size(),
    3144  key,
    3145  VmaPairFirstLess<KeyT, ValueT>());
    3146  if((it != m_Vector.end()) && (it->first == key))
    3147  {
    3148  return it;
    3149  }
    3150  else
    3151  {
    3152  return m_Vector.end();
    3153  }
    3154 }
    3155 
    3156 template<typename KeyT, typename ValueT>
    3157 void VmaMap<KeyT, ValueT>::erase(iterator it)
    3158 {
    3159  VmaVectorRemove(m_Vector, it - m_Vector.begin());
    3160 }
    3161 
    3162 #endif // #if VMA_USE_STL_UNORDERED_MAP
    3163 
    3164 #endif // #if 0
    3165 
    3167 
    3168 class VmaDeviceMemoryBlock;
    3169 
    3170 struct VmaAllocation_T
    3171 {
    3172 private:
    3173  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
    3174 
    3175  enum FLAGS
    3176  {
    3177  FLAG_USER_DATA_STRING = 0x01,
    3178  };
    3179 
    3180 public:
    3181  enum ALLOCATION_TYPE
    3182  {
    3183  ALLOCATION_TYPE_NONE,
    3184  ALLOCATION_TYPE_BLOCK,
    3185  ALLOCATION_TYPE_DEDICATED,
    3186  };
    3187 
    3188  VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
    3189  m_Alignment(1),
    3190  m_Size(0),
    3191  m_pUserData(VMA_NULL),
    3192  m_LastUseFrameIndex(currentFrameIndex),
    3193  m_Type((uint8_t)ALLOCATION_TYPE_NONE),
    3194  m_SuballocationType((uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN),
    3195  m_MapCount(0),
    3196  m_Flags(userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0)
    3197  {
    3198  }
    3199 
    3200  ~VmaAllocation_T()
    3201  {
    3202  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
    3203 
    3204  // Check if owned string was freed.
    3205  VMA_ASSERT(m_pUserData == VMA_NULL);
    3206  }
    3207 
    3208  void InitBlockAllocation(
    3209  VmaPool hPool,
    3210  VmaDeviceMemoryBlock* block,
    3211  VkDeviceSize offset,
    3212  VkDeviceSize alignment,
    3213  VkDeviceSize size,
    3214  VmaSuballocationType suballocationType,
    3215  bool mapped,
    3216  bool canBecomeLost)
    3217  {
    3218  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    3219  VMA_ASSERT(block != VMA_NULL);
    3220  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
    3221  m_Alignment = alignment;
    3222  m_Size = size;
    3223  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
    3224  m_SuballocationType = (uint8_t)suballocationType;
    3225  m_BlockAllocation.m_hPool = hPool;
    3226  m_BlockAllocation.m_Block = block;
    3227  m_BlockAllocation.m_Offset = offset;
    3228  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
    3229  }
    3230 
    3231  void InitLost()
    3232  {
    3233  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    3234  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
    3235  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
    3236  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
    3237  m_BlockAllocation.m_Block = VMA_NULL;
    3238  m_BlockAllocation.m_Offset = 0;
    3239  m_BlockAllocation.m_CanBecomeLost = true;
    3240  }
    3241 
    3242  void ChangeBlockAllocation(
    3243  VmaDeviceMemoryBlock* block,
    3244  VkDeviceSize offset)
    3245  {
    3246  VMA_ASSERT(block != VMA_NULL);
    3247  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    3248  m_BlockAllocation.m_Block = block;
    3249  m_BlockAllocation.m_Offset = offset;
    3250  }
    3251 
    3252  // pMappedData not null means allocation is created with MAPPED flag.
    3253  void InitDedicatedAllocation(
    3254  uint32_t memoryTypeIndex,
    3255  VkDeviceMemory hMemory,
    3256  VmaSuballocationType suballocationType,
    3257  void* pMappedData,
    3258  VkDeviceSize size)
    3259  {
    3260  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    3261  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
    3262  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
    3263  m_Alignment = 0;
    3264  m_Size = size;
    3265  m_SuballocationType = (uint8_t)suballocationType;
    3266  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
    3267  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
    3268  m_DedicatedAllocation.m_hMemory = hMemory;
    3269  m_DedicatedAllocation.m_pMappedData = pMappedData;
    3270  }
    3271 
    3272  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
    3273  VkDeviceSize GetAlignment() const { return m_Alignment; }
    3274  VkDeviceSize GetSize() const { return m_Size; }
    3275  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
    3276  void* GetUserData() const { return m_pUserData; }
    3277  void SetUserData(VmaAllocator hAllocator, void* pUserData);
    3278  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
    3279 
    3280  VmaDeviceMemoryBlock* GetBlock() const
    3281  {
    3282  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    3283  return m_BlockAllocation.m_Block;
    3284  }
    3285  VkDeviceSize GetOffset() const;
    3286  VkDeviceMemory GetMemory() const;
    3287  uint32_t GetMemoryTypeIndex() const;
    3288  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
    3289  void* GetMappedData() const;
    3290  bool CanBecomeLost() const;
    3291  VmaPool GetPool() const;
    3292 
    3293  uint32_t GetLastUseFrameIndex() const
    3294  {
    3295  return m_LastUseFrameIndex.load();
    3296  }
    3297  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
    3298  {
    3299  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
    3300  }
    3301  /*
    3302  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
    3303  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
    3304  - Else, returns false.
    3305 
    3306  If hAllocation is already lost, assert - you should not call it then.
    3307  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
    3308  */
    3309  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
    3310 
    3311  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
    3312  {
    3313  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
    3314  outInfo.blockCount = 1;
    3315  outInfo.allocationCount = 1;
    3316  outInfo.unusedRangeCount = 0;
    3317  outInfo.usedBytes = m_Size;
    3318  outInfo.unusedBytes = 0;
    3319  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
    3320  outInfo.unusedRangeSizeMin = UINT64_MAX;
    3321  outInfo.unusedRangeSizeMax = 0;
    3322  }
    3323 
    3324  void BlockAllocMap();
    3325  void BlockAllocUnmap();
    3326  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
    3327  void DedicatedAllocUnmap(VmaAllocator hAllocator);
    3328 
    3329 private:
    3330  VkDeviceSize m_Alignment;
    3331  VkDeviceSize m_Size;
    3332  void* m_pUserData;
    3333  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
    3334  uint8_t m_Type; // ALLOCATION_TYPE
    3335  uint8_t m_SuballocationType; // VmaSuballocationType
    3336  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
    3337  // Bits with mask 0x7F, used only when ALLOCATION_TYPE_DEDICATED, are reference counter for vmaMapMemory()/vmaUnmapMemory().
    3338  uint8_t m_MapCount;
    3339  uint8_t m_Flags; // enum FLAGS
    3340 
    3341  // Allocation out of VmaDeviceMemoryBlock.
    3342  struct BlockAllocation
    3343  {
    3344  VmaPool m_hPool; // Null if belongs to general memory.
    3345  VmaDeviceMemoryBlock* m_Block;
    3346  VkDeviceSize m_Offset;
    3347  bool m_CanBecomeLost;
    3348  };
    3349 
    3350  // Allocation for an object that has its own private VkDeviceMemory.
    3351  struct DedicatedAllocation
    3352  {
    3353  uint32_t m_MemoryTypeIndex;
    3354  VkDeviceMemory m_hMemory;
    3355  void* m_pMappedData; // Not null means memory is mapped.
    3356  };
    3357 
    3358  union
    3359  {
    3360  // Allocation out of VmaDeviceMemoryBlock.
    3361  BlockAllocation m_BlockAllocation;
    3362  // Allocation for an object that has its own private VkDeviceMemory.
    3363  DedicatedAllocation m_DedicatedAllocation;
    3364  };
    3365 
    3366  void FreeUserDataString(VmaAllocator hAllocator);
    3367 };
    3368 
    3369 /*
    3370 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
    3371 allocated memory block or free.
    3372 */
    3373 struct VmaSuballocation
    3374 {
    3375  VkDeviceSize offset;
    3376  VkDeviceSize size;
    3377  VmaAllocation hAllocation;
    3378  VmaSuballocationType type;
    3379 };
    3380 
    3381 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
    3382 
    3383 // Cost of one additional allocation lost, as equivalent in bytes.
    3384 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
    3385 
    3386 /*
    3387 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
    3388 
    3389 If canMakeOtherLost was false:
    3390 - item points to a FREE suballocation.
    3391 - itemsToMakeLostCount is 0.
    3392 
    3393 If canMakeOtherLost was true:
    3394 - item points to first of sequence of suballocations, which are either FREE,
    3395  or point to VmaAllocations that can become lost.
    3396 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
    3397  the requested allocation to succeed.
    3398 */
    3399 struct VmaAllocationRequest
    3400 {
    3401  VkDeviceSize offset;
    3402  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
    3403  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
    3404  VmaSuballocationList::iterator item;
    3405  size_t itemsToMakeLostCount;
    3406 
    3407  VkDeviceSize CalcCost() const
    3408  {
    3409  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
    3410  }
    3411 };
    3412 
    3413 /*
    3414 Data structure used for bookkeeping of allocations and unused ranges of memory
    3415 in a single VkDeviceMemory block.
    3416 */
    3417 class VmaBlockMetadata
    3418 {
    3419 public:
    3420  VmaBlockMetadata(VmaAllocator hAllocator);
    3421  ~VmaBlockMetadata();
    3422  void Init(VkDeviceSize size);
    3423 
    3424  // Validates all data structures inside this object. If not valid, returns false.
    3425  bool Validate() const;
    3426  VkDeviceSize GetSize() const { return m_Size; }
    3427  size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
    3428  VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
    3429  VkDeviceSize GetUnusedRangeSizeMax() const;
    3430  // Returns true if this block is empty - contains only single free suballocation.
    3431  bool IsEmpty() const;
    3432 
    3433  void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
    3434  void AddPoolStats(VmaPoolStats& inoutStats) const;
    3435 
    3436 #if VMA_STATS_STRING_ENABLED
    3437  void PrintDetailedMap(class VmaJsonWriter& json) const;
    3438 #endif
    3439 
    3440  // Creates trivial request for case when block is empty.
    3441  void CreateFirstAllocationRequest(VmaAllocationRequest* pAllocationRequest);
    3442 
    3443  // Tries to find a place for suballocation with given parameters inside this block.
    3444  // If succeeded, fills pAllocationRequest and returns true.
    3445  // If failed, returns false.
    3446  bool CreateAllocationRequest(
    3447  uint32_t currentFrameIndex,
    3448  uint32_t frameInUseCount,
    3449  VkDeviceSize bufferImageGranularity,
    3450  VkDeviceSize allocSize,
    3451  VkDeviceSize allocAlignment,
    3452  VmaSuballocationType allocType,
    3453  bool canMakeOtherLost,
    3454  VmaAllocationRequest* pAllocationRequest);
    3455 
    3456  bool MakeRequestedAllocationsLost(
    3457  uint32_t currentFrameIndex,
    3458  uint32_t frameInUseCount,
    3459  VmaAllocationRequest* pAllocationRequest);
    3460 
    3461  uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
    3462 
    3463  // Makes actual allocation based on request. Request must already be checked and valid.
    3464  void Alloc(
    3465  const VmaAllocationRequest& request,
    3466  VmaSuballocationType type,
    3467  VkDeviceSize allocSize,
    3468  VmaAllocation hAllocation);
    3469 
    3470  // Frees suballocation assigned to given memory region.
    3471  void Free(const VmaAllocation allocation);
    3472 
    3473 private:
    3474  VkDeviceSize m_Size;
    3475  uint32_t m_FreeCount;
    3476  VkDeviceSize m_SumFreeSize;
    3477  VmaSuballocationList m_Suballocations;
    3478  // Suballocations that are free and have size greater than certain threshold.
    3479  // Sorted by size, ascending.
    3480  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
    3481 
    3482  bool ValidateFreeSuballocationList() const;
    3483 
    3484  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
    3485  // If yes, fills pOffset and returns true. If no, returns false.
    3486  bool CheckAllocation(
    3487  uint32_t currentFrameIndex,
    3488  uint32_t frameInUseCount,
    3489  VkDeviceSize bufferImageGranularity,
    3490  VkDeviceSize allocSize,
    3491  VkDeviceSize allocAlignment,
    3492  VmaSuballocationType allocType,
    3493  VmaSuballocationList::const_iterator suballocItem,
    3494  bool canMakeOtherLost,
    3495  VkDeviceSize* pOffset,
    3496  size_t* itemsToMakeLostCount,
    3497  VkDeviceSize* pSumFreeSize,
    3498  VkDeviceSize* pSumItemSize) const;
    3499  // Given free suballocation, it merges it with following one, which must also be free.
    3500  void MergeFreeWithNext(VmaSuballocationList::iterator item);
    3501  // Releases given suballocation, making it free.
    3502  // Merges it with adjacent free suballocations if applicable.
    3503  // Returns iterator to new free suballocation at this place.
    3504  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
    3505  // Given free suballocation, it inserts it into sorted list of
    3506  // m_FreeSuballocationsBySize if it's suitable.
    3507  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
    3508  // Given free suballocation, it removes it from sorted list of
    3509  // m_FreeSuballocationsBySize if it's suitable.
    3510  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
    3511 };
    3512 
    3513 // Helper class that represents mapped memory. Synchronized internally.
    3514 class VmaDeviceMemoryMapping
    3515 {
    3516 public:
    3517  VmaDeviceMemoryMapping();
    3518  ~VmaDeviceMemoryMapping();
    3519 
    3520  void* GetMappedData() const { return m_pMappedData; }
    3521 
    3522  // ppData can be null.
    3523  VkResult Map(VmaAllocator hAllocator, VkDeviceMemory hMemory, void **ppData);
    3524  void Unmap(VmaAllocator hAllocator, VkDeviceMemory hMemory);
    3525 
    3526 private:
    3527  VMA_MUTEX m_Mutex;
    3528  uint32_t m_MapCount;
    3529  void* m_pMappedData;
    3530 };
    3531 
    3532 /*
    3533 Represents a single block of device memory (`VkDeviceMemory`) with all the
    3534 data about its regions (aka suballocations, `VmaAllocation`), assigned and free.
    3535 
    3536 Thread-safety: This class must be externally synchronized.
    3537 */
    3538 class VmaDeviceMemoryBlock
    3539 {
    3540 public:
    3541  uint32_t m_MemoryTypeIndex;
    3542  VkDeviceMemory m_hMemory;
    3543  VmaDeviceMemoryMapping m_Mapping;
    3544  VmaBlockMetadata m_Metadata;
    3545 
    3546  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
    3547 
    3548  ~VmaDeviceMemoryBlock()
    3549  {
    3550  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
    3551  }
    3552 
    3553  // Always call after construction.
    3554  void Init(
    3555  uint32_t newMemoryTypeIndex,
    3556  VkDeviceMemory newMemory,
    3557  VkDeviceSize newSize);
    3558  // Always call before destruction.
    3559  void Destroy(VmaAllocator allocator);
    3560 
    3561  // Validates all data structures inside this object. If not valid, returns false.
    3562  bool Validate() const;
    3563 
    3564  // ppData can be null.
    3565  VkResult Map(VmaAllocator hAllocator, void** ppData);
    3566  void Unmap(VmaAllocator hAllocator);
    3567 };
    3568 
    3569 struct VmaPointerLess
    3570 {
    3571  bool operator()(const void* lhs, const void* rhs) const
    3572  {
    3573  return lhs < rhs;
    3574  }
    3575 };
    3576 
    3577 class VmaDefragmentator;
    3578 
    3579 /*
    3580 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
    3581 Vulkan memory type.
    3582 
    3583 Synchronized internally with a mutex.
    3584 */
    3585 struct VmaBlockVector
    3586 {
    3587  VmaBlockVector(
    3588  VmaAllocator hAllocator,
    3589  uint32_t memoryTypeIndex,
    3590  VkDeviceSize preferredBlockSize,
    3591  size_t minBlockCount,
    3592  size_t maxBlockCount,
    3593  VkDeviceSize bufferImageGranularity,
    3594  uint32_t frameInUseCount,
    3595  bool isCustomPool);
    3596  ~VmaBlockVector();
    3597 
    3598  VkResult CreateMinBlocks();
    3599 
    3600  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
    3601  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
    3602  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
    3603  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
    3604 
    3605  void GetPoolStats(VmaPoolStats* pStats);
    3606 
    3607  bool IsEmpty() const { return m_Blocks.empty(); }
    3608 
    3609  VkResult Allocate(
    3610  VmaPool hCurrentPool,
    3611  uint32_t currentFrameIndex,
    3612  const VkMemoryRequirements& vkMemReq,
    3613  const VmaAllocationCreateInfo& createInfo,
    3614  VmaSuballocationType suballocType,
    3615  VmaAllocation* pAllocation);
    3616 
    3617  void Free(
    3618  VmaAllocation hAllocation);
    3619 
    3620  // Adds statistics of this BlockVector to pStats.
    3621  void AddStats(VmaStats* pStats);
    3622 
    3623 #if VMA_STATS_STRING_ENABLED
    3624  void PrintDetailedMap(class VmaJsonWriter& json);
    3625 #endif
    3626 
    3627  void MakePoolAllocationsLost(
    3628  uint32_t currentFrameIndex,
    3629  size_t* pLostAllocationCount);
    3630 
    3631  VmaDefragmentator* EnsureDefragmentator(
    3632  VmaAllocator hAllocator,
    3633  uint32_t currentFrameIndex);
    3634 
    3635  VkResult Defragment(
    3636  VmaDefragmentationStats* pDefragmentationStats,
    3637  VkDeviceSize& maxBytesToMove,
    3638  uint32_t& maxAllocationsToMove);
    3639 
    3640  void DestroyDefragmentator();
    3641 
    3642 private:
    3643  friend class VmaDefragmentator;
    3644 
    3645  const VmaAllocator m_hAllocator;
    3646  const uint32_t m_MemoryTypeIndex;
    3647  const VkDeviceSize m_PreferredBlockSize;
    3648  const size_t m_MinBlockCount;
    3649  const size_t m_MaxBlockCount;
    3650  const VkDeviceSize m_BufferImageGranularity;
    3651  const uint32_t m_FrameInUseCount;
    3652  const bool m_IsCustomPool;
    3653  VMA_MUTEX m_Mutex;
    3654  // Incrementally sorted by sumFreeSize, ascending.
    3655  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
    3656  /* There can be at most one allocation that is completely empty - a
    3657  hysteresis to avoid pessimistic case of alternating creation and destruction
    3658  of a VkDeviceMemory. */
    3659  bool m_HasEmptyBlock;
    3660  VmaDefragmentator* m_pDefragmentator;
    3661 
    3662  size_t CalcMaxBlockSize() const;
    3663 
    3664  // Finds and removes given block from vector.
    3665  void Remove(VmaDeviceMemoryBlock* pBlock);
    3666 
    3667  // Performs single step in sorting m_Blocks. They may not be fully sorted
    3668  // after this call.
    3669  void IncrementallySortBlocks();
    3670 
    3671  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
    3672 };
    3673 
    3674 struct VmaPool_T
    3675 {
    3676 public:
    3677  VmaBlockVector m_BlockVector;
    3678 
    3679  // Takes ownership.
    3680  VmaPool_T(
    3681  VmaAllocator hAllocator,
    3682  const VmaPoolCreateInfo& createInfo);
    3683  ~VmaPool_T();
    3684 
    3685  VmaBlockVector& GetBlockVector() { return m_BlockVector; }
    3686 
    3687 #if VMA_STATS_STRING_ENABLED
    3688  //void PrintDetailedMap(class VmaStringBuilder& sb);
    3689 #endif
    3690 };
    3691 
    3692 class VmaDefragmentator
    3693 {
    3694  const VmaAllocator m_hAllocator;
    3695  VmaBlockVector* const m_pBlockVector;
    3696  uint32_t m_CurrentFrameIndex;
    3697  VkDeviceSize m_BytesMoved;
    3698  uint32_t m_AllocationsMoved;
    3699 
    3700  struct AllocationInfo
    3701  {
    3702  VmaAllocation m_hAllocation;
    3703  VkBool32* m_pChanged;
    3704 
    3705  AllocationInfo() :
    3706  m_hAllocation(VK_NULL_HANDLE),
    3707  m_pChanged(VMA_NULL)
    3708  {
    3709  }
    3710  };
    3711 
    3712  struct AllocationInfoSizeGreater
    3713  {
    3714  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
    3715  {
    3716  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
    3717  }
    3718  };
    3719 
    3720  // Used between AddAllocation and Defragment.
    3721  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
    3722 
    3723  struct BlockInfo
    3724  {
    3725  VmaDeviceMemoryBlock* m_pBlock;
    3726  bool m_HasNonMovableAllocations;
    3727  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
    3728 
    3729  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
    3730  m_pBlock(VMA_NULL),
    3731  m_HasNonMovableAllocations(true),
    3732  m_Allocations(pAllocationCallbacks),
    3733  m_pMappedDataForDefragmentation(VMA_NULL)
    3734  {
    3735  }
    3736 
    3737  void CalcHasNonMovableAllocations()
    3738  {
    3739  const size_t blockAllocCount = m_pBlock->m_Metadata.GetAllocationCount();
    3740  const size_t defragmentAllocCount = m_Allocations.size();
    3741  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
    3742  }
    3743 
    3744  void SortAllocationsBySizeDescecnding()
    3745  {
    3746  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
    3747  }
    3748 
    3749  VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);
    3750  void Unmap(VmaAllocator hAllocator);
    3751 
    3752  private:
    3753  // Not null if mapped for defragmentation only, not originally mapped.
    3754  void* m_pMappedDataForDefragmentation;
    3755  };
    3756 
    3757  struct BlockPointerLess
    3758  {
    3759  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
    3760  {
    3761  return pLhsBlockInfo->m_pBlock < pRhsBlock;
    3762  }
    3763  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
    3764  {
    3765  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
    3766  }
    3767  };
    3768 
    3769  // 1. Blocks with some non-movable allocations go first.
    3770  // 2. Blocks with smaller sumFreeSize go first.
    3771  struct BlockInfoCompareMoveDestination
    3772  {
    3773  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
    3774  {
    3775  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
    3776  {
    3777  return true;
    3778  }
    3779  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
    3780  {
    3781  return false;
    3782  }
    3783  if(pLhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize())
    3784  {
    3785  return true;
    3786  }
    3787  return false;
    3788  }
    3789  };
    3790 
    3791  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
    3792  BlockInfoVector m_Blocks;
    3793 
    3794  VkResult DefragmentRound(
    3795  VkDeviceSize maxBytesToMove,
    3796  uint32_t maxAllocationsToMove);
    3797 
    3798  static bool MoveMakesSense(
    3799  size_t dstBlockIndex, VkDeviceSize dstOffset,
    3800  size_t srcBlockIndex, VkDeviceSize srcOffset);
    3801 
    3802 public:
    3803  VmaDefragmentator(
    3804  VmaAllocator hAllocator,
    3805  VmaBlockVector* pBlockVector,
    3806  uint32_t currentFrameIndex);
    3807 
    3808  ~VmaDefragmentator();
    3809 
    3810  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
    3811  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
    3812 
    3813  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
    3814 
    3815  VkResult Defragment(
    3816  VkDeviceSize maxBytesToMove,
    3817  uint32_t maxAllocationsToMove);
    3818 };
    3819 
    3820 // Main allocator object.
    3821 struct VmaAllocator_T
    3822 {
    3823  bool m_UseMutex;
    3824  bool m_UseKhrDedicatedAllocation;
    3825  VkDevice m_hDevice;
    3826  bool m_AllocationCallbacksSpecified;
    3827  VkAllocationCallbacks m_AllocationCallbacks;
    3828  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
    3829 
    3830  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
    3831  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
    3832  VMA_MUTEX m_HeapSizeLimitMutex;
    3833 
    3834  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
    3835  VkPhysicalDeviceMemoryProperties m_MemProps;
    3836 
    3837  // Default pools.
    3838  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
    3839 
    3840  // Each vector is sorted by memory (handle value).
    3841  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
    3842  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
    3843  VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
    3844 
    3845  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
    3846  ~VmaAllocator_T();
    3847 
    3848  const VkAllocationCallbacks* GetAllocationCallbacks() const
    3849  {
    3850  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
    3851  }
    3852  const VmaVulkanFunctions& GetVulkanFunctions() const
    3853  {
    3854  return m_VulkanFunctions;
    3855  }
    3856 
    3857  VkDeviceSize GetBufferImageGranularity() const
    3858  {
    3859  return VMA_MAX(
    3860  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
    3861  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
    3862  }
    3863 
    3864  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
    3865  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
    3866 
    3867  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
    3868  {
    3869  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
    3870  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
    3871  }
    3872 
    3873  void GetBufferMemoryRequirements(
    3874  VkBuffer hBuffer,
    3875  VkMemoryRequirements& memReq,
    3876  bool& requiresDedicatedAllocation,
    3877  bool& prefersDedicatedAllocation) const;
    3878  void GetImageMemoryRequirements(
    3879  VkImage hImage,
    3880  VkMemoryRequirements& memReq,
    3881  bool& requiresDedicatedAllocation,
    3882  bool& prefersDedicatedAllocation) const;
    3883 
    3884  // Main allocation function.
    3885  VkResult AllocateMemory(
    3886  const VkMemoryRequirements& vkMemReq,
    3887  bool requiresDedicatedAllocation,
    3888  bool prefersDedicatedAllocation,
    3889  VkBuffer dedicatedBuffer,
    3890  VkImage dedicatedImage,
    3891  const VmaAllocationCreateInfo& createInfo,
    3892  VmaSuballocationType suballocType,
    3893  VmaAllocation* pAllocation);
    3894 
    3895  // Main deallocation function.
    3896  void FreeMemory(const VmaAllocation allocation);
    3897 
    3898  void CalculateStats(VmaStats* pStats);
    3899 
    3900 #if VMA_STATS_STRING_ENABLED
    3901  void PrintDetailedMap(class VmaJsonWriter& json);
    3902 #endif
    3903 
    3904  VkResult Defragment(
    3905  VmaAllocation* pAllocations,
    3906  size_t allocationCount,
    3907  VkBool32* pAllocationsChanged,
    3908  const VmaDefragmentationInfo* pDefragmentationInfo,
    3909  VmaDefragmentationStats* pDefragmentationStats);
    3910 
    3911  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
    3912 
    3913  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
    3914  void DestroyPool(VmaPool pool);
    3915  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
    3916 
    3917  void SetCurrentFrameIndex(uint32_t frameIndex);
    3918 
    3919  void MakePoolAllocationsLost(
    3920  VmaPool hPool,
    3921  size_t* pLostAllocationCount);
    3922 
    3923  void CreateLostAllocation(VmaAllocation* pAllocation);
    3924 
    3925  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
    3926  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
    3927 
    3928  VkResult Map(VmaAllocation hAllocation, void** ppData);
    3929  void Unmap(VmaAllocation hAllocation);
    3930 
    3931 private:
    3932  VkDeviceSize m_PreferredLargeHeapBlockSize;
    3933 
    3934  VkPhysicalDevice m_PhysicalDevice;
    3935  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
    3936 
    3937  VMA_MUTEX m_PoolsMutex;
    3938  // Protected by m_PoolsMutex. Sorted by pointer value.
    3939  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
    3940 
    3941  VmaVulkanFunctions m_VulkanFunctions;
    3942 
    3943  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
    3944 
    3945  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
    3946 
    3947  VkResult AllocateMemoryOfType(
    3948  const VkMemoryRequirements& vkMemReq,
    3949  bool dedicatedAllocation,
    3950  VkBuffer dedicatedBuffer,
    3951  VkImage dedicatedImage,
    3952  const VmaAllocationCreateInfo& createInfo,
    3953  uint32_t memTypeIndex,
    3954  VmaSuballocationType suballocType,
    3955  VmaAllocation* pAllocation);
    3956 
    3957  // Allocates and registers new VkDeviceMemory specifically for single allocation.
    3958  VkResult AllocateDedicatedMemory(
    3959  VkDeviceSize size,
    3960  VmaSuballocationType suballocType,
    3961  uint32_t memTypeIndex,
    3962  bool map,
    3963  bool isUserDataString,
    3964  void* pUserData,
    3965  VkBuffer dedicatedBuffer,
    3966  VkImage dedicatedImage,
    3967  VmaAllocation* pAllocation);
    3968 
    3969  // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.
    3970  void FreeDedicatedMemory(VmaAllocation allocation);
    3971 };
    3972 
    3974 // Memory allocation #2 after VmaAllocator_T definition
    3975 
    3976 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
    3977 {
    3978  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
    3979 }
    3980 
    3981 static void VmaFree(VmaAllocator hAllocator, void* ptr)
    3982 {
    3983  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
    3984 }
    3985 
    3986 template<typename T>
    3987 static T* VmaAllocate(VmaAllocator hAllocator)
    3988 {
    3989  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
    3990 }
    3991 
    3992 template<typename T>
    3993 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
    3994 {
    3995  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
    3996 }
    3997 
    3998 template<typename T>
    3999 static void vma_delete(VmaAllocator hAllocator, T* ptr)
    4000 {
    4001  if(ptr != VMA_NULL)
    4002  {
    4003  ptr->~T();
    4004  VmaFree(hAllocator, ptr);
    4005  }
    4006 }
    4007 
    4008 template<typename T>
    4009 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
    4010 {
    4011  if(ptr != VMA_NULL)
    4012  {
    4013  for(size_t i = count; i--; )
    4014  ptr[i].~T();
    4015  VmaFree(hAllocator, ptr);
    4016  }
    4017 }
    4018 
    4020 // VmaStringBuilder
    4021 
    4022 #if VMA_STATS_STRING_ENABLED
    4023 
    4024 class VmaStringBuilder
    4025 {
    4026 public:
    4027  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
    4028  size_t GetLength() const { return m_Data.size(); }
    4029  const char* GetData() const { return m_Data.data(); }
    4030 
    4031  void Add(char ch) { m_Data.push_back(ch); }
    4032  void Add(const char* pStr);
    4033  void AddNewLine() { Add('\n'); }
    4034  void AddNumber(uint32_t num);
    4035  void AddNumber(uint64_t num);
    4036  void AddPointer(const void* ptr);
    4037 
    4038 private:
    4039  VmaVector< char, VmaStlAllocator<char> > m_Data;
    4040 };
    4041 
    4042 void VmaStringBuilder::Add(const char* pStr)
    4043 {
    4044  const size_t strLen = strlen(pStr);
    4045  if(strLen > 0)
    4046  {
    4047  const size_t oldCount = m_Data.size();
    4048  m_Data.resize(oldCount + strLen);
    4049  memcpy(m_Data.data() + oldCount, pStr, strLen);
    4050  }
    4051 }
    4052 
    4053 void VmaStringBuilder::AddNumber(uint32_t num)
    4054 {
    4055  char buf[11];
    4056  VmaUint32ToStr(buf, sizeof(buf), num);
    4057  Add(buf);
    4058 }
    4059 
    4060 void VmaStringBuilder::AddNumber(uint64_t num)
    4061 {
    4062  char buf[21];
    4063  VmaUint64ToStr(buf, sizeof(buf), num);
    4064  Add(buf);
    4065 }
    4066 
    4067 void VmaStringBuilder::AddPointer(const void* ptr)
    4068 {
    4069  char buf[21];
    4070  VmaPtrToStr(buf, sizeof(buf), ptr);
    4071  Add(buf);
    4072 }
    4073 
    4074 #endif // #if VMA_STATS_STRING_ENABLED
    4075 
    4077 // VmaJsonWriter
    4078 
    4079 #if VMA_STATS_STRING_ENABLED
    4080 
    4081 class VmaJsonWriter
    4082 {
    4083 public:
    4084  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
    4085  ~VmaJsonWriter();
    4086 
    4087  void BeginObject(bool singleLine = false);
    4088  void EndObject();
    4089 
    4090  void BeginArray(bool singleLine = false);
    4091  void EndArray();
    4092 
    4093  void WriteString(const char* pStr);
    4094  void BeginString(const char* pStr = VMA_NULL);
    4095  void ContinueString(const char* pStr);
    4096  void ContinueString(uint32_t n);
    4097  void ContinueString(uint64_t n);
    4098  void ContinueString_Pointer(const void* ptr);
    4099  void EndString(const char* pStr = VMA_NULL);
    4100 
    4101  void WriteNumber(uint32_t n);
    4102  void WriteNumber(uint64_t n);
    4103  void WriteBool(bool b);
    4104  void WriteNull();
    4105 
    4106 private:
    4107  static const char* const INDENT;
    4108 
    4109  enum COLLECTION_TYPE
    4110  {
    4111  COLLECTION_TYPE_OBJECT,
    4112  COLLECTION_TYPE_ARRAY,
    4113  };
    4114  struct StackItem
    4115  {
    4116  COLLECTION_TYPE type;
    4117  uint32_t valueCount;
    4118  bool singleLineMode;
    4119  };
    4120 
    4121  VmaStringBuilder& m_SB;
    4122  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
    4123  bool m_InsideString;
    4124 
    4125  void BeginValue(bool isString);
    4126  void WriteIndent(bool oneLess = false);
    4127 };
    4128 
    4129 const char* const VmaJsonWriter::INDENT = " ";
    4130 
    4131 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
    4132  m_SB(sb),
    4133  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
    4134  m_InsideString(false)
    4135 {
    4136 }
    4137 
    4138 VmaJsonWriter::~VmaJsonWriter()
    4139 {
    4140  VMA_ASSERT(!m_InsideString);
    4141  VMA_ASSERT(m_Stack.empty());
    4142 }
    4143 
    4144 void VmaJsonWriter::BeginObject(bool singleLine)
    4145 {
    4146  VMA_ASSERT(!m_InsideString);
    4147 
    4148  BeginValue(false);
    4149  m_SB.Add('{');
    4150 
    4151  StackItem item;
    4152  item.type = COLLECTION_TYPE_OBJECT;
    4153  item.valueCount = 0;
    4154  item.singleLineMode = singleLine;
    4155  m_Stack.push_back(item);
    4156 }
    4157 
    4158 void VmaJsonWriter::EndObject()
    4159 {
    4160  VMA_ASSERT(!m_InsideString);
    4161 
    4162  WriteIndent(true);
    4163  m_SB.Add('}');
    4164 
    4165  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
    4166  m_Stack.pop_back();
    4167 }
    4168 
    4169 void VmaJsonWriter::BeginArray(bool singleLine)
    4170 {
    4171  VMA_ASSERT(!m_InsideString);
    4172 
    4173  BeginValue(false);
    4174  m_SB.Add('[');
    4175 
    4176  StackItem item;
    4177  item.type = COLLECTION_TYPE_ARRAY;
    4178  item.valueCount = 0;
    4179  item.singleLineMode = singleLine;
    4180  m_Stack.push_back(item);
    4181 }
    4182 
    4183 void VmaJsonWriter::EndArray()
    4184 {
    4185  VMA_ASSERT(!m_InsideString);
    4186 
    4187  WriteIndent(true);
    4188  m_SB.Add(']');
    4189 
    4190  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
    4191  m_Stack.pop_back();
    4192 }
    4193 
    4194 void VmaJsonWriter::WriteString(const char* pStr)
    4195 {
    4196  BeginString(pStr);
    4197  EndString();
    4198 }
    4199 
    4200 void VmaJsonWriter::BeginString(const char* pStr)
    4201 {
    4202  VMA_ASSERT(!m_InsideString);
    4203 
    4204  BeginValue(true);
    4205  m_SB.Add('"');
    4206  m_InsideString = true;
    4207  if(pStr != VMA_NULL && pStr[0] != '\0')
    4208  {
    4209  ContinueString(pStr);
    4210  }
    4211 }
    4212 
    4213 void VmaJsonWriter::ContinueString(const char* pStr)
    4214 {
    4215  VMA_ASSERT(m_InsideString);
    4216 
    4217  const size_t strLen = strlen(pStr);
    4218  for(size_t i = 0; i < strLen; ++i)
    4219  {
    4220  char ch = pStr[i];
    4221  if(ch == '\'')
    4222  {
    4223  m_SB.Add("\\\\");
    4224  }
    4225  else if(ch == '"')
    4226  {
    4227  m_SB.Add("\\\"");
    4228  }
    4229  else if(ch >= 32)
    4230  {
    4231  m_SB.Add(ch);
    4232  }
    4233  else switch(ch)
    4234  {
    4235  case '\b':
    4236  m_SB.Add("\\b");
    4237  break;
    4238  case '\f':
    4239  m_SB.Add("\\f");
    4240  break;
    4241  case '\n':
    4242  m_SB.Add("\\n");
    4243  break;
    4244  case '\r':
    4245  m_SB.Add("\\r");
    4246  break;
    4247  case '\t':
    4248  m_SB.Add("\\t");
    4249  break;
    4250  default:
    4251  VMA_ASSERT(0 && "Character not currently supported.");
    4252  break;
    4253  }
    4254  }
    4255 }
    4256 
    4257 void VmaJsonWriter::ContinueString(uint32_t n)
    4258 {
    4259  VMA_ASSERT(m_InsideString);
    4260  m_SB.AddNumber(n);
    4261 }
    4262 
    4263 void VmaJsonWriter::ContinueString(uint64_t n)
    4264 {
    4265  VMA_ASSERT(m_InsideString);
    4266  m_SB.AddNumber(n);
    4267 }
    4268 
    4269 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
    4270 {
    4271  VMA_ASSERT(m_InsideString);
    4272  m_SB.AddPointer(ptr);
    4273 }
    4274 
    4275 void VmaJsonWriter::EndString(const char* pStr)
    4276 {
    4277  VMA_ASSERT(m_InsideString);
    4278  if(pStr != VMA_NULL && pStr[0] != '\0')
    4279  {
    4280  ContinueString(pStr);
    4281  }
    4282  m_SB.Add('"');
    4283  m_InsideString = false;
    4284 }
    4285 
    4286 void VmaJsonWriter::WriteNumber(uint32_t n)
    4287 {
    4288  VMA_ASSERT(!m_InsideString);
    4289  BeginValue(false);
    4290  m_SB.AddNumber(n);
    4291 }
    4292 
    4293 void VmaJsonWriter::WriteNumber(uint64_t n)
    4294 {
    4295  VMA_ASSERT(!m_InsideString);
    4296  BeginValue(false);
    4297  m_SB.AddNumber(n);
    4298 }
    4299 
    4300 void VmaJsonWriter::WriteBool(bool b)
    4301 {
    4302  VMA_ASSERT(!m_InsideString);
    4303  BeginValue(false);
    4304  m_SB.Add(b ? "true" : "false");
    4305 }
    4306 
    4307 void VmaJsonWriter::WriteNull()
    4308 {
    4309  VMA_ASSERT(!m_InsideString);
    4310  BeginValue(false);
    4311  m_SB.Add("null");
    4312 }
    4313 
    4314 void VmaJsonWriter::BeginValue(bool isString)
    4315 {
    4316  if(!m_Stack.empty())
    4317  {
    4318  StackItem& currItem = m_Stack.back();
    4319  if(currItem.type == COLLECTION_TYPE_OBJECT &&
    4320  currItem.valueCount % 2 == 0)
    4321  {
    4322  VMA_ASSERT(isString);
    4323  }
    4324 
    4325  if(currItem.type == COLLECTION_TYPE_OBJECT &&
    4326  currItem.valueCount % 2 != 0)
    4327  {
    4328  m_SB.Add(": ");
    4329  }
    4330  else if(currItem.valueCount > 0)
    4331  {
    4332  m_SB.Add(", ");
    4333  WriteIndent();
    4334  }
    4335  else
    4336  {
    4337  WriteIndent();
    4338  }
    4339  ++currItem.valueCount;
    4340  }
    4341 }
    4342 
    4343 void VmaJsonWriter::WriteIndent(bool oneLess)
    4344 {
    4345  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
    4346  {
    4347  m_SB.AddNewLine();
    4348 
    4349  size_t count = m_Stack.size();
    4350  if(count > 0 && oneLess)
    4351  {
    4352  --count;
    4353  }
    4354  for(size_t i = 0; i < count; ++i)
    4355  {
    4356  m_SB.Add(INDENT);
    4357  }
    4358  }
    4359 }
    4360 
    4361 #endif // #if VMA_STATS_STRING_ENABLED
    4362 
    4364 
    4365 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
    4366 {
    4367  if(IsUserDataString())
    4368  {
    4369  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
    4370 
    4371  FreeUserDataString(hAllocator);
    4372 
    4373  if(pUserData != VMA_NULL)
    4374  {
    4375  const char* const newStrSrc = (char*)pUserData;
    4376  const size_t newStrLen = strlen(newStrSrc);
    4377  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
    4378  memcpy(newStrDst, newStrSrc, newStrLen + 1);
    4379  m_pUserData = newStrDst;
    4380  }
    4381  }
    4382  else
    4383  {
    4384  m_pUserData = pUserData;
    4385  }
    4386 }
    4387 
    4388 VkDeviceSize VmaAllocation_T::GetOffset() const
    4389 {
    4390  switch(m_Type)
    4391  {
    4392  case ALLOCATION_TYPE_BLOCK:
    4393  return m_BlockAllocation.m_Offset;
    4394  case ALLOCATION_TYPE_DEDICATED:
    4395  return 0;
    4396  default:
    4397  VMA_ASSERT(0);
    4398  return 0;
    4399  }
    4400 }
    4401 
    4402 VkDeviceMemory VmaAllocation_T::GetMemory() const
    4403 {
    4404  switch(m_Type)
    4405  {
    4406  case ALLOCATION_TYPE_BLOCK:
    4407  return m_BlockAllocation.m_Block->m_hMemory;
    4408  case ALLOCATION_TYPE_DEDICATED:
    4409  return m_DedicatedAllocation.m_hMemory;
    4410  default:
    4411  VMA_ASSERT(0);
    4412  return VK_NULL_HANDLE;
    4413  }
    4414 }
    4415 
    4416 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
    4417 {
    4418  switch(m_Type)
    4419  {
    4420  case ALLOCATION_TYPE_BLOCK:
    4421  return m_BlockAllocation.m_Block->m_MemoryTypeIndex;
    4422  case ALLOCATION_TYPE_DEDICATED:
    4423  return m_DedicatedAllocation.m_MemoryTypeIndex;
    4424  default:
    4425  VMA_ASSERT(0);
    4426  return UINT32_MAX;
    4427  }
    4428 }
    4429 
    4430 void* VmaAllocation_T::GetMappedData() const
    4431 {
    4432  switch(m_Type)
    4433  {
    4434  case ALLOCATION_TYPE_BLOCK:
    4435  if(m_MapCount != 0)
    4436  {
    4437  void* pBlockData = m_BlockAllocation.m_Block->m_Mapping.GetMappedData();
    4438  VMA_ASSERT(pBlockData != VMA_NULL);
    4439  return (char*)pBlockData + m_BlockAllocation.m_Offset;
    4440  }
    4441  else
    4442  {
    4443  return VMA_NULL;
    4444  }
    4445  break;
    4446  case ALLOCATION_TYPE_DEDICATED:
    4447  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
    4448  return m_DedicatedAllocation.m_pMappedData;
    4449  default:
    4450  VMA_ASSERT(0);
    4451  return VMA_NULL;
    4452  }
    4453 }
    4454 
    4455 bool VmaAllocation_T::CanBecomeLost() const
    4456 {
    4457  switch(m_Type)
    4458  {
    4459  case ALLOCATION_TYPE_BLOCK:
    4460  return m_BlockAllocation.m_CanBecomeLost;
    4461  case ALLOCATION_TYPE_DEDICATED:
    4462  return false;
    4463  default:
    4464  VMA_ASSERT(0);
    4465  return false;
    4466  }
    4467 }
    4468 
    4469 VmaPool VmaAllocation_T::GetPool() const
    4470 {
    4471  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    4472  return m_BlockAllocation.m_hPool;
    4473 }
    4474 
    4475 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
    4476 {
    4477  VMA_ASSERT(CanBecomeLost());
    4478 
    4479  /*
    4480  Warning: This is a carefully designed algorithm.
    4481  Do not modify unless you really know what you're doing :)
    4482  */
    4483  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
    4484  for(;;)
    4485  {
    4486  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
    4487  {
    4488  VMA_ASSERT(0);
    4489  return false;
    4490  }
    4491  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
    4492  {
    4493  return false;
    4494  }
    4495  else // Last use time earlier than current time.
    4496  {
    4497  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
    4498  {
    4499  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
    4500  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
    4501  return true;
    4502  }
    4503  }
    4504  }
    4505 }
    4506 
    4507 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
    4508 {
    4509  VMA_ASSERT(IsUserDataString());
    4510  if(m_pUserData != VMA_NULL)
    4511  {
    4512  char* const oldStr = (char*)m_pUserData;
    4513  const size_t oldStrLen = strlen(oldStr);
    4514  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
    4515  m_pUserData = VMA_NULL;
    4516  }
    4517 }
    4518 
    4519 void VmaAllocation_T::BlockAllocMap()
    4520 {
    4521  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
    4522 
    4523  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
    4524  {
    4525  ++m_MapCount;
    4526  }
    4527  else
    4528  {
    4529  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
    4530  }
    4531 }
    4532 
    4533 void VmaAllocation_T::BlockAllocUnmap()
    4534 {
    4535  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
    4536 
    4537  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
    4538  {
    4539  --m_MapCount;
    4540  }
    4541  else
    4542  {
    4543  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
    4544  }
    4545 }
    4546 
    4547 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
    4548 {
    4549  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
    4550 
    4551  if(m_MapCount != 0)
    4552  {
    4553  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
    4554  {
    4555  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
    4556  *ppData = m_DedicatedAllocation.m_pMappedData;
    4557  ++m_MapCount;
    4558  return VK_SUCCESS;
    4559  }
    4560  else
    4561  {
    4562  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
    4563  return VK_ERROR_MEMORY_MAP_FAILED;
    4564  }
    4565  }
    4566  else
    4567  {
    4568  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
    4569  hAllocator->m_hDevice,
    4570  m_DedicatedAllocation.m_hMemory,
    4571  0, // offset
    4572  VK_WHOLE_SIZE,
    4573  0, // flags
    4574  ppData);
    4575  if(result == VK_SUCCESS)
    4576  {
    4577  m_DedicatedAllocation.m_pMappedData = *ppData;
    4578  m_MapCount = 1;
    4579  }
    4580  return result;
    4581  }
    4582 }
    4583 
    4584 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
    4585 {
    4586  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
    4587 
    4588  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
    4589  {
    4590  --m_MapCount;
    4591  if(m_MapCount == 0)
    4592  {
    4593  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
    4594  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
    4595  hAllocator->m_hDevice,
    4596  m_DedicatedAllocation.m_hMemory);
    4597  }
    4598  }
    4599  else
    4600  {
    4601  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
    4602  }
    4603 }
    4604 
    4605 #if VMA_STATS_STRING_ENABLED
    4606 
    4607 // Correspond to values of enum VmaSuballocationType.
    4608 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
    4609  "FREE",
    4610  "UNKNOWN",
    4611  "BUFFER",
    4612  "IMAGE_UNKNOWN",
    4613  "IMAGE_LINEAR",
    4614  "IMAGE_OPTIMAL",
    4615 };
    4616 
    4617 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
    4618 {
    4619  json.BeginObject();
    4620 
    4621  json.WriteString("Blocks");
    4622  json.WriteNumber(stat.blockCount);
    4623 
    4624  json.WriteString("Allocations");
    4625  json.WriteNumber(stat.allocationCount);
    4626 
    4627  json.WriteString("UnusedRanges");
    4628  json.WriteNumber(stat.unusedRangeCount);
    4629 
    4630  json.WriteString("UsedBytes");
    4631  json.WriteNumber(stat.usedBytes);
    4632 
    4633  json.WriteString("UnusedBytes");
    4634  json.WriteNumber(stat.unusedBytes);
    4635 
    4636  if(stat.allocationCount > 1)
    4637  {
    4638  json.WriteString("AllocationSize");
    4639  json.BeginObject(true);
    4640  json.WriteString("Min");
    4641  json.WriteNumber(stat.allocationSizeMin);
    4642  json.WriteString("Avg");
    4643  json.WriteNumber(stat.allocationSizeAvg);
    4644  json.WriteString("Max");
    4645  json.WriteNumber(stat.allocationSizeMax);
    4646  json.EndObject();
    4647  }
    4648 
    4649  if(stat.unusedRangeCount > 1)
    4650  {
    4651  json.WriteString("UnusedRangeSize");
    4652  json.BeginObject(true);
    4653  json.WriteString("Min");
    4654  json.WriteNumber(stat.unusedRangeSizeMin);
    4655  json.WriteString("Avg");
    4656  json.WriteNumber(stat.unusedRangeSizeAvg);
    4657  json.WriteString("Max");
    4658  json.WriteNumber(stat.unusedRangeSizeMax);
    4659  json.EndObject();
    4660  }
    4661 
    4662  json.EndObject();
    4663 }
    4664 
    4665 #endif // #if VMA_STATS_STRING_ENABLED
    4666 
    4667 struct VmaSuballocationItemSizeLess
    4668 {
    4669  bool operator()(
    4670  const VmaSuballocationList::iterator lhs,
    4671  const VmaSuballocationList::iterator rhs) const
    4672  {
    4673  return lhs->size < rhs->size;
    4674  }
    4675  bool operator()(
    4676  const VmaSuballocationList::iterator lhs,
    4677  VkDeviceSize rhsSize) const
    4678  {
    4679  return lhs->size < rhsSize;
    4680  }
    4681 };
    4682 
    4684 // class VmaBlockMetadata
    4685 
    4686 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
    4687  m_Size(0),
    4688  m_FreeCount(0),
    4689  m_SumFreeSize(0),
    4690  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
    4691  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
    4692 {
    4693 }
    4694 
    4695 VmaBlockMetadata::~VmaBlockMetadata()
    4696 {
    4697 }
    4698 
    4699 void VmaBlockMetadata::Init(VkDeviceSize size)
    4700 {
    4701  m_Size = size;
    4702  m_FreeCount = 1;
    4703  m_SumFreeSize = size;
    4704 
    4705  VmaSuballocation suballoc = {};
    4706  suballoc.offset = 0;
    4707  suballoc.size = size;
    4708  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    4709  suballoc.hAllocation = VK_NULL_HANDLE;
    4710 
    4711  m_Suballocations.push_back(suballoc);
    4712  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
    4713  --suballocItem;
    4714  m_FreeSuballocationsBySize.push_back(suballocItem);
    4715 }
    4716 
    4717 bool VmaBlockMetadata::Validate() const
    4718 {
    4719  if(m_Suballocations.empty())
    4720  {
    4721  return false;
    4722  }
    4723 
    4724  // Expected offset of new suballocation as calculates from previous ones.
    4725  VkDeviceSize calculatedOffset = 0;
    4726  // Expected number of free suballocations as calculated from traversing their list.
    4727  uint32_t calculatedFreeCount = 0;
    4728  // Expected sum size of free suballocations as calculated from traversing their list.
    4729  VkDeviceSize calculatedSumFreeSize = 0;
    4730  // Expected number of free suballocations that should be registered in
    4731  // m_FreeSuballocationsBySize calculated from traversing their list.
    4732  size_t freeSuballocationsToRegister = 0;
    4733  // True if previous visisted suballocation was free.
    4734  bool prevFree = false;
    4735 
    4736  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
    4737  suballocItem != m_Suballocations.cend();
    4738  ++suballocItem)
    4739  {
    4740  const VmaSuballocation& subAlloc = *suballocItem;
    4741 
    4742  // Actual offset of this suballocation doesn't match expected one.
    4743  if(subAlloc.offset != calculatedOffset)
    4744  {
    4745  return false;
    4746  }
    4747 
    4748  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
    4749  // Two adjacent free suballocations are invalid. They should be merged.
    4750  if(prevFree && currFree)
    4751  {
    4752  return false;
    4753  }
    4754  prevFree = currFree;
    4755 
    4756  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
    4757  {
    4758  return false;
    4759  }
    4760 
    4761  if(currFree)
    4762  {
    4763  calculatedSumFreeSize += subAlloc.size;
    4764  ++calculatedFreeCount;
    4765  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    4766  {
    4767  ++freeSuballocationsToRegister;
    4768  }
    4769  }
    4770 
    4771  calculatedOffset += subAlloc.size;
    4772  }
    4773 
    4774  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
    4775  // match expected one.
    4776  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
    4777  {
    4778  return false;
    4779  }
    4780 
    4781  VkDeviceSize lastSize = 0;
    4782  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
    4783  {
    4784  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
    4785 
    4786  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
    4787  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
    4788  {
    4789  return false;
    4790  }
    4791  // They must be sorted by size ascending.
    4792  if(suballocItem->size < lastSize)
    4793  {
    4794  return false;
    4795  }
    4796 
    4797  lastSize = suballocItem->size;
    4798  }
    4799 
    4800  // Check if totals match calculacted values.
    4801  return
    4802  ValidateFreeSuballocationList() &&
    4803  (calculatedOffset == m_Size) &&
    4804  (calculatedSumFreeSize == m_SumFreeSize) &&
    4805  (calculatedFreeCount == m_FreeCount);
    4806 }
    4807 
    4808 VkDeviceSize VmaBlockMetadata::GetUnusedRangeSizeMax() const
    4809 {
    4810  if(!m_FreeSuballocationsBySize.empty())
    4811  {
    4812  return m_FreeSuballocationsBySize.back()->size;
    4813  }
    4814  else
    4815  {
    4816  return 0;
    4817  }
    4818 }
    4819 
    4820 bool VmaBlockMetadata::IsEmpty() const
    4821 {
    4822  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
    4823 }
    4824 
    4825 void VmaBlockMetadata::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
    4826 {
    4827  outInfo.blockCount = 1;
    4828 
    4829  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
    4830  outInfo.allocationCount = rangeCount - m_FreeCount;
    4831  outInfo.unusedRangeCount = m_FreeCount;
    4832 
    4833  outInfo.unusedBytes = m_SumFreeSize;
    4834  outInfo.usedBytes = m_Size - outInfo.unusedBytes;
    4835 
    4836  outInfo.allocationSizeMin = UINT64_MAX;
    4837  outInfo.allocationSizeMax = 0;
    4838  outInfo.unusedRangeSizeMin = UINT64_MAX;
    4839  outInfo.unusedRangeSizeMax = 0;
    4840 
    4841  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
    4842  suballocItem != m_Suballocations.cend();
    4843  ++suballocItem)
    4844  {
    4845  const VmaSuballocation& suballoc = *suballocItem;
    4846  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
    4847  {
    4848  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
    4849  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
    4850  }
    4851  else
    4852  {
    4853  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
    4854  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
    4855  }
    4856  }
    4857 }
    4858 
    4859 void VmaBlockMetadata::AddPoolStats(VmaPoolStats& inoutStats) const
    4860 {
    4861  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
    4862 
    4863  inoutStats.size += m_Size;
    4864  inoutStats.unusedSize += m_SumFreeSize;
    4865  inoutStats.allocationCount += rangeCount - m_FreeCount;
    4866  inoutStats.unusedRangeCount += m_FreeCount;
    4867  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
    4868 }
    4869 
    4870 #if VMA_STATS_STRING_ENABLED
    4871 
    4872 void VmaBlockMetadata::PrintDetailedMap(class VmaJsonWriter& json) const
    4873 {
    4874  json.BeginObject();
    4875 
    4876  json.WriteString("TotalBytes");
    4877  json.WriteNumber(m_Size);
    4878 
    4879  json.WriteString("UnusedBytes");
    4880  json.WriteNumber(m_SumFreeSize);
    4881 
    4882  json.WriteString("Allocations");
    4883  json.WriteNumber(m_Suballocations.size() - m_FreeCount);
    4884 
    4885  json.WriteString("UnusedRanges");
    4886  json.WriteNumber(m_FreeCount);
    4887 
    4888  json.WriteString("Suballocations");
    4889  json.BeginArray();
    4890  size_t i = 0;
    4891  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
    4892  suballocItem != m_Suballocations.cend();
    4893  ++suballocItem, ++i)
    4894  {
    4895  json.BeginObject(true);
    4896 
    4897  json.WriteString("Type");
    4898  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[suballocItem->type]);
    4899 
    4900  json.WriteString("Size");
    4901  json.WriteNumber(suballocItem->size);
    4902 
    4903  json.WriteString("Offset");
    4904  json.WriteNumber(suballocItem->offset);
    4905 
    4906  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
    4907  {
    4908  const void* pUserData = suballocItem->hAllocation->GetUserData();
    4909  if(pUserData != VMA_NULL)
    4910  {
    4911  json.WriteString("UserData");
    4912  if(suballocItem->hAllocation->IsUserDataString())
    4913  {
    4914  json.WriteString((const char*)pUserData);
    4915  }
    4916  else
    4917  {
    4918  json.BeginString();
    4919  json.ContinueString_Pointer(pUserData);
    4920  json.EndString();
    4921  }
    4922  }
    4923  }
    4924 
    4925  json.EndObject();
    4926  }
    4927  json.EndArray();
    4928 
    4929  json.EndObject();
    4930 }
    4931 
    4932 #endif // #if VMA_STATS_STRING_ENABLED
    4933 
    4934 /*
    4935 How many suitable free suballocations to analyze before choosing best one.
    4936 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
    4937  be chosen.
    4938 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
    4939  suballocations will be analized and best one will be chosen.
    4940 - Any other value is also acceptable.
    4941 */
    4942 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
    4943 
    4944 void VmaBlockMetadata::CreateFirstAllocationRequest(VmaAllocationRequest* pAllocationRequest)
    4945 {
    4946  VMA_ASSERT(IsEmpty());
    4947  pAllocationRequest->offset = 0;
    4948  pAllocationRequest->sumFreeSize = m_SumFreeSize;
    4949  pAllocationRequest->sumItemSize = 0;
    4950  pAllocationRequest->item = m_Suballocations.begin();
    4951  pAllocationRequest->itemsToMakeLostCount = 0;
    4952 }
    4953 
    4954 bool VmaBlockMetadata::CreateAllocationRequest(
    4955  uint32_t currentFrameIndex,
    4956  uint32_t frameInUseCount,
    4957  VkDeviceSize bufferImageGranularity,
    4958  VkDeviceSize allocSize,
    4959  VkDeviceSize allocAlignment,
    4960  VmaSuballocationType allocType,
    4961  bool canMakeOtherLost,
    4962  VmaAllocationRequest* pAllocationRequest)
    4963 {
    4964  VMA_ASSERT(allocSize > 0);
    4965  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    4966  VMA_ASSERT(pAllocationRequest != VMA_NULL);
    4967  VMA_HEAVY_ASSERT(Validate());
    4968 
    4969  // There is not enough total free space in this block to fullfill the request: Early return.
    4970  if(canMakeOtherLost == false && m_SumFreeSize < allocSize)
    4971  {
    4972  return false;
    4973  }
    4974 
    4975  // New algorithm, efficiently searching freeSuballocationsBySize.
    4976  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
    4977  if(freeSuballocCount > 0)
    4978  {
    4979  if(VMA_BEST_FIT)
    4980  {
    4981  // Find first free suballocation with size not less than allocSize.
    4982  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
    4983  m_FreeSuballocationsBySize.data(),
    4984  m_FreeSuballocationsBySize.data() + freeSuballocCount,
    4985  allocSize,
    4986  VmaSuballocationItemSizeLess());
    4987  size_t index = it - m_FreeSuballocationsBySize.data();
    4988  for(; index < freeSuballocCount; ++index)
    4989  {
    4990  if(CheckAllocation(
    4991  currentFrameIndex,
    4992  frameInUseCount,
    4993  bufferImageGranularity,
    4994  allocSize,
    4995  allocAlignment,
    4996  allocType,
    4997  m_FreeSuballocationsBySize[index],
    4998  false, // canMakeOtherLost
    4999  &pAllocationRequest->offset,
    5000  &pAllocationRequest->itemsToMakeLostCount,
    5001  &pAllocationRequest->sumFreeSize,
    5002  &pAllocationRequest->sumItemSize))
    5003  {
    5004  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
    5005  return true;
    5006  }
    5007  }
    5008  }
    5009  else
    5010  {
    5011  // Search staring from biggest suballocations.
    5012  for(size_t index = freeSuballocCount; index--; )
    5013  {
    5014  if(CheckAllocation(
    5015  currentFrameIndex,
    5016  frameInUseCount,
    5017  bufferImageGranularity,
    5018  allocSize,
    5019  allocAlignment,
    5020  allocType,
    5021  m_FreeSuballocationsBySize[index],
    5022  false, // canMakeOtherLost
    5023  &pAllocationRequest->offset,
    5024  &pAllocationRequest->itemsToMakeLostCount,
    5025  &pAllocationRequest->sumFreeSize,
    5026  &pAllocationRequest->sumItemSize))
    5027  {
    5028  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
    5029  return true;
    5030  }
    5031  }
    5032  }
    5033  }
    5034 
    5035  if(canMakeOtherLost)
    5036  {
    5037  // Brute-force algorithm. TODO: Come up with something better.
    5038 
    5039  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
    5040  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
    5041 
    5042  VmaAllocationRequest tmpAllocRequest = {};
    5043  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
    5044  suballocIt != m_Suballocations.end();
    5045  ++suballocIt)
    5046  {
    5047  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
    5048  suballocIt->hAllocation->CanBecomeLost())
    5049  {
    5050  if(CheckAllocation(
    5051  currentFrameIndex,
    5052  frameInUseCount,
    5053  bufferImageGranularity,
    5054  allocSize,
    5055  allocAlignment,
    5056  allocType,
    5057  suballocIt,
    5058  canMakeOtherLost,
    5059  &tmpAllocRequest.offset,
    5060  &tmpAllocRequest.itemsToMakeLostCount,
    5061  &tmpAllocRequest.sumFreeSize,
    5062  &tmpAllocRequest.sumItemSize))
    5063  {
    5064  tmpAllocRequest.item = suballocIt;
    5065 
    5066  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
    5067  {
    5068  *pAllocationRequest = tmpAllocRequest;
    5069  }
    5070  }
    5071  }
    5072  }
    5073 
    5074  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
    5075  {
    5076  return true;
    5077  }
    5078  }
    5079 
    5080  return false;
    5081 }
    5082 
    5083 bool VmaBlockMetadata::MakeRequestedAllocationsLost(
    5084  uint32_t currentFrameIndex,
    5085  uint32_t frameInUseCount,
    5086  VmaAllocationRequest* pAllocationRequest)
    5087 {
    5088  while(pAllocationRequest->itemsToMakeLostCount > 0)
    5089  {
    5090  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
    5091  {
    5092  ++pAllocationRequest->item;
    5093  }
    5094  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
    5095  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
    5096  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
    5097  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
    5098  {
    5099  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
    5100  --pAllocationRequest->itemsToMakeLostCount;
    5101  }
    5102  else
    5103  {
    5104  return false;
    5105  }
    5106  }
    5107 
    5108  VMA_HEAVY_ASSERT(Validate());
    5109  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
    5110  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5111 
    5112  return true;
    5113 }
    5114 
    5115 uint32_t VmaBlockMetadata::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
    5116 {
    5117  uint32_t lostAllocationCount = 0;
    5118  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
    5119  it != m_Suballocations.end();
    5120  ++it)
    5121  {
    5122  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
    5123  it->hAllocation->CanBecomeLost() &&
    5124  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
    5125  {
    5126  it = FreeSuballocation(it);
    5127  ++lostAllocationCount;
    5128  }
    5129  }
    5130  return lostAllocationCount;
    5131 }
    5132 
    5133 void VmaBlockMetadata::Alloc(
    5134  const VmaAllocationRequest& request,
    5135  VmaSuballocationType type,
    5136  VkDeviceSize allocSize,
    5137  VmaAllocation hAllocation)
    5138 {
    5139  VMA_ASSERT(request.item != m_Suballocations.end());
    5140  VmaSuballocation& suballoc = *request.item;
    5141  // Given suballocation is a free block.
    5142  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
    5143  // Given offset is inside this suballocation.
    5144  VMA_ASSERT(request.offset >= suballoc.offset);
    5145  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
    5146  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
    5147  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
    5148 
    5149  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
    5150  // it to become used.
    5151  UnregisterFreeSuballocation(request.item);
    5152 
    5153  suballoc.offset = request.offset;
    5154  suballoc.size = allocSize;
    5155  suballoc.type = type;
    5156  suballoc.hAllocation = hAllocation;
    5157 
    5158  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
    5159  if(paddingEnd)
    5160  {
    5161  VmaSuballocation paddingSuballoc = {};
    5162  paddingSuballoc.offset = request.offset + allocSize;
    5163  paddingSuballoc.size = paddingEnd;
    5164  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    5165  VmaSuballocationList::iterator next = request.item;
    5166  ++next;
    5167  const VmaSuballocationList::iterator paddingEndItem =
    5168  m_Suballocations.insert(next, paddingSuballoc);
    5169  RegisterFreeSuballocation(paddingEndItem);
    5170  }
    5171 
    5172  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
    5173  if(paddingBegin)
    5174  {
    5175  VmaSuballocation paddingSuballoc = {};
    5176  paddingSuballoc.offset = request.offset - paddingBegin;
    5177  paddingSuballoc.size = paddingBegin;
    5178  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    5179  const VmaSuballocationList::iterator paddingBeginItem =
    5180  m_Suballocations.insert(request.item, paddingSuballoc);
    5181  RegisterFreeSuballocation(paddingBeginItem);
    5182  }
    5183 
    5184  // Update totals.
    5185  m_FreeCount = m_FreeCount - 1;
    5186  if(paddingBegin > 0)
    5187  {
    5188  ++m_FreeCount;
    5189  }
    5190  if(paddingEnd > 0)
    5191  {
    5192  ++m_FreeCount;
    5193  }
    5194  m_SumFreeSize -= allocSize;
    5195 }
    5196 
    5197 void VmaBlockMetadata::Free(const VmaAllocation allocation)
    5198 {
    5199  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
    5200  suballocItem != m_Suballocations.end();
    5201  ++suballocItem)
    5202  {
    5203  VmaSuballocation& suballoc = *suballocItem;
    5204  if(suballoc.hAllocation == allocation)
    5205  {
    5206  FreeSuballocation(suballocItem);
    5207  VMA_HEAVY_ASSERT(Validate());
    5208  return;
    5209  }
    5210  }
    5211  VMA_ASSERT(0 && "Not found!");
    5212 }
    5213 
    5214 bool VmaBlockMetadata::ValidateFreeSuballocationList() const
    5215 {
    5216  VkDeviceSize lastSize = 0;
    5217  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
    5218  {
    5219  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
    5220 
    5221  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
    5222  {
    5223  VMA_ASSERT(0);
    5224  return false;
    5225  }
    5226  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    5227  {
    5228  VMA_ASSERT(0);
    5229  return false;
    5230  }
    5231  if(it->size < lastSize)
    5232  {
    5233  VMA_ASSERT(0);
    5234  return false;
    5235  }
    5236 
    5237  lastSize = it->size;
    5238  }
    5239  return true;
    5240 }
    5241 
    5242 bool VmaBlockMetadata::CheckAllocation(
    5243  uint32_t currentFrameIndex,
    5244  uint32_t frameInUseCount,
    5245  VkDeviceSize bufferImageGranularity,
    5246  VkDeviceSize allocSize,
    5247  VkDeviceSize allocAlignment,
    5248  VmaSuballocationType allocType,
    5249  VmaSuballocationList::const_iterator suballocItem,
    5250  bool canMakeOtherLost,
    5251  VkDeviceSize* pOffset,
    5252  size_t* itemsToMakeLostCount,
    5253  VkDeviceSize* pSumFreeSize,
    5254  VkDeviceSize* pSumItemSize) const
    5255 {
    5256  VMA_ASSERT(allocSize > 0);
    5257  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    5258  VMA_ASSERT(suballocItem != m_Suballocations.cend());
    5259  VMA_ASSERT(pOffset != VMA_NULL);
    5260 
    5261  *itemsToMakeLostCount = 0;
    5262  *pSumFreeSize = 0;
    5263  *pSumItemSize = 0;
    5264 
    5265  if(canMakeOtherLost)
    5266  {
    5267  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
    5268  {
    5269  *pSumFreeSize = suballocItem->size;
    5270  }
    5271  else
    5272  {
    5273  if(suballocItem->hAllocation->CanBecomeLost() &&
    5274  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
    5275  {
    5276  ++*itemsToMakeLostCount;
    5277  *pSumItemSize = suballocItem->size;
    5278  }
    5279  else
    5280  {
    5281  return false;
    5282  }
    5283  }
    5284 
    5285  // Remaining size is too small for this request: Early return.
    5286  if(m_Size - suballocItem->offset < allocSize)
    5287  {
    5288  return false;
    5289  }
    5290 
    5291  // Start from offset equal to beginning of this suballocation.
    5292  *pOffset = suballocItem->offset;
    5293 
    5294  // Apply VMA_DEBUG_MARGIN at the beginning.
    5295  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
    5296  {
    5297  *pOffset += VMA_DEBUG_MARGIN;
    5298  }
    5299 
    5300  // Apply alignment.
    5301  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
    5302  *pOffset = VmaAlignUp(*pOffset, alignment);
    5303 
    5304  // Check previous suballocations for BufferImageGranularity conflicts.
    5305  // Make bigger alignment if necessary.
    5306  if(bufferImageGranularity > 1)
    5307  {
    5308  bool bufferImageGranularityConflict = false;
    5309  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
    5310  while(prevSuballocItem != m_Suballocations.cbegin())
    5311  {
    5312  --prevSuballocItem;
    5313  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
    5314  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
    5315  {
    5316  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
    5317  {
    5318  bufferImageGranularityConflict = true;
    5319  break;
    5320  }
    5321  }
    5322  else
    5323  // Already on previous page.
    5324  break;
    5325  }
    5326  if(bufferImageGranularityConflict)
    5327  {
    5328  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
    5329  }
    5330  }
    5331 
    5332  // Now that we have final *pOffset, check if we are past suballocItem.
    5333  // If yes, return false - this function should be called for another suballocItem as starting point.
    5334  if(*pOffset >= suballocItem->offset + suballocItem->size)
    5335  {
    5336  return false;
    5337  }
    5338 
    5339  // Calculate padding at the beginning based on current offset.
    5340  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
    5341 
    5342  // Calculate required margin at the end if this is not last suballocation.
    5343  VmaSuballocationList::const_iterator next = suballocItem;
    5344  ++next;
    5345  const VkDeviceSize requiredEndMargin =
    5346  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
    5347 
    5348  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
    5349  // Another early return check.
    5350  if(suballocItem->offset + totalSize > m_Size)
    5351  {
    5352  return false;
    5353  }
    5354 
    5355  // Advance lastSuballocItem until desired size is reached.
    5356  // Update itemsToMakeLostCount.
    5357  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
    5358  if(totalSize > suballocItem->size)
    5359  {
    5360  VkDeviceSize remainingSize = totalSize - suballocItem->size;
    5361  while(remainingSize > 0)
    5362  {
    5363  ++lastSuballocItem;
    5364  if(lastSuballocItem == m_Suballocations.cend())
    5365  {
    5366  return false;
    5367  }
    5368  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
    5369  {
    5370  *pSumFreeSize += lastSuballocItem->size;
    5371  }
    5372  else
    5373  {
    5374  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
    5375  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
    5376  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
    5377  {
    5378  ++*itemsToMakeLostCount;
    5379  *pSumItemSize += lastSuballocItem->size;
    5380  }
    5381  else
    5382  {
    5383  return false;
    5384  }
    5385  }
    5386  remainingSize = (lastSuballocItem->size < remainingSize) ?
    5387  remainingSize - lastSuballocItem->size : 0;
    5388  }
    5389  }
    5390 
    5391  // Check next suballocations for BufferImageGranularity conflicts.
    5392  // If conflict exists, we must mark more allocations lost or fail.
    5393  if(bufferImageGranularity > 1)
    5394  {
    5395  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
    5396  ++nextSuballocItem;
    5397  while(nextSuballocItem != m_Suballocations.cend())
    5398  {
    5399  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
    5400  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
    5401  {
    5402  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
    5403  {
    5404  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
    5405  if(nextSuballoc.hAllocation->CanBecomeLost() &&
    5406  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
    5407  {
    5408  ++*itemsToMakeLostCount;
    5409  }
    5410  else
    5411  {
    5412  return false;
    5413  }
    5414  }
    5415  }
    5416  else
    5417  {
    5418  // Already on next page.
    5419  break;
    5420  }
    5421  ++nextSuballocItem;
    5422  }
    5423  }
    5424  }
    5425  else
    5426  {
    5427  const VmaSuballocation& suballoc = *suballocItem;
    5428  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
    5429 
    5430  *pSumFreeSize = suballoc.size;
    5431 
    5432  // Size of this suballocation is too small for this request: Early return.
    5433  if(suballoc.size < allocSize)
    5434  {
    5435  return false;
    5436  }
    5437 
    5438  // Start from offset equal to beginning of this suballocation.
    5439  *pOffset = suballoc.offset;
    5440 
    5441  // Apply VMA_DEBUG_MARGIN at the beginning.
    5442  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
    5443  {
    5444  *pOffset += VMA_DEBUG_MARGIN;
    5445  }
    5446 
    5447  // Apply alignment.
    5448  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
    5449  *pOffset = VmaAlignUp(*pOffset, alignment);
    5450 
    5451  // Check previous suballocations for BufferImageGranularity conflicts.
    5452  // Make bigger alignment if necessary.
    5453  if(bufferImageGranularity > 1)
    5454  {
    5455  bool bufferImageGranularityConflict = false;
    5456  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
    5457  while(prevSuballocItem != m_Suballocations.cbegin())
    5458  {
    5459  --prevSuballocItem;
    5460  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
    5461  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
    5462  {
    5463  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
    5464  {
    5465  bufferImageGranularityConflict = true;
    5466  break;
    5467  }
    5468  }
    5469  else
    5470  // Already on previous page.
    5471  break;
    5472  }
    5473  if(bufferImageGranularityConflict)
    5474  {
    5475  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
    5476  }
    5477  }
    5478 
    5479  // Calculate padding at the beginning based on current offset.
    5480  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
    5481 
    5482  // Calculate required margin at the end if this is not last suballocation.
    5483  VmaSuballocationList::const_iterator next = suballocItem;
    5484  ++next;
    5485  const VkDeviceSize requiredEndMargin =
    5486  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
    5487 
    5488  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
    5489  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
    5490  {
    5491  return false;
    5492  }
    5493 
    5494  // Check next suballocations for BufferImageGranularity conflicts.
    5495  // If conflict exists, allocation cannot be made here.
    5496  if(bufferImageGranularity > 1)
    5497  {
    5498  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
    5499  ++nextSuballocItem;
    5500  while(nextSuballocItem != m_Suballocations.cend())
    5501  {
    5502  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
    5503  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
    5504  {
    5505  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
    5506  {
    5507  return false;
    5508  }
    5509  }
    5510  else
    5511  {
    5512  // Already on next page.
    5513  break;
    5514  }
    5515  ++nextSuballocItem;
    5516  }
    5517  }
    5518  }
    5519 
    5520  // All tests passed: Success. pOffset is already filled.
    5521  return true;
    5522 }
    5523 
    5524 void VmaBlockMetadata::MergeFreeWithNext(VmaSuballocationList::iterator item)
    5525 {
    5526  VMA_ASSERT(item != m_Suballocations.end());
    5527  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5528 
    5529  VmaSuballocationList::iterator nextItem = item;
    5530  ++nextItem;
    5531  VMA_ASSERT(nextItem != m_Suballocations.end());
    5532  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
    5533 
    5534  item->size += nextItem->size;
    5535  --m_FreeCount;
    5536  m_Suballocations.erase(nextItem);
    5537 }
    5538 
    5539 VmaSuballocationList::iterator VmaBlockMetadata::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
    5540 {
    5541  // Change this suballocation to be marked as free.
    5542  VmaSuballocation& suballoc = *suballocItem;
    5543  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    5544  suballoc.hAllocation = VK_NULL_HANDLE;
    5545 
    5546  // Update totals.
    5547  ++m_FreeCount;
    5548  m_SumFreeSize += suballoc.size;
    5549 
    5550  // Merge with previous and/or next suballocation if it's also free.
    5551  bool mergeWithNext = false;
    5552  bool mergeWithPrev = false;
    5553 
    5554  VmaSuballocationList::iterator nextItem = suballocItem;
    5555  ++nextItem;
    5556  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
    5557  {
    5558  mergeWithNext = true;
    5559  }
    5560 
    5561  VmaSuballocationList::iterator prevItem = suballocItem;
    5562  if(suballocItem != m_Suballocations.begin())
    5563  {
    5564  --prevItem;
    5565  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
    5566  {
    5567  mergeWithPrev = true;
    5568  }
    5569  }
    5570 
    5571  if(mergeWithNext)
    5572  {
    5573  UnregisterFreeSuballocation(nextItem);
    5574  MergeFreeWithNext(suballocItem);
    5575  }
    5576 
    5577  if(mergeWithPrev)
    5578  {
    5579  UnregisterFreeSuballocation(prevItem);
    5580  MergeFreeWithNext(prevItem);
    5581  RegisterFreeSuballocation(prevItem);
    5582  return prevItem;
    5583  }
    5584  else
    5585  {
    5586  RegisterFreeSuballocation(suballocItem);
    5587  return suballocItem;
    5588  }
    5589 }
    5590 
    5591 void VmaBlockMetadata::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
    5592 {
    5593  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5594  VMA_ASSERT(item->size > 0);
    5595 
    5596  // You may want to enable this validation at the beginning or at the end of
    5597  // this function, depending on what do you want to check.
    5598  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5599 
    5600  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    5601  {
    5602  if(m_FreeSuballocationsBySize.empty())
    5603  {
    5604  m_FreeSuballocationsBySize.push_back(item);
    5605  }
    5606  else
    5607  {
    5608  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
    5609  }
    5610  }
    5611 
    5612  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5613 }
    5614 
    5615 
    5616 void VmaBlockMetadata::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
    5617 {
    5618  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5619  VMA_ASSERT(item->size > 0);
    5620 
    5621  // You may want to enable this validation at the beginning or at the end of
    5622  // this function, depending on what do you want to check.
    5623  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5624 
    5625  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    5626  {
    5627  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
    5628  m_FreeSuballocationsBySize.data(),
    5629  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
    5630  item,
    5631  VmaSuballocationItemSizeLess());
    5632  for(size_t index = it - m_FreeSuballocationsBySize.data();
    5633  index < m_FreeSuballocationsBySize.size();
    5634  ++index)
    5635  {
    5636  if(m_FreeSuballocationsBySize[index] == item)
    5637  {
    5638  VmaVectorRemove(m_FreeSuballocationsBySize, index);
    5639  return;
    5640  }
    5641  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
    5642  }
    5643  VMA_ASSERT(0 && "Not found.");
    5644  }
    5645 
    5646  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5647 }
    5648 
    5650 // class VmaDeviceMemoryMapping
    5651 
    5652 VmaDeviceMemoryMapping::VmaDeviceMemoryMapping() :
    5653  m_MapCount(0),
    5654  m_pMappedData(VMA_NULL)
    5655 {
    5656 }
    5657 
    5658 VmaDeviceMemoryMapping::~VmaDeviceMemoryMapping()
    5659 {
    5660  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
    5661 }
    5662 
    5663 VkResult VmaDeviceMemoryMapping::Map(VmaAllocator hAllocator, VkDeviceMemory hMemory, void **ppData)
    5664 {
    5665  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
    5666  if(m_MapCount != 0)
    5667  {
    5668  ++m_MapCount;
    5669  VMA_ASSERT(m_pMappedData != VMA_NULL);
    5670  if(ppData != VMA_NULL)
    5671  {
    5672  *ppData = m_pMappedData;
    5673  }
    5674  return VK_SUCCESS;
    5675  }
    5676  else
    5677  {
    5678  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
    5679  hAllocator->m_hDevice,
    5680  hMemory,
    5681  0, // offset
    5682  VK_WHOLE_SIZE,
    5683  0, // flags
    5684  &m_pMappedData);
    5685  if(result == VK_SUCCESS)
    5686  {
    5687  if(ppData != VMA_NULL)
    5688  {
    5689  *ppData = m_pMappedData;
    5690  }
    5691  m_MapCount = 1;
    5692  }
    5693  return result;
    5694  }
    5695 }
    5696 
    5697 void VmaDeviceMemoryMapping::Unmap(VmaAllocator hAllocator, VkDeviceMemory hMemory)
    5698 {
    5699  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
    5700  if(m_MapCount != 0)
    5701  {
    5702  if(--m_MapCount == 0)
    5703  {
    5704  m_pMappedData = VMA_NULL;
    5705  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, hMemory);
    5706  }
    5707  }
    5708  else
    5709  {
    5710  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
    5711  }
    5712 }
    5713 
    5715 // class VmaDeviceMemoryBlock
    5716 
    5717 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
    5718  m_MemoryTypeIndex(UINT32_MAX),
    5719  m_hMemory(VK_NULL_HANDLE),
    5720  m_Metadata(hAllocator)
    5721 {
    5722 }
    5723 
    5724 void VmaDeviceMemoryBlock::Init(
    5725  uint32_t newMemoryTypeIndex,
    5726  VkDeviceMemory newMemory,
    5727  VkDeviceSize newSize)
    5728 {
    5729  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
    5730 
    5731  m_MemoryTypeIndex = newMemoryTypeIndex;
    5732  m_hMemory = newMemory;
    5733 
    5734  m_Metadata.Init(newSize);
    5735 }
    5736 
    5737 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
    5738 {
    5739  // This is the most important assert in the entire library.
    5740  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
    5741  VMA_ASSERT(m_Metadata.IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
    5742 
    5743  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
    5744  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Metadata.GetSize(), m_hMemory);
    5745  m_hMemory = VK_NULL_HANDLE;
    5746 }
    5747 
    5748 bool VmaDeviceMemoryBlock::Validate() const
    5749 {
    5750  if((m_hMemory == VK_NULL_HANDLE) ||
    5751  (m_Metadata.GetSize() == 0))
    5752  {
    5753  return false;
    5754  }
    5755 
    5756  return m_Metadata.Validate();
    5757 }
    5758 
    5759 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, void** ppData)
    5760 {
    5761  return m_Mapping.Map(hAllocator, m_hMemory, ppData);
    5762 }
    5763 
    5764 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator)
    5765 {
    5766  m_Mapping.Unmap(hAllocator, m_hMemory);
    5767 }
    5768 
    5769 static void InitStatInfo(VmaStatInfo& outInfo)
    5770 {
    5771  memset(&outInfo, 0, sizeof(outInfo));
    5772  outInfo.allocationSizeMin = UINT64_MAX;
    5773  outInfo.unusedRangeSizeMin = UINT64_MAX;
    5774 }
    5775 
    5776 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
    5777 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
    5778 {
    5779  inoutInfo.blockCount += srcInfo.blockCount;
    5780  inoutInfo.allocationCount += srcInfo.allocationCount;
    5781  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
    5782  inoutInfo.usedBytes += srcInfo.usedBytes;
    5783  inoutInfo.unusedBytes += srcInfo.unusedBytes;
    5784  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
    5785  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
    5786  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
    5787  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
    5788 }
    5789 
    5790 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
    5791 {
    5792  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
    5793  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
    5794  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
    5795  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
    5796 }
    5797 
    5798 VmaPool_T::VmaPool_T(
    5799  VmaAllocator hAllocator,
    5800  const VmaPoolCreateInfo& createInfo) :
    5801  m_BlockVector(
    5802  hAllocator,
    5803  createInfo.memoryTypeIndex,
    5804  createInfo.blockSize,
    5805  createInfo.minBlockCount,
    5806  createInfo.maxBlockCount,
    5807  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
    5808  createInfo.frameInUseCount,
    5809  true) // isCustomPool
    5810 {
    5811 }
    5812 
    5813 VmaPool_T::~VmaPool_T()
    5814 {
    5815 }
    5816 
    5817 #if VMA_STATS_STRING_ENABLED
    5818 
    5819 #endif // #if VMA_STATS_STRING_ENABLED
    5820 
    5821 VmaBlockVector::VmaBlockVector(
    5822  VmaAllocator hAllocator,
    5823  uint32_t memoryTypeIndex,
    5824  VkDeviceSize preferredBlockSize,
    5825  size_t minBlockCount,
    5826  size_t maxBlockCount,
    5827  VkDeviceSize bufferImageGranularity,
    5828  uint32_t frameInUseCount,
    5829  bool isCustomPool) :
    5830  m_hAllocator(hAllocator),
    5831  m_MemoryTypeIndex(memoryTypeIndex),
    5832  m_PreferredBlockSize(preferredBlockSize),
    5833  m_MinBlockCount(minBlockCount),
    5834  m_MaxBlockCount(maxBlockCount),
    5835  m_BufferImageGranularity(bufferImageGranularity),
    5836  m_FrameInUseCount(frameInUseCount),
    5837  m_IsCustomPool(isCustomPool),
    5838  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
    5839  m_HasEmptyBlock(false),
    5840  m_pDefragmentator(VMA_NULL)
    5841 {
    5842 }
    5843 
    5844 VmaBlockVector::~VmaBlockVector()
    5845 {
    5846  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
    5847 
    5848  for(size_t i = m_Blocks.size(); i--; )
    5849  {
    5850  m_Blocks[i]->Destroy(m_hAllocator);
    5851  vma_delete(m_hAllocator, m_Blocks[i]);
    5852  }
    5853 }
    5854 
    5855 VkResult VmaBlockVector::CreateMinBlocks()
    5856 {
    5857  for(size_t i = 0; i < m_MinBlockCount; ++i)
    5858  {
    5859  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
    5860  if(res != VK_SUCCESS)
    5861  {
    5862  return res;
    5863  }
    5864  }
    5865  return VK_SUCCESS;
    5866 }
    5867 
    5868 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
    5869 {
    5870  pStats->size = 0;
    5871  pStats->unusedSize = 0;
    5872  pStats->allocationCount = 0;
    5873  pStats->unusedRangeCount = 0;
    5874  pStats->unusedRangeSizeMax = 0;
    5875 
    5876  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    5877 
    5878  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    5879  {
    5880  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
    5881  VMA_ASSERT(pBlock);
    5882  VMA_HEAVY_ASSERT(pBlock->Validate());
    5883  pBlock->m_Metadata.AddPoolStats(*pStats);
    5884  }
    5885 }
    5886 
    5887 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
    5888 
    5889 VkResult VmaBlockVector::Allocate(
    5890  VmaPool hCurrentPool,
    5891  uint32_t currentFrameIndex,
    5892  const VkMemoryRequirements& vkMemReq,
    5893  const VmaAllocationCreateInfo& createInfo,
    5894  VmaSuballocationType suballocType,
    5895  VmaAllocation* pAllocation)
    5896 {
    5897  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
    5898  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
    5899 
    5900  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    5901 
    5902  // 1. Search existing allocations. Try to allocate without making other allocations lost.
    5903  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
    5904  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
    5905  {
    5906  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
    5907  VMA_ASSERT(pCurrBlock);
    5908  VmaAllocationRequest currRequest = {};
    5909  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
    5910  currentFrameIndex,
    5911  m_FrameInUseCount,
    5912  m_BufferImageGranularity,
    5913  vkMemReq.size,
    5914  vkMemReq.alignment,
    5915  suballocType,
    5916  false, // canMakeOtherLost
    5917  &currRequest))
    5918  {
    5919  // Allocate from pCurrBlock.
    5920  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
    5921 
    5922  if(mapped)
    5923  {
    5924  VkResult res = pCurrBlock->Map(m_hAllocator, nullptr);
    5925  if(res != VK_SUCCESS)
    5926  {
    5927  return res;
    5928  }
    5929  }
    5930 
    5931  // We no longer have an empty Allocation.
    5932  if(pCurrBlock->m_Metadata.IsEmpty())
    5933  {
    5934  m_HasEmptyBlock = false;
    5935  }
    5936 
    5937  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
    5938  pCurrBlock->m_Metadata.Alloc(currRequest, suballocType, vkMemReq.size, *pAllocation);
    5939  (*pAllocation)->InitBlockAllocation(
    5940  hCurrentPool,
    5941  pCurrBlock,
    5942  currRequest.offset,
    5943  vkMemReq.alignment,
    5944  vkMemReq.size,
    5945  suballocType,
    5946  mapped,
    5947  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
    5948  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
    5949  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
    5950  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
    5951  return VK_SUCCESS;
    5952  }
    5953  }
    5954 
    5955  const bool canCreateNewBlock =
    5956  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
    5957  (m_Blocks.size() < m_MaxBlockCount);
    5958 
    5959  // 2. Try to create new block.
    5960  if(canCreateNewBlock)
    5961  {
    5962  // Calculate optimal size for new block.
    5963  VkDeviceSize newBlockSize = m_PreferredBlockSize;
    5964  uint32_t newBlockSizeShift = 0;
    5965  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
    5966 
    5967  // Allocating blocks of other sizes is allowed only in default pools.
    5968  // In custom pools block size is fixed.
    5969  if(m_IsCustomPool == false)
    5970  {
    5971  // Allocate 1/8, 1/4, 1/2 as first blocks.
    5972  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
    5973  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
    5974  {
    5975  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
    5976  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= vkMemReq.size * 2)
    5977  {
    5978  newBlockSize = smallerNewBlockSize;
    5979  ++newBlockSizeShift;
    5980  }
    5981  else
    5982  {
    5983  break;
    5984  }
    5985  }
    5986  }
    5987 
    5988  size_t newBlockIndex = 0;
    5989  VkResult res = CreateBlock(newBlockSize, &newBlockIndex);
    5990  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
    5991  if(m_IsCustomPool == false)
    5992  {
    5993  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
    5994  {
    5995  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
    5996  if(smallerNewBlockSize >= vkMemReq.size)
    5997  {
    5998  newBlockSize = smallerNewBlockSize;
    5999  ++newBlockSizeShift;
    6000  res = CreateBlock(newBlockSize, &newBlockIndex);
    6001  }
    6002  else
    6003  {
    6004  break;
    6005  }
    6006  }
    6007  }
    6008 
    6009  if(res == VK_SUCCESS)
    6010  {
    6011  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
    6012  VMA_ASSERT(pBlock->m_Metadata.GetSize() >= vkMemReq.size);
    6013 
    6014  if(mapped)
    6015  {
    6016  res = pBlock->Map(m_hAllocator, nullptr);
    6017  if(res != VK_SUCCESS)
    6018  {
    6019  return res;
    6020  }
    6021  }
    6022 
    6023  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
    6024  VmaAllocationRequest allocRequest;
    6025  pBlock->m_Metadata.CreateFirstAllocationRequest(&allocRequest);
    6026  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
    6027  pBlock->m_Metadata.Alloc(allocRequest, suballocType, vkMemReq.size, *pAllocation);
    6028  (*pAllocation)->InitBlockAllocation(
    6029  hCurrentPool,
    6030  pBlock,
    6031  allocRequest.offset,
    6032  vkMemReq.alignment,
    6033  vkMemReq.size,
    6034  suballocType,
    6035  mapped,
    6036  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
    6037  VMA_HEAVY_ASSERT(pBlock->Validate());
    6038  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
    6039  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
    6040  return VK_SUCCESS;
    6041  }
    6042  }
    6043 
    6044  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
    6045 
    6046  // 3. Try to allocate from existing blocks with making other allocations lost.
    6047  if(canMakeOtherLost)
    6048  {
    6049  uint32_t tryIndex = 0;
    6050  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
    6051  {
    6052  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
    6053  VmaAllocationRequest bestRequest = {};
    6054  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
    6055 
    6056  // 1. Search existing allocations.
    6057  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
    6058  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
    6059  {
    6060  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
    6061  VMA_ASSERT(pCurrBlock);
    6062  VmaAllocationRequest currRequest = {};
    6063  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
    6064  currentFrameIndex,
    6065  m_FrameInUseCount,
    6066  m_BufferImageGranularity,
    6067  vkMemReq.size,
    6068  vkMemReq.alignment,
    6069  suballocType,
    6070  canMakeOtherLost,
    6071  &currRequest))
    6072  {
    6073  const VkDeviceSize currRequestCost = currRequest.CalcCost();
    6074  if(pBestRequestBlock == VMA_NULL ||
    6075  currRequestCost < bestRequestCost)
    6076  {
    6077  pBestRequestBlock = pCurrBlock;
    6078  bestRequest = currRequest;
    6079  bestRequestCost = currRequestCost;
    6080 
    6081  if(bestRequestCost == 0)
    6082  {
    6083  break;
    6084  }
    6085  }
    6086  }
    6087  }
    6088 
    6089  if(pBestRequestBlock != VMA_NULL)
    6090  {
    6091  if(mapped)
    6092  {
    6093  VkResult res = pBestRequestBlock->Map(m_hAllocator, nullptr);
    6094  if(res != VK_SUCCESS)
    6095  {
    6096  return res;
    6097  }
    6098  }
    6099 
    6100  if(pBestRequestBlock->m_Metadata.MakeRequestedAllocationsLost(
    6101  currentFrameIndex,
    6102  m_FrameInUseCount,
    6103  &bestRequest))
    6104  {
    6105  // We no longer have an empty Allocation.
    6106  if(pBestRequestBlock->m_Metadata.IsEmpty())
    6107  {
    6108  m_HasEmptyBlock = false;
    6109  }
    6110  // Allocate from this pBlock.
    6111  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
    6112  pBestRequestBlock->m_Metadata.Alloc(bestRequest, suballocType, vkMemReq.size, *pAllocation);
    6113  (*pAllocation)->InitBlockAllocation(
    6114  hCurrentPool,
    6115  pBestRequestBlock,
    6116  bestRequest.offset,
    6117  vkMemReq.alignment,
    6118  vkMemReq.size,
    6119  suballocType,
    6120  mapped,
    6121  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
    6122  VMA_HEAVY_ASSERT(pBlock->Validate());
    6123  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
    6124  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
    6125  return VK_SUCCESS;
    6126  }
    6127  // else: Some allocations must have been touched while we are here. Next try.
    6128  }
    6129  else
    6130  {
    6131  // Could not find place in any of the blocks - break outer loop.
    6132  break;
    6133  }
    6134  }
    6135  /* Maximum number of tries exceeded - a very unlike event when many other
    6136  threads are simultaneously touching allocations making it impossible to make
    6137  lost at the same time as we try to allocate. */
    6138  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
    6139  {
    6140  return VK_ERROR_TOO_MANY_OBJECTS;
    6141  }
    6142  }
    6143 
    6144  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    6145 }
    6146 
    6147 void VmaBlockVector::Free(
    6148  VmaAllocation hAllocation)
    6149 {
    6150  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
    6151 
    6152  // Scope for lock.
    6153  {
    6154  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6155 
    6156  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
    6157 
    6158  if(hAllocation->IsPersistentMap())
    6159  {
    6160  pBlock->m_Mapping.Unmap(m_hAllocator, pBlock->m_hMemory);
    6161  }
    6162 
    6163  pBlock->m_Metadata.Free(hAllocation);
    6164  VMA_HEAVY_ASSERT(pBlock->Validate());
    6165 
    6166  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
    6167 
    6168  // pBlock became empty after this deallocation.
    6169  if(pBlock->m_Metadata.IsEmpty())
    6170  {
    6171  // Already has empty Allocation. We don't want to have two, so delete this one.
    6172  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
    6173  {
    6174  pBlockToDelete = pBlock;
    6175  Remove(pBlock);
    6176  }
    6177  // We now have first empty Allocation.
    6178  else
    6179  {
    6180  m_HasEmptyBlock = true;
    6181  }
    6182  }
    6183  // pBlock didn't become empty, but we have another empty block - find and free that one.
    6184  // (This is optional, heuristics.)
    6185  else if(m_HasEmptyBlock)
    6186  {
    6187  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
    6188  if(pLastBlock->m_Metadata.IsEmpty() && m_Blocks.size() > m_MinBlockCount)
    6189  {
    6190  pBlockToDelete = pLastBlock;
    6191  m_Blocks.pop_back();
    6192  m_HasEmptyBlock = false;
    6193  }
    6194  }
    6195 
    6196  IncrementallySortBlocks();
    6197  }
    6198 
    6199  // Destruction of a free Allocation. Deferred until this point, outside of mutex
    6200  // lock, for performance reason.
    6201  if(pBlockToDelete != VMA_NULL)
    6202  {
    6203  VMA_DEBUG_LOG(" Deleted empty allocation");
    6204  pBlockToDelete->Destroy(m_hAllocator);
    6205  vma_delete(m_hAllocator, pBlockToDelete);
    6206  }
    6207 }
    6208 
    6209 size_t VmaBlockVector::CalcMaxBlockSize() const
    6210 {
    6211  size_t result = 0;
    6212  for(size_t i = m_Blocks.size(); i--; )
    6213  {
    6214  result = VMA_MAX(result, m_Blocks[i]->m_Metadata.GetSize());
    6215  if(result >= m_PreferredBlockSize)
    6216  {
    6217  break;
    6218  }
    6219  }
    6220  return result;
    6221 }
    6222 
    6223 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
    6224 {
    6225  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    6226  {
    6227  if(m_Blocks[blockIndex] == pBlock)
    6228  {
    6229  VmaVectorRemove(m_Blocks, blockIndex);
    6230  return;
    6231  }
    6232  }
    6233  VMA_ASSERT(0);
    6234 }
    6235 
    6236 void VmaBlockVector::IncrementallySortBlocks()
    6237 {
    6238  // Bubble sort only until first swap.
    6239  for(size_t i = 1; i < m_Blocks.size(); ++i)
    6240  {
    6241  if(m_Blocks[i - 1]->m_Metadata.GetSumFreeSize() > m_Blocks[i]->m_Metadata.GetSumFreeSize())
    6242  {
    6243  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
    6244  return;
    6245  }
    6246  }
    6247 }
    6248 
    6249 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
    6250 {
    6251  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
    6252  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
    6253  allocInfo.allocationSize = blockSize;
    6254  VkDeviceMemory mem = VK_NULL_HANDLE;
    6255  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
    6256  if(res < 0)
    6257  {
    6258  return res;
    6259  }
    6260 
    6261  // New VkDeviceMemory successfully created.
    6262 
    6263  // Create new Allocation for it.
    6264  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
    6265  pBlock->Init(
    6266  m_MemoryTypeIndex,
    6267  mem,
    6268  allocInfo.allocationSize);
    6269 
    6270  m_Blocks.push_back(pBlock);
    6271  if(pNewBlockIndex != VMA_NULL)
    6272  {
    6273  *pNewBlockIndex = m_Blocks.size() - 1;
    6274  }
    6275 
    6276  return VK_SUCCESS;
    6277 }
    6278 
    6279 #if VMA_STATS_STRING_ENABLED
    6280 
    6281 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
    6282 {
    6283  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6284 
    6285  json.BeginObject();
    6286 
    6287  if(m_IsCustomPool)
    6288  {
    6289  json.WriteString("MemoryTypeIndex");
    6290  json.WriteNumber(m_MemoryTypeIndex);
    6291 
    6292  json.WriteString("BlockSize");
    6293  json.WriteNumber(m_PreferredBlockSize);
    6294 
    6295  json.WriteString("BlockCount");
    6296  json.BeginObject(true);
    6297  if(m_MinBlockCount > 0)
    6298  {
    6299  json.WriteString("Min");
    6300  json.WriteNumber(m_MinBlockCount);
    6301  }
    6302  if(m_MaxBlockCount < SIZE_MAX)
    6303  {
    6304  json.WriteString("Max");
    6305  json.WriteNumber(m_MaxBlockCount);
    6306  }
    6307  json.WriteString("Cur");
    6308  json.WriteNumber(m_Blocks.size());
    6309  json.EndObject();
    6310 
    6311  if(m_FrameInUseCount > 0)
    6312  {
    6313  json.WriteString("FrameInUseCount");
    6314  json.WriteNumber(m_FrameInUseCount);
    6315  }
    6316  }
    6317  else
    6318  {
    6319  json.WriteString("PreferredBlockSize");
    6320  json.WriteNumber(m_PreferredBlockSize);
    6321  }
    6322 
    6323  json.WriteString("Blocks");
    6324  json.BeginArray();
    6325  for(size_t i = 0; i < m_Blocks.size(); ++i)
    6326  {
    6327  m_Blocks[i]->m_Metadata.PrintDetailedMap(json);
    6328  }
    6329  json.EndArray();
    6330 
    6331  json.EndObject();
    6332 }
    6333 
    6334 #endif // #if VMA_STATS_STRING_ENABLED
    6335 
    6336 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
    6337  VmaAllocator hAllocator,
    6338  uint32_t currentFrameIndex)
    6339 {
    6340  if(m_pDefragmentator == VMA_NULL)
    6341  {
    6342  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
    6343  hAllocator,
    6344  this,
    6345  currentFrameIndex);
    6346  }
    6347 
    6348  return m_pDefragmentator;
    6349 }
    6350 
    6351 VkResult VmaBlockVector::Defragment(
    6352  VmaDefragmentationStats* pDefragmentationStats,
    6353  VkDeviceSize& maxBytesToMove,
    6354  uint32_t& maxAllocationsToMove)
    6355 {
    6356  if(m_pDefragmentator == VMA_NULL)
    6357  {
    6358  return VK_SUCCESS;
    6359  }
    6360 
    6361  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6362 
    6363  // Defragment.
    6364  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
    6365 
    6366  // Accumulate statistics.
    6367  if(pDefragmentationStats != VMA_NULL)
    6368  {
    6369  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
    6370  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
    6371  pDefragmentationStats->bytesMoved += bytesMoved;
    6372  pDefragmentationStats->allocationsMoved += allocationsMoved;
    6373  VMA_ASSERT(bytesMoved <= maxBytesToMove);
    6374  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
    6375  maxBytesToMove -= bytesMoved;
    6376  maxAllocationsToMove -= allocationsMoved;
    6377  }
    6378 
    6379  // Free empty blocks.
    6380  m_HasEmptyBlock = false;
    6381  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
    6382  {
    6383  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
    6384  if(pBlock->m_Metadata.IsEmpty())
    6385  {
    6386  if(m_Blocks.size() > m_MinBlockCount)
    6387  {
    6388  if(pDefragmentationStats != VMA_NULL)
    6389  {
    6390  ++pDefragmentationStats->deviceMemoryBlocksFreed;
    6391  pDefragmentationStats->bytesFreed += pBlock->m_Metadata.GetSize();
    6392  }
    6393 
    6394  VmaVectorRemove(m_Blocks, blockIndex);
    6395  pBlock->Destroy(m_hAllocator);
    6396  vma_delete(m_hAllocator, pBlock);
    6397  }
    6398  else
    6399  {
    6400  m_HasEmptyBlock = true;
    6401  }
    6402  }
    6403  }
    6404 
    6405  return result;
    6406 }
    6407 
    6408 void VmaBlockVector::DestroyDefragmentator()
    6409 {
    6410  if(m_pDefragmentator != VMA_NULL)
    6411  {
    6412  vma_delete(m_hAllocator, m_pDefragmentator);
    6413  m_pDefragmentator = VMA_NULL;
    6414  }
    6415 }
    6416 
    6417 void VmaBlockVector::MakePoolAllocationsLost(
    6418  uint32_t currentFrameIndex,
    6419  size_t* pLostAllocationCount)
    6420 {
    6421  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6422  size_t lostAllocationCount = 0;
    6423  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    6424  {
    6425  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
    6426  VMA_ASSERT(pBlock);
    6427  lostAllocationCount += pBlock->m_Metadata.MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
    6428  }
    6429  if(pLostAllocationCount != VMA_NULL)
    6430  {
    6431  *pLostAllocationCount = lostAllocationCount;
    6432  }
    6433 }
    6434 
    6435 void VmaBlockVector::AddStats(VmaStats* pStats)
    6436 {
    6437  const uint32_t memTypeIndex = m_MemoryTypeIndex;
    6438  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
    6439 
    6440  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6441 
    6442  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    6443  {
    6444  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
    6445  VMA_ASSERT(pBlock);
    6446  VMA_HEAVY_ASSERT(pBlock->Validate());
    6447  VmaStatInfo allocationStatInfo;
    6448  pBlock->m_Metadata.CalcAllocationStatInfo(allocationStatInfo);
    6449  VmaAddStatInfo(pStats->total, allocationStatInfo);
    6450  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
    6451  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
    6452  }
    6453 }
    6454 
    6456 // VmaDefragmentator members definition
    6457 
    6458 VmaDefragmentator::VmaDefragmentator(
    6459  VmaAllocator hAllocator,
    6460  VmaBlockVector* pBlockVector,
    6461  uint32_t currentFrameIndex) :
    6462  m_hAllocator(hAllocator),
    6463  m_pBlockVector(pBlockVector),
    6464  m_CurrentFrameIndex(currentFrameIndex),
    6465  m_BytesMoved(0),
    6466  m_AllocationsMoved(0),
    6467  m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),
    6468  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
    6469 {
    6470 }
    6471 
    6472 VmaDefragmentator::~VmaDefragmentator()
    6473 {
    6474  for(size_t i = m_Blocks.size(); i--; )
    6475  {
    6476  vma_delete(m_hAllocator, m_Blocks[i]);
    6477  }
    6478 }
    6479 
    6480 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
    6481 {
    6482  AllocationInfo allocInfo;
    6483  allocInfo.m_hAllocation = hAlloc;
    6484  allocInfo.m_pChanged = pChanged;
    6485  m_Allocations.push_back(allocInfo);
    6486 }
    6487 
    6488 VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)
    6489 {
    6490  // It has already been mapped for defragmentation.
    6491  if(m_pMappedDataForDefragmentation)
    6492  {
    6493  *ppMappedData = m_pMappedDataForDefragmentation;
    6494  return VK_SUCCESS;
    6495  }
    6496 
    6497  // It is originally mapped.
    6498  if(m_pBlock->m_Mapping.GetMappedData())
    6499  {
    6500  *ppMappedData = m_pBlock->m_Mapping.GetMappedData();
    6501  return VK_SUCCESS;
    6502  }
    6503 
    6504  // Map on first usage.
    6505  VkResult res = m_pBlock->Map(hAllocator, &m_pMappedDataForDefragmentation);
    6506  *ppMappedData = m_pMappedDataForDefragmentation;
    6507  return res;
    6508 }
    6509 
    6510 void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)
    6511 {
    6512  if(m_pMappedDataForDefragmentation != VMA_NULL)
    6513  {
    6514  m_pBlock->Unmap(hAllocator);
    6515  }
    6516 }
    6517 
    6518 VkResult VmaDefragmentator::DefragmentRound(
    6519  VkDeviceSize maxBytesToMove,
    6520  uint32_t maxAllocationsToMove)
    6521 {
    6522  if(m_Blocks.empty())
    6523  {
    6524  return VK_SUCCESS;
    6525  }
    6526 
    6527  size_t srcBlockIndex = m_Blocks.size() - 1;
    6528  size_t srcAllocIndex = SIZE_MAX;
    6529  for(;;)
    6530  {
    6531  // 1. Find next allocation to move.
    6532  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
    6533  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
    6534  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
    6535  {
    6536  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
    6537  {
    6538  // Finished: no more allocations to process.
    6539  if(srcBlockIndex == 0)
    6540  {
    6541  return VK_SUCCESS;
    6542  }
    6543  else
    6544  {
    6545  --srcBlockIndex;
    6546  srcAllocIndex = SIZE_MAX;
    6547  }
    6548  }
    6549  else
    6550  {
    6551  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
    6552  }
    6553  }
    6554 
    6555  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
    6556  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
    6557 
    6558  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
    6559  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
    6560  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
    6561  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
    6562 
    6563  // 2. Try to find new place for this allocation in preceding or current block.
    6564  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
    6565  {
    6566  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
    6567  VmaAllocationRequest dstAllocRequest;
    6568  if(pDstBlockInfo->m_pBlock->m_Metadata.CreateAllocationRequest(
    6569  m_CurrentFrameIndex,
    6570  m_pBlockVector->GetFrameInUseCount(),
    6571  m_pBlockVector->GetBufferImageGranularity(),
    6572  size,
    6573  alignment,
    6574  suballocType,
    6575  false, // canMakeOtherLost
    6576  &dstAllocRequest) &&
    6577  MoveMakesSense(
    6578  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
    6579  {
    6580  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
    6581 
    6582  // Reached limit on number of allocations or bytes to move.
    6583  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
    6584  (m_BytesMoved + size > maxBytesToMove))
    6585  {
    6586  return VK_INCOMPLETE;
    6587  }
    6588 
    6589  void* pDstMappedData = VMA_NULL;
    6590  VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);
    6591  if(res != VK_SUCCESS)
    6592  {
    6593  return res;
    6594  }
    6595 
    6596  void* pSrcMappedData = VMA_NULL;
    6597  res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);
    6598  if(res != VK_SUCCESS)
    6599  {
    6600  return res;
    6601  }
    6602 
    6603  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
    6604  memcpy(
    6605  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
    6606  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
    6607  static_cast<size_t>(size));
    6608 
    6609  pDstBlockInfo->m_pBlock->m_Metadata.Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);
    6610  pSrcBlockInfo->m_pBlock->m_Metadata.Free(allocInfo.m_hAllocation);
    6611 
    6612  allocInfo.m_hAllocation->ChangeBlockAllocation(pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
    6613 
    6614  if(allocInfo.m_pChanged != VMA_NULL)
    6615  {
    6616  *allocInfo.m_pChanged = VK_TRUE;
    6617  }
    6618 
    6619  ++m_AllocationsMoved;
    6620  m_BytesMoved += size;
    6621 
    6622  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
    6623 
    6624  break;
    6625  }
    6626  }
    6627 
    6628  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
    6629 
    6630  if(srcAllocIndex > 0)
    6631  {
    6632  --srcAllocIndex;
    6633  }
    6634  else
    6635  {
    6636  if(srcBlockIndex > 0)
    6637  {
    6638  --srcBlockIndex;
    6639  srcAllocIndex = SIZE_MAX;
    6640  }
    6641  else
    6642  {
    6643  return VK_SUCCESS;
    6644  }
    6645  }
    6646  }
    6647 }
    6648 
    6649 VkResult VmaDefragmentator::Defragment(
    6650  VkDeviceSize maxBytesToMove,
    6651  uint32_t maxAllocationsToMove)
    6652 {
    6653  if(m_Allocations.empty())
    6654  {
    6655  return VK_SUCCESS;
    6656  }
    6657 
    6658  // Create block info for each block.
    6659  const size_t blockCount = m_pBlockVector->m_Blocks.size();
    6660  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    6661  {
    6662  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
    6663  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
    6664  m_Blocks.push_back(pBlockInfo);
    6665  }
    6666 
    6667  // Sort them by m_pBlock pointer value.
    6668  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
    6669 
    6670  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
    6671  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
    6672  {
    6673  AllocationInfo& allocInfo = m_Allocations[blockIndex];
    6674  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
    6675  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
    6676  {
    6677  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
    6678  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
    6679  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
    6680  {
    6681  (*it)->m_Allocations.push_back(allocInfo);
    6682  }
    6683  else
    6684  {
    6685  VMA_ASSERT(0);
    6686  }
    6687  }
    6688  }
    6689  m_Allocations.clear();
    6690 
    6691  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    6692  {
    6693  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
    6694  pBlockInfo->CalcHasNonMovableAllocations();
    6695  pBlockInfo->SortAllocationsBySizeDescecnding();
    6696  }
    6697 
    6698  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
    6699  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
    6700 
    6701  // Execute defragmentation rounds (the main part).
    6702  VkResult result = VK_SUCCESS;
    6703  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
    6704  {
    6705  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
    6706  }
    6707 
    6708  // Unmap blocks that were mapped for defragmentation.
    6709  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    6710  {
    6711  m_Blocks[blockIndex]->Unmap(m_hAllocator);
    6712  }
    6713 
    6714  return result;
    6715 }
    6716 
    6717 bool VmaDefragmentator::MoveMakesSense(
    6718  size_t dstBlockIndex, VkDeviceSize dstOffset,
    6719  size_t srcBlockIndex, VkDeviceSize srcOffset)
    6720 {
    6721  if(dstBlockIndex < srcBlockIndex)
    6722  {
    6723  return true;
    6724  }
    6725  if(dstBlockIndex > srcBlockIndex)
    6726  {
    6727  return false;
    6728  }
    6729  if(dstOffset < srcOffset)
    6730  {
    6731  return true;
    6732  }
    6733  return false;
    6734 }
    6735 
    6737 // VmaAllocator_T
    6738 
    6739 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
    6740  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
    6741  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
    6742  m_hDevice(pCreateInfo->device),
    6743  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
    6744  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
    6745  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
    6746  m_PreferredLargeHeapBlockSize(0),
    6747  m_PhysicalDevice(pCreateInfo->physicalDevice),
    6748  m_CurrentFrameIndex(0),
    6749  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks()))
    6750 {
    6751  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
    6752 
    6753  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
    6754  memset(&m_MemProps, 0, sizeof(m_MemProps));
    6755  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
    6756 
    6757  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
    6758  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
    6759 
    6760  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
    6761  {
    6762  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
    6763  }
    6764 
    6765  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
    6766  {
    6767  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
    6768  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
    6769  }
    6770 
    6771  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
    6772 
    6773  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
    6774  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
    6775 
    6776  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
    6777  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
    6778 
    6779  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
    6780  {
    6781  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
    6782  {
    6783  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
    6784  if(limit != VK_WHOLE_SIZE)
    6785  {
    6786  m_HeapSizeLimit[heapIndex] = limit;
    6787  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
    6788  {
    6789  m_MemProps.memoryHeaps[heapIndex].size = limit;
    6790  }
    6791  }
    6792  }
    6793  }
    6794 
    6795  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    6796  {
    6797  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
    6798 
    6799  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
    6800  this,
    6801  memTypeIndex,
    6802  preferredBlockSize,
    6803  0,
    6804  SIZE_MAX,
    6805  GetBufferImageGranularity(),
    6806  pCreateInfo->frameInUseCount,
    6807  false); // isCustomPool
    6808  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
    6809  // becase minBlockCount is 0.
    6810  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
    6811  }
    6812 }
    6813 
    6814 VmaAllocator_T::~VmaAllocator_T()
    6815 {
    6816  VMA_ASSERT(m_Pools.empty());
    6817 
    6818  for(size_t i = GetMemoryTypeCount(); i--; )
    6819  {
    6820  vma_delete(this, m_pDedicatedAllocations[i]);
    6821  vma_delete(this, m_pBlockVectors[i]);
    6822  }
    6823 }
    6824 
    6825 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
    6826 {
    6827 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
    6828  m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;
    6829  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;
    6830  m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
    6831  m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;
    6832  m_VulkanFunctions.vkMapMemory = &vkMapMemory;
    6833  m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;
    6834  m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;
    6835  m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;
    6836  m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;
    6837  m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;
    6838  m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;
    6839  m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;
    6840  m_VulkanFunctions.vkCreateImage = &vkCreateImage;
    6841  m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;
    6842  if(m_UseKhrDedicatedAllocation)
    6843  {
    6844  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
    6845  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
    6846  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
    6847  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
    6848  }
    6849 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
    6850 
    6851 #define VMA_COPY_IF_NOT_NULL(funcName) \
    6852  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
    6853 
    6854  if(pVulkanFunctions != VMA_NULL)
    6855  {
    6856  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
    6857  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
    6858  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
    6859  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
    6860  VMA_COPY_IF_NOT_NULL(vkMapMemory);
    6861  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
    6862  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
    6863  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
    6864  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
    6865  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
    6866  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
    6867  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
    6868  VMA_COPY_IF_NOT_NULL(vkCreateImage);
    6869  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
    6870  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
    6871  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
    6872  }
    6873 
    6874 #undef VMA_COPY_IF_NOT_NULL
    6875 
    6876  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
    6877  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
    6878  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
    6879  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
    6880  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
    6881  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
    6882  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
    6883  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
    6884  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
    6885  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
    6886  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
    6887  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
    6888  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
    6889  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
    6890  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
    6891  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
    6892  if(m_UseKhrDedicatedAllocation)
    6893  {
    6894  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
    6895  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
    6896  }
    6897 }
    6898 
    6899 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
    6900 {
    6901  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
    6902  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
    6903  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
    6904  return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
    6905 }
    6906 
    6907 VkResult VmaAllocator_T::AllocateMemoryOfType(
    6908  const VkMemoryRequirements& vkMemReq,
    6909  bool dedicatedAllocation,
    6910  VkBuffer dedicatedBuffer,
    6911  VkImage dedicatedImage,
    6912  const VmaAllocationCreateInfo& createInfo,
    6913  uint32_t memTypeIndex,
    6914  VmaSuballocationType suballocType,
    6915  VmaAllocation* pAllocation)
    6916 {
    6917  VMA_ASSERT(pAllocation != VMA_NULL);
    6918  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
    6919 
    6920  VmaAllocationCreateInfo finalCreateInfo = createInfo;
    6921 
    6922  // If memory type is not HOST_VISIBLE, disable MAPPED.
    6923  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
    6924  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
    6925  {
    6926  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
    6927  }
    6928 
    6929  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
    6930  VMA_ASSERT(blockVector);
    6931 
    6932  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
    6933  bool preferDedicatedMemory =
    6934  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
    6935  dedicatedAllocation ||
    6936  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
    6937  vkMemReq.size > preferredBlockSize / 2;
    6938 
    6939  if(preferDedicatedMemory &&
    6940  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
    6941  finalCreateInfo.pool == VK_NULL_HANDLE)
    6942  {
    6943  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
    6944  }
    6945 
    6946  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
    6947  {
    6948  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    6949  {
    6950  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    6951  }
    6952  else
    6953  {
    6954  return AllocateDedicatedMemory(
    6955  vkMemReq.size,
    6956  suballocType,
    6957  memTypeIndex,
    6958  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
    6959  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
    6960  finalCreateInfo.pUserData,
    6961  dedicatedBuffer,
    6962  dedicatedImage,
    6963  pAllocation);
    6964  }
    6965  }
    6966  else
    6967  {
    6968  VkResult res = blockVector->Allocate(
    6969  VK_NULL_HANDLE, // hCurrentPool
    6970  m_CurrentFrameIndex.load(),
    6971  vkMemReq,
    6972  finalCreateInfo,
    6973  suballocType,
    6974  pAllocation);
    6975  if(res == VK_SUCCESS)
    6976  {
    6977  return res;
    6978  }
    6979 
    6980  // 5. Try dedicated memory.
    6981  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    6982  {
    6983  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    6984  }
    6985  else
    6986  {
    6987  res = AllocateDedicatedMemory(
    6988  vkMemReq.size,
    6989  suballocType,
    6990  memTypeIndex,
    6991  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
    6992  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
    6993  finalCreateInfo.pUserData,
    6994  dedicatedBuffer,
    6995  dedicatedImage,
    6996  pAllocation);
    6997  if(res == VK_SUCCESS)
    6998  {
    6999  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
    7000  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
    7001  return VK_SUCCESS;
    7002  }
    7003  else
    7004  {
    7005  // Everything failed: Return error code.
    7006  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
    7007  return res;
    7008  }
    7009  }
    7010  }
    7011 }
    7012 
    7013 VkResult VmaAllocator_T::AllocateDedicatedMemory(
    7014  VkDeviceSize size,
    7015  VmaSuballocationType suballocType,
    7016  uint32_t memTypeIndex,
    7017  bool map,
    7018  bool isUserDataString,
    7019  void* pUserData,
    7020  VkBuffer dedicatedBuffer,
    7021  VkImage dedicatedImage,
    7022  VmaAllocation* pAllocation)
    7023 {
    7024  VMA_ASSERT(pAllocation);
    7025 
    7026  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
    7027  allocInfo.memoryTypeIndex = memTypeIndex;
    7028  allocInfo.allocationSize = size;
    7029 
    7030  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
    7031  if(m_UseKhrDedicatedAllocation)
    7032  {
    7033  if(dedicatedBuffer != VK_NULL_HANDLE)
    7034  {
    7035  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
    7036  dedicatedAllocInfo.buffer = dedicatedBuffer;
    7037  allocInfo.pNext = &dedicatedAllocInfo;
    7038  }
    7039  else if(dedicatedImage != VK_NULL_HANDLE)
    7040  {
    7041  dedicatedAllocInfo.image = dedicatedImage;
    7042  allocInfo.pNext = &dedicatedAllocInfo;
    7043  }
    7044  }
    7045 
    7046  // Allocate VkDeviceMemory.
    7047  VkDeviceMemory hMemory = VK_NULL_HANDLE;
    7048  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
    7049  if(res < 0)
    7050  {
    7051  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
    7052  return res;
    7053  }
    7054 
    7055  void* pMappedData = nullptr;
    7056  if(map)
    7057  {
    7058  res = (*m_VulkanFunctions.vkMapMemory)(
    7059  m_hDevice,
    7060  hMemory,
    7061  0,
    7062  VK_WHOLE_SIZE,
    7063  0,
    7064  &pMappedData);
    7065  if(res < 0)
    7066  {
    7067  VMA_DEBUG_LOG(" vkMapMemory FAILED");
    7068  FreeVulkanMemory(memTypeIndex, size, hMemory);
    7069  return res;
    7070  }
    7071  }
    7072 
    7073  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
    7074  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
    7075  (*pAllocation)->SetUserData(this, pUserData);
    7076 
    7077  // Register it in m_pDedicatedAllocations.
    7078  {
    7079  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7080  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
    7081  VMA_ASSERT(pDedicatedAllocations);
    7082  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);
    7083  }
    7084 
    7085  VMA_DEBUG_LOG(" Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
    7086 
    7087  return VK_SUCCESS;
    7088 }
    7089 
    7090 void VmaAllocator_T::GetBufferMemoryRequirements(
    7091  VkBuffer hBuffer,
    7092  VkMemoryRequirements& memReq,
    7093  bool& requiresDedicatedAllocation,
    7094  bool& prefersDedicatedAllocation) const
    7095 {
    7096  if(m_UseKhrDedicatedAllocation)
    7097  {
    7098  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
    7099  memReqInfo.buffer = hBuffer;
    7100 
    7101  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
    7102 
    7103  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
    7104  memReq2.pNext = &memDedicatedReq;
    7105 
    7106  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
    7107 
    7108  memReq = memReq2.memoryRequirements;
    7109  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
    7110  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
    7111  }
    7112  else
    7113  {
    7114  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
    7115  requiresDedicatedAllocation = false;
    7116  prefersDedicatedAllocation = false;
    7117  }
    7118 }
    7119 
    7120 void VmaAllocator_T::GetImageMemoryRequirements(
    7121  VkImage hImage,
    7122  VkMemoryRequirements& memReq,
    7123  bool& requiresDedicatedAllocation,
    7124  bool& prefersDedicatedAllocation) const
    7125 {
    7126  if(m_UseKhrDedicatedAllocation)
    7127  {
    7128  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
    7129  memReqInfo.image = hImage;
    7130 
    7131  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
    7132 
    7133  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
    7134  memReq2.pNext = &memDedicatedReq;
    7135 
    7136  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
    7137 
    7138  memReq = memReq2.memoryRequirements;
    7139  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
    7140  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
    7141  }
    7142  else
    7143  {
    7144  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
    7145  requiresDedicatedAllocation = false;
    7146  prefersDedicatedAllocation = false;
    7147  }
    7148 }
    7149 
    7150 VkResult VmaAllocator_T::AllocateMemory(
    7151  const VkMemoryRequirements& vkMemReq,
    7152  bool requiresDedicatedAllocation,
    7153  bool prefersDedicatedAllocation,
    7154  VkBuffer dedicatedBuffer,
    7155  VkImage dedicatedImage,
    7156  const VmaAllocationCreateInfo& createInfo,
    7157  VmaSuballocationType suballocType,
    7158  VmaAllocation* pAllocation)
    7159 {
    7160  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
    7161  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    7162  {
    7163  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
    7164  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7165  }
    7166  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
    7167  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
    7168  {
    7169  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
    7170  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7171  }
    7172  if(requiresDedicatedAllocation)
    7173  {
    7174  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    7175  {
    7176  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
    7177  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7178  }
    7179  if(createInfo.pool != VK_NULL_HANDLE)
    7180  {
    7181  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
    7182  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7183  }
    7184  }
    7185  if((createInfo.pool != VK_NULL_HANDLE) &&
    7186  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
    7187  {
    7188  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
    7189  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7190  }
    7191 
    7192  if(createInfo.pool != VK_NULL_HANDLE)
    7193  {
    7194  return createInfo.pool->m_BlockVector.Allocate(
    7195  createInfo.pool,
    7196  m_CurrentFrameIndex.load(),
    7197  vkMemReq,
    7198  createInfo,
    7199  suballocType,
    7200  pAllocation);
    7201  }
    7202  else
    7203  {
    7204  // Bit mask of memory Vulkan types acceptable for this allocation.
    7205  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
    7206  uint32_t memTypeIndex = UINT32_MAX;
    7207  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
    7208  if(res == VK_SUCCESS)
    7209  {
    7210  res = AllocateMemoryOfType(
    7211  vkMemReq,
    7212  requiresDedicatedAllocation || prefersDedicatedAllocation,
    7213  dedicatedBuffer,
    7214  dedicatedImage,
    7215  createInfo,
    7216  memTypeIndex,
    7217  suballocType,
    7218  pAllocation);
    7219  // Succeeded on first try.
    7220  if(res == VK_SUCCESS)
    7221  {
    7222  return res;
    7223  }
    7224  // Allocation from this memory type failed. Try other compatible memory types.
    7225  else
    7226  {
    7227  for(;;)
    7228  {
    7229  // Remove old memTypeIndex from list of possibilities.
    7230  memoryTypeBits &= ~(1u << memTypeIndex);
    7231  // Find alternative memTypeIndex.
    7232  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
    7233  if(res == VK_SUCCESS)
    7234  {
    7235  res = AllocateMemoryOfType(
    7236  vkMemReq,
    7237  requiresDedicatedAllocation || prefersDedicatedAllocation,
    7238  dedicatedBuffer,
    7239  dedicatedImage,
    7240  createInfo,
    7241  memTypeIndex,
    7242  suballocType,
    7243  pAllocation);
    7244  // Allocation from this alternative memory type succeeded.
    7245  if(res == VK_SUCCESS)
    7246  {
    7247  return res;
    7248  }
    7249  // else: Allocation from this memory type failed. Try next one - next loop iteration.
    7250  }
    7251  // No other matching memory type index could be found.
    7252  else
    7253  {
    7254  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
    7255  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7256  }
    7257  }
    7258  }
    7259  }
    7260  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
    7261  else
    7262  return res;
    7263  }
    7264 }
    7265 
    7266 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
    7267 {
    7268  VMA_ASSERT(allocation);
    7269 
    7270  if(allocation->CanBecomeLost() == false ||
    7271  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
    7272  {
    7273  switch(allocation->GetType())
    7274  {
    7275  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    7276  {
    7277  VmaBlockVector* pBlockVector = VMA_NULL;
    7278  VmaPool hPool = allocation->GetPool();
    7279  if(hPool != VK_NULL_HANDLE)
    7280  {
    7281  pBlockVector = &hPool->m_BlockVector;
    7282  }
    7283  else
    7284  {
    7285  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    7286  pBlockVector = m_pBlockVectors[memTypeIndex];
    7287  }
    7288  pBlockVector->Free(allocation);
    7289  }
    7290  break;
    7291  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
    7292  FreeDedicatedMemory(allocation);
    7293  break;
    7294  default:
    7295  VMA_ASSERT(0);
    7296  }
    7297  }
    7298 
    7299  allocation->SetUserData(this, VMA_NULL);
    7300  vma_delete(this, allocation);
    7301 }
    7302 
    7303 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
    7304 {
    7305  // Initialize.
    7306  InitStatInfo(pStats->total);
    7307  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
    7308  InitStatInfo(pStats->memoryType[i]);
    7309  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
    7310  InitStatInfo(pStats->memoryHeap[i]);
    7311 
    7312  // Process default pools.
    7313  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7314  {
    7315  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
    7316  VMA_ASSERT(pBlockVector);
    7317  pBlockVector->AddStats(pStats);
    7318  }
    7319 
    7320  // Process custom pools.
    7321  {
    7322  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7323  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
    7324  {
    7325  m_Pools[poolIndex]->GetBlockVector().AddStats(pStats);
    7326  }
    7327  }
    7328 
    7329  // Process dedicated allocations.
    7330  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7331  {
    7332  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
    7333  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7334  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
    7335  VMA_ASSERT(pDedicatedAllocVector);
    7336  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
    7337  {
    7338  VmaStatInfo allocationStatInfo;
    7339  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
    7340  VmaAddStatInfo(pStats->total, allocationStatInfo);
    7341  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
    7342  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
    7343  }
    7344  }
    7345 
    7346  // Postprocess.
    7347  VmaPostprocessCalcStatInfo(pStats->total);
    7348  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
    7349  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
    7350  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
    7351  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
    7352 }
    7353 
    7354 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
    7355 
    7356 VkResult VmaAllocator_T::Defragment(
    7357  VmaAllocation* pAllocations,
    7358  size_t allocationCount,
    7359  VkBool32* pAllocationsChanged,
    7360  const VmaDefragmentationInfo* pDefragmentationInfo,
    7361  VmaDefragmentationStats* pDefragmentationStats)
    7362 {
    7363  if(pAllocationsChanged != VMA_NULL)
    7364  {
    7365  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
    7366  }
    7367  if(pDefragmentationStats != VMA_NULL)
    7368  {
    7369  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
    7370  }
    7371 
    7372  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
    7373 
    7374  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
    7375 
    7376  const size_t poolCount = m_Pools.size();
    7377 
    7378  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
    7379  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
    7380  {
    7381  VmaAllocation hAlloc = pAllocations[allocIndex];
    7382  VMA_ASSERT(hAlloc);
    7383  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
    7384  // DedicatedAlloc cannot be defragmented.
    7385  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
    7386  // Only HOST_VISIBLE memory types can be defragmented.
    7387  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&
    7388  // Lost allocation cannot be defragmented.
    7389  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
    7390  {
    7391  VmaBlockVector* pAllocBlockVector = nullptr;
    7392 
    7393  const VmaPool hAllocPool = hAlloc->GetPool();
    7394  // This allocation belongs to custom pool.
    7395  if(hAllocPool != VK_NULL_HANDLE)
    7396  {
    7397  pAllocBlockVector = &hAllocPool->GetBlockVector();
    7398  }
    7399  // This allocation belongs to general pool.
    7400  else
    7401  {
    7402  pAllocBlockVector = m_pBlockVectors[memTypeIndex];
    7403  }
    7404 
    7405  VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);
    7406 
    7407  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
    7408  &pAllocationsChanged[allocIndex] : VMA_NULL;
    7409  pDefragmentator->AddAllocation(hAlloc, pChanged);
    7410  }
    7411  }
    7412 
    7413  VkResult result = VK_SUCCESS;
    7414 
    7415  // ======== Main processing.
    7416 
    7417  VkDeviceSize maxBytesToMove = SIZE_MAX;
    7418  uint32_t maxAllocationsToMove = UINT32_MAX;
    7419  if(pDefragmentationInfo != VMA_NULL)
    7420  {
    7421  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
    7422  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
    7423  }
    7424 
    7425  // Process standard memory.
    7426  for(uint32_t memTypeIndex = 0;
    7427  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
    7428  ++memTypeIndex)
    7429  {
    7430  // Only HOST_VISIBLE memory types can be defragmented.
    7431  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    7432  {
    7433  result = m_pBlockVectors[memTypeIndex]->Defragment(
    7434  pDefragmentationStats,
    7435  maxBytesToMove,
    7436  maxAllocationsToMove);
    7437  }
    7438  }
    7439 
    7440  // Process custom pools.
    7441  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
    7442  {
    7443  result = m_Pools[poolIndex]->GetBlockVector().Defragment(
    7444  pDefragmentationStats,
    7445  maxBytesToMove,
    7446  maxAllocationsToMove);
    7447  }
    7448 
    7449  // ======== Destroy defragmentators.
    7450 
    7451  // Process custom pools.
    7452  for(size_t poolIndex = poolCount; poolIndex--; )
    7453  {
    7454  m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();
    7455  }
    7456 
    7457  // Process standard memory.
    7458  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
    7459  {
    7460  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    7461  {
    7462  m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();
    7463  }
    7464  }
    7465 
    7466  return result;
    7467 }
    7468 
    7469 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
    7470 {
    7471  if(hAllocation->CanBecomeLost())
    7472  {
    7473  /*
    7474  Warning: This is a carefully designed algorithm.
    7475  Do not modify unless you really know what you're doing :)
    7476  */
    7477  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
    7478  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
    7479  for(;;)
    7480  {
    7481  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
    7482  {
    7483  pAllocationInfo->memoryType = UINT32_MAX;
    7484  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
    7485  pAllocationInfo->offset = 0;
    7486  pAllocationInfo->size = hAllocation->GetSize();
    7487  pAllocationInfo->pMappedData = VMA_NULL;
    7488  pAllocationInfo->pUserData = hAllocation->GetUserData();
    7489  return;
    7490  }
    7491  else if(localLastUseFrameIndex == localCurrFrameIndex)
    7492  {
    7493  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
    7494  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
    7495  pAllocationInfo->offset = hAllocation->GetOffset();
    7496  pAllocationInfo->size = hAllocation->GetSize();
    7497  pAllocationInfo->pMappedData = VMA_NULL;
    7498  pAllocationInfo->pUserData = hAllocation->GetUserData();
    7499  return;
    7500  }
    7501  else // Last use time earlier than current time.
    7502  {
    7503  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
    7504  {
    7505  localLastUseFrameIndex = localCurrFrameIndex;
    7506  }
    7507  }
    7508  }
    7509  }
    7510  else
    7511  {
    7512  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
    7513  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
    7514  pAllocationInfo->offset = hAllocation->GetOffset();
    7515  pAllocationInfo->size = hAllocation->GetSize();
    7516  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
    7517  pAllocationInfo->pUserData = hAllocation->GetUserData();
    7518  }
    7519 }
    7520 
    7521 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
    7522 {
    7523  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);
    7524 
    7525  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
    7526 
    7527  if(newCreateInfo.maxBlockCount == 0)
    7528  {
    7529  newCreateInfo.maxBlockCount = SIZE_MAX;
    7530  }
    7531  if(newCreateInfo.blockSize == 0)
    7532  {
    7533  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
    7534  }
    7535 
    7536  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
    7537 
    7538  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
    7539  if(res != VK_SUCCESS)
    7540  {
    7541  vma_delete(this, *pPool);
    7542  *pPool = VMA_NULL;
    7543  return res;
    7544  }
    7545 
    7546  // Add to m_Pools.
    7547  {
    7548  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7549  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
    7550  }
    7551 
    7552  return VK_SUCCESS;
    7553 }
    7554 
    7555 void VmaAllocator_T::DestroyPool(VmaPool pool)
    7556 {
    7557  // Remove from m_Pools.
    7558  {
    7559  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7560  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
    7561  VMA_ASSERT(success && "Pool not found in Allocator.");
    7562  }
    7563 
    7564  vma_delete(this, pool);
    7565 }
    7566 
    7567 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
    7568 {
    7569  pool->m_BlockVector.GetPoolStats(pPoolStats);
    7570 }
    7571 
    7572 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
    7573 {
    7574  m_CurrentFrameIndex.store(frameIndex);
    7575 }
    7576 
    7577 void VmaAllocator_T::MakePoolAllocationsLost(
    7578  VmaPool hPool,
    7579  size_t* pLostAllocationCount)
    7580 {
    7581  hPool->m_BlockVector.MakePoolAllocationsLost(
    7582  m_CurrentFrameIndex.load(),
    7583  pLostAllocationCount);
    7584 }
    7585 
    7586 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
    7587 {
    7588  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);
    7589  (*pAllocation)->InitLost();
    7590 }
    7591 
    7592 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
    7593 {
    7594  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
    7595 
    7596  VkResult res;
    7597  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
    7598  {
    7599  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
    7600  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
    7601  {
    7602  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
    7603  if(res == VK_SUCCESS)
    7604  {
    7605  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
    7606  }
    7607  }
    7608  else
    7609  {
    7610  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7611  }
    7612  }
    7613  else
    7614  {
    7615  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
    7616  }
    7617 
    7618  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
    7619  {
    7620  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
    7621  }
    7622 
    7623  return res;
    7624 }
    7625 
    7626 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
    7627 {
    7628  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
    7629  {
    7630  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
    7631  }
    7632 
    7633  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
    7634 
    7635  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
    7636  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
    7637  {
    7638  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
    7639  m_HeapSizeLimit[heapIndex] += size;
    7640  }
    7641 }
    7642 
    7643 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
    7644 {
    7645  if(hAllocation->CanBecomeLost())
    7646  {
    7647  return VK_ERROR_MEMORY_MAP_FAILED;
    7648  }
    7649 
    7650  switch(hAllocation->GetType())
    7651  {
    7652  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    7653  {
    7654  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
    7655  char *pBytes = nullptr;
    7656  VkResult res = pBlock->Map(this, (void**)&pBytes);
    7657  if(res == VK_SUCCESS)
    7658  {
    7659  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
    7660  hAllocation->BlockAllocMap();
    7661  }
    7662  return res;
    7663  }
    7664  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
    7665  return hAllocation->DedicatedAllocMap(this, ppData);
    7666  default:
    7667  VMA_ASSERT(0);
    7668  return VK_ERROR_MEMORY_MAP_FAILED;
    7669  }
    7670 }
    7671 
    7672 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
    7673 {
    7674  switch(hAllocation->GetType())
    7675  {
    7676  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    7677  {
    7678  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
    7679  hAllocation->BlockAllocUnmap();
    7680  pBlock->Unmap(this);
    7681  }
    7682  break;
    7683  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
    7684  hAllocation->DedicatedAllocUnmap(this);
    7685  break;
    7686  default:
    7687  VMA_ASSERT(0);
    7688  }
    7689 }
    7690 
    7691 void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
    7692 {
    7693  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
    7694 
    7695  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    7696  {
    7697  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7698  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
    7699  VMA_ASSERT(pDedicatedAllocations);
    7700  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
    7701  VMA_ASSERT(success);
    7702  }
    7703 
    7704  VkDeviceMemory hMemory = allocation->GetMemory();
    7705 
    7706  if(allocation->GetMappedData() != VMA_NULL)
    7707  {
    7708  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
    7709  }
    7710 
    7711  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
    7712 
    7713  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
    7714 }
    7715 
    7716 #if VMA_STATS_STRING_ENABLED
    7717 
    7718 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
    7719 {
    7720  bool dedicatedAllocationsStarted = false;
    7721  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7722  {
    7723  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7724  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
    7725  VMA_ASSERT(pDedicatedAllocVector);
    7726  if(pDedicatedAllocVector->empty() == false)
    7727  {
    7728  if(dedicatedAllocationsStarted == false)
    7729  {
    7730  dedicatedAllocationsStarted = true;
    7731  json.WriteString("DedicatedAllocations");
    7732  json.BeginObject();
    7733  }
    7734 
    7735  json.BeginString("Type ");
    7736  json.ContinueString(memTypeIndex);
    7737  json.EndString();
    7738 
    7739  json.BeginArray();
    7740 
    7741  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
    7742  {
    7743  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
    7744  json.BeginObject(true);
    7745 
    7746  json.WriteString("Type");
    7747  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[hAlloc->GetSuballocationType()]);
    7748 
    7749  json.WriteString("Size");
    7750  json.WriteNumber(hAlloc->GetSize());
    7751 
    7752  const void* pUserData = hAlloc->GetUserData();
    7753  if(pUserData != VMA_NULL)
    7754  {
    7755  json.WriteString("UserData");
    7756  if(hAlloc->IsUserDataString())
    7757  {
    7758  json.WriteString((const char*)pUserData);
    7759  }
    7760  else
    7761  {
    7762  json.BeginString();
    7763  json.ContinueString_Pointer(pUserData);
    7764  json.EndString();
    7765  }
    7766  }
    7767 
    7768  json.EndObject();
    7769  }
    7770 
    7771  json.EndArray();
    7772  }
    7773  }
    7774  if(dedicatedAllocationsStarted)
    7775  {
    7776  json.EndObject();
    7777  }
    7778 
    7779  {
    7780  bool allocationsStarted = false;
    7781  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7782  {
    7783  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
    7784  {
    7785  if(allocationsStarted == false)
    7786  {
    7787  allocationsStarted = true;
    7788  json.WriteString("DefaultPools");
    7789  json.BeginObject();
    7790  }
    7791 
    7792  json.BeginString("Type ");
    7793  json.ContinueString(memTypeIndex);
    7794  json.EndString();
    7795 
    7796  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
    7797  }
    7798  }
    7799  if(allocationsStarted)
    7800  {
    7801  json.EndObject();
    7802  }
    7803  }
    7804 
    7805  {
    7806  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7807  const size_t poolCount = m_Pools.size();
    7808  if(poolCount > 0)
    7809  {
    7810  json.WriteString("Pools");
    7811  json.BeginArray();
    7812  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
    7813  {
    7814  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
    7815  }
    7816  json.EndArray();
    7817  }
    7818  }
    7819 }
    7820 
    7821 #endif // #if VMA_STATS_STRING_ENABLED
    7822 
    7823 static VkResult AllocateMemoryForImage(
    7824  VmaAllocator allocator,
    7825  VkImage image,
    7826  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    7827  VmaSuballocationType suballocType,
    7828  VmaAllocation* pAllocation)
    7829 {
    7830  VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation);
    7831 
    7832  VkMemoryRequirements vkMemReq = {};
    7833  bool requiresDedicatedAllocation = false;
    7834  bool prefersDedicatedAllocation = false;
    7835  allocator->GetImageMemoryRequirements(image, vkMemReq,
    7836  requiresDedicatedAllocation, prefersDedicatedAllocation);
    7837 
    7838  return allocator->AllocateMemory(
    7839  vkMemReq,
    7840  requiresDedicatedAllocation,
    7841  prefersDedicatedAllocation,
    7842  VK_NULL_HANDLE, // dedicatedBuffer
    7843  image, // dedicatedImage
    7844  *pAllocationCreateInfo,
    7845  suballocType,
    7846  pAllocation);
    7847 }
    7848 
    7850 // Public interface
    7851 
    7852 VkResult vmaCreateAllocator(
    7853  const VmaAllocatorCreateInfo* pCreateInfo,
    7854  VmaAllocator* pAllocator)
    7855 {
    7856  VMA_ASSERT(pCreateInfo && pAllocator);
    7857  VMA_DEBUG_LOG("vmaCreateAllocator");
    7858  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
    7859  return VK_SUCCESS;
    7860 }
    7861 
    7862 void vmaDestroyAllocator(
    7863  VmaAllocator allocator)
    7864 {
    7865  if(allocator != VK_NULL_HANDLE)
    7866  {
    7867  VMA_DEBUG_LOG("vmaDestroyAllocator");
    7868  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
    7869  vma_delete(&allocationCallbacks, allocator);
    7870  }
    7871 }
    7872 
    7873 void vmaGetPhysicalDeviceProperties(
    7874  VmaAllocator allocator,
    7875  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
    7876 {
    7877  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
    7878  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
    7879 }
    7880 
    7881 void vmaGetMemoryProperties(
    7882  VmaAllocator allocator,
    7883  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
    7884 {
    7885  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
    7886  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
    7887 }
    7888 
    7889 void vmaGetMemoryTypeProperties(
    7890  VmaAllocator allocator,
    7891  uint32_t memoryTypeIndex,
    7892  VkMemoryPropertyFlags* pFlags)
    7893 {
    7894  VMA_ASSERT(allocator && pFlags);
    7895  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
    7896  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
    7897 }
    7898 
    7899 void vmaSetCurrentFrameIndex(
    7900  VmaAllocator allocator,
    7901  uint32_t frameIndex)
    7902 {
    7903  VMA_ASSERT(allocator);
    7904  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
    7905 
    7906  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    7907 
    7908  allocator->SetCurrentFrameIndex(frameIndex);
    7909 }
    7910 
    7911 void vmaCalculateStats(
    7912  VmaAllocator allocator,
    7913  VmaStats* pStats)
    7914 {
    7915  VMA_ASSERT(allocator && pStats);
    7916  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    7917  allocator->CalculateStats(pStats);
    7918 }
    7919 
    7920 #if VMA_STATS_STRING_ENABLED
    7921 
    7922 void vmaBuildStatsString(
    7923  VmaAllocator allocator,
    7924  char** ppStatsString,
    7925  VkBool32 detailedMap)
    7926 {
    7927  VMA_ASSERT(allocator && ppStatsString);
    7928  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    7929 
    7930  VmaStringBuilder sb(allocator);
    7931  {
    7932  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
    7933  json.BeginObject();
    7934 
    7935  VmaStats stats;
    7936  allocator->CalculateStats(&stats);
    7937 
    7938  json.WriteString("Total");
    7939  VmaPrintStatInfo(json, stats.total);
    7940 
    7941  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
    7942  {
    7943  json.BeginString("Heap ");
    7944  json.ContinueString(heapIndex);
    7945  json.EndString();
    7946  json.BeginObject();
    7947 
    7948  json.WriteString("Size");
    7949  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
    7950 
    7951  json.WriteString("Flags");
    7952  json.BeginArray(true);
    7953  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
    7954  {
    7955  json.WriteString("DEVICE_LOCAL");
    7956  }
    7957  json.EndArray();
    7958 
    7959  if(stats.memoryHeap[heapIndex].blockCount > 0)
    7960  {
    7961  json.WriteString("Stats");
    7962  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
    7963  }
    7964 
    7965  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
    7966  {
    7967  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
    7968  {
    7969  json.BeginString("Type ");
    7970  json.ContinueString(typeIndex);
    7971  json.EndString();
    7972 
    7973  json.BeginObject();
    7974 
    7975  json.WriteString("Flags");
    7976  json.BeginArray(true);
    7977  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
    7978  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
    7979  {
    7980  json.WriteString("DEVICE_LOCAL");
    7981  }
    7982  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    7983  {
    7984  json.WriteString("HOST_VISIBLE");
    7985  }
    7986  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
    7987  {
    7988  json.WriteString("HOST_COHERENT");
    7989  }
    7990  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
    7991  {
    7992  json.WriteString("HOST_CACHED");
    7993  }
    7994  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
    7995  {
    7996  json.WriteString("LAZILY_ALLOCATED");
    7997  }
    7998  json.EndArray();
    7999 
    8000  if(stats.memoryType[typeIndex].blockCount > 0)
    8001  {
    8002  json.WriteString("Stats");
    8003  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
    8004  }
    8005 
    8006  json.EndObject();
    8007  }
    8008  }
    8009 
    8010  json.EndObject();
    8011  }
    8012  if(detailedMap == VK_TRUE)
    8013  {
    8014  allocator->PrintDetailedMap(json);
    8015  }
    8016 
    8017  json.EndObject();
    8018  }
    8019 
    8020  const size_t len = sb.GetLength();
    8021  char* const pChars = vma_new_array(allocator, char, len + 1);
    8022  if(len > 0)
    8023  {
    8024  memcpy(pChars, sb.GetData(), len);
    8025  }
    8026  pChars[len] = '\0';
    8027  *ppStatsString = pChars;
    8028 }
    8029 
    8030 void vmaFreeStatsString(
    8031  VmaAllocator allocator,
    8032  char* pStatsString)
    8033 {
    8034  if(pStatsString != VMA_NULL)
    8035  {
    8036  VMA_ASSERT(allocator);
    8037  size_t len = strlen(pStatsString);
    8038  vma_delete_array(allocator, pStatsString, len + 1);
    8039  }
    8040 }
    8041 
    8042 #endif // #if VMA_STATS_STRING_ENABLED
    8043 
    8044 /*
    8045 This function is not protected by any mutex because it just reads immutable data.
    8046 */
    8047 VkResult vmaFindMemoryTypeIndex(
    8048  VmaAllocator allocator,
    8049  uint32_t memoryTypeBits,
    8050  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    8051  uint32_t* pMemoryTypeIndex)
    8052 {
    8053  VMA_ASSERT(allocator != VK_NULL_HANDLE);
    8054  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
    8055  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
    8056 
    8057  if(pAllocationCreateInfo->memoryTypeBits != 0)
    8058  {
    8059  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
    8060  }
    8061 
    8062  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
    8063  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
    8064 
    8065  // Convert usage to requiredFlags and preferredFlags.
    8066  switch(pAllocationCreateInfo->usage)
    8067  {
    8068  case VMA_MEMORY_USAGE_UNKNOWN:
    8069  break;
    8070  case VMA_MEMORY_USAGE_GPU_ONLY:
    8071  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    8072  break;
    8073  case VMA_MEMORY_USAGE_CPU_ONLY:
    8074  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
    8075  break;
    8076  case VMA_MEMORY_USAGE_CPU_TO_GPU:
    8077  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    8078  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    8079  break;
    8080  case VMA_MEMORY_USAGE_GPU_TO_CPU:
    8081  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    8082  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
    8083  break;
    8084  default:
    8085  break;
    8086  }
    8087 
    8088  *pMemoryTypeIndex = UINT32_MAX;
    8089  uint32_t minCost = UINT32_MAX;
    8090  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
    8091  memTypeIndex < allocator->GetMemoryTypeCount();
    8092  ++memTypeIndex, memTypeBit <<= 1)
    8093  {
    8094  // This memory type is acceptable according to memoryTypeBits bitmask.
    8095  if((memTypeBit & memoryTypeBits) != 0)
    8096  {
    8097  const VkMemoryPropertyFlags currFlags =
    8098  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
    8099  // This memory type contains requiredFlags.
    8100  if((requiredFlags & ~currFlags) == 0)
    8101  {
    8102  // Calculate cost as number of bits from preferredFlags not present in this memory type.
    8103  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
    8104  // Remember memory type with lowest cost.
    8105  if(currCost < minCost)
    8106  {
    8107  *pMemoryTypeIndex = memTypeIndex;
    8108  if(currCost == 0)
    8109  {
    8110  return VK_SUCCESS;
    8111  }
    8112  minCost = currCost;
    8113  }
    8114  }
    8115  }
    8116  }
    8117  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
    8118 }
    8119 
    8120 VkResult vmaCreatePool(
    8121  VmaAllocator allocator,
    8122  const VmaPoolCreateInfo* pCreateInfo,
    8123  VmaPool* pPool)
    8124 {
    8125  VMA_ASSERT(allocator && pCreateInfo && pPool);
    8126 
    8127  VMA_DEBUG_LOG("vmaCreatePool");
    8128 
    8129  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8130 
    8131  return allocator->CreatePool(pCreateInfo, pPool);
    8132 }
    8133 
    8134 void vmaDestroyPool(
    8135  VmaAllocator allocator,
    8136  VmaPool pool)
    8137 {
    8138  VMA_ASSERT(allocator);
    8139 
    8140  if(pool == VK_NULL_HANDLE)
    8141  {
    8142  return;
    8143  }
    8144 
    8145  VMA_DEBUG_LOG("vmaDestroyPool");
    8146 
    8147  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8148 
    8149  allocator->DestroyPool(pool);
    8150 }
    8151 
    8152 void vmaGetPoolStats(
    8153  VmaAllocator allocator,
    8154  VmaPool pool,
    8155  VmaPoolStats* pPoolStats)
    8156 {
    8157  VMA_ASSERT(allocator && pool && pPoolStats);
    8158 
    8159  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8160 
    8161  allocator->GetPoolStats(pool, pPoolStats);
    8162 }
    8163 
    8164 void vmaMakePoolAllocationsLost(
    8165  VmaAllocator allocator,
    8166  VmaPool pool,
    8167  size_t* pLostAllocationCount)
    8168 {
    8169  VMA_ASSERT(allocator && pool);
    8170 
    8171  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8172 
    8173  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
    8174 }
    8175 
    8176 VkResult vmaAllocateMemory(
    8177  VmaAllocator allocator,
    8178  const VkMemoryRequirements* pVkMemoryRequirements,
    8179  const VmaAllocationCreateInfo* pCreateInfo,
    8180  VmaAllocation* pAllocation,
    8181  VmaAllocationInfo* pAllocationInfo)
    8182 {
    8183  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
    8184 
    8185  VMA_DEBUG_LOG("vmaAllocateMemory");
    8186 
    8187  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8188 
    8189  VkResult result = allocator->AllocateMemory(
    8190  *pVkMemoryRequirements,
    8191  false, // requiresDedicatedAllocation
    8192  false, // prefersDedicatedAllocation
    8193  VK_NULL_HANDLE, // dedicatedBuffer
    8194  VK_NULL_HANDLE, // dedicatedImage
    8195  *pCreateInfo,
    8196  VMA_SUBALLOCATION_TYPE_UNKNOWN,
    8197  pAllocation);
    8198 
    8199  if(pAllocationInfo && result == VK_SUCCESS)
    8200  {
    8201  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8202  }
    8203 
    8204  return result;
    8205 }
    8206 
    8207 VkResult vmaAllocateMemoryForBuffer(
    8208  VmaAllocator allocator,
    8209  VkBuffer buffer,
    8210  const VmaAllocationCreateInfo* pCreateInfo,
    8211  VmaAllocation* pAllocation,
    8212  VmaAllocationInfo* pAllocationInfo)
    8213 {
    8214  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
    8215 
    8216  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
    8217 
    8218  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8219 
    8220  VkMemoryRequirements vkMemReq = {};
    8221  bool requiresDedicatedAllocation = false;
    8222  bool prefersDedicatedAllocation = false;
    8223  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
    8224  requiresDedicatedAllocation,
    8225  prefersDedicatedAllocation);
    8226 
    8227  VkResult result = allocator->AllocateMemory(
    8228  vkMemReq,
    8229  requiresDedicatedAllocation,
    8230  prefersDedicatedAllocation,
    8231  buffer, // dedicatedBuffer
    8232  VK_NULL_HANDLE, // dedicatedImage
    8233  *pCreateInfo,
    8234  VMA_SUBALLOCATION_TYPE_BUFFER,
    8235  pAllocation);
    8236 
    8237  if(pAllocationInfo && result == VK_SUCCESS)
    8238  {
    8239  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8240  }
    8241 
    8242  return result;
    8243 }
    8244 
    8245 VkResult vmaAllocateMemoryForImage(
    8246  VmaAllocator allocator,
    8247  VkImage image,
    8248  const VmaAllocationCreateInfo* pCreateInfo,
    8249  VmaAllocation* pAllocation,
    8250  VmaAllocationInfo* pAllocationInfo)
    8251 {
    8252  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
    8253 
    8254  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
    8255 
    8256  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8257 
    8258  VkResult result = AllocateMemoryForImage(
    8259  allocator,
    8260  image,
    8261  pCreateInfo,
    8262  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
    8263  pAllocation);
    8264 
    8265  if(pAllocationInfo && result == VK_SUCCESS)
    8266  {
    8267  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8268  }
    8269 
    8270  return result;
    8271 }
    8272 
    8273 void vmaFreeMemory(
    8274  VmaAllocator allocator,
    8275  VmaAllocation allocation)
    8276 {
    8277  VMA_ASSERT(allocator && allocation);
    8278 
    8279  VMA_DEBUG_LOG("vmaFreeMemory");
    8280 
    8281  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8282 
    8283  allocator->FreeMemory(allocation);
    8284 }
    8285 
    8286 void vmaGetAllocationInfo(
    8287  VmaAllocator allocator,
    8288  VmaAllocation allocation,
    8289  VmaAllocationInfo* pAllocationInfo)
    8290 {
    8291  VMA_ASSERT(allocator && allocation && pAllocationInfo);
    8292 
    8293  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8294 
    8295  allocator->GetAllocationInfo(allocation, pAllocationInfo);
    8296 }
    8297 
    8298 void vmaSetAllocationUserData(
    8299  VmaAllocator allocator,
    8300  VmaAllocation allocation,
    8301  void* pUserData)
    8302 {
    8303  VMA_ASSERT(allocator && allocation);
    8304 
    8305  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8306 
    8307  allocation->SetUserData(allocator, pUserData);
    8308 }
    8309 
    8310 void vmaCreateLostAllocation(
    8311  VmaAllocator allocator,
    8312  VmaAllocation* pAllocation)
    8313 {
    8314  VMA_ASSERT(allocator && pAllocation);
    8315 
    8316  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    8317 
    8318  allocator->CreateLostAllocation(pAllocation);
    8319 }
    8320 
    8321 VkResult vmaMapMemory(
    8322  VmaAllocator allocator,
    8323  VmaAllocation allocation,
    8324  void** ppData)
    8325 {
    8326  VMA_ASSERT(allocator && allocation && ppData);
    8327 
    8328  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8329 
    8330  return allocator->Map(allocation, ppData);
    8331 }
    8332 
    8333 void vmaUnmapMemory(
    8334  VmaAllocator allocator,
    8335  VmaAllocation allocation)
    8336 {
    8337  VMA_ASSERT(allocator && allocation);
    8338 
    8339  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8340 
    8341  allocator->Unmap(allocation);
    8342 }
    8343 
    8344 VkResult vmaDefragment(
    8345  VmaAllocator allocator,
    8346  VmaAllocation* pAllocations,
    8347  size_t allocationCount,
    8348  VkBool32* pAllocationsChanged,
    8349  const VmaDefragmentationInfo *pDefragmentationInfo,
    8350  VmaDefragmentationStats* pDefragmentationStats)
    8351 {
    8352  VMA_ASSERT(allocator && pAllocations);
    8353 
    8354  VMA_DEBUG_LOG("vmaDefragment");
    8355 
    8356  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8357 
    8358  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
    8359 }
    8360 
    8361 VkResult vmaCreateBuffer(
    8362  VmaAllocator allocator,
    8363  const VkBufferCreateInfo* pBufferCreateInfo,
    8364  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    8365  VkBuffer* pBuffer,
    8366  VmaAllocation* pAllocation,
    8367  VmaAllocationInfo* pAllocationInfo)
    8368 {
    8369  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
    8370 
    8371  VMA_DEBUG_LOG("vmaCreateBuffer");
    8372 
    8373  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8374 
    8375  *pBuffer = VK_NULL_HANDLE;
    8376  *pAllocation = VK_NULL_HANDLE;
    8377 
    8378  // 1. Create VkBuffer.
    8379  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
    8380  allocator->m_hDevice,
    8381  pBufferCreateInfo,
    8382  allocator->GetAllocationCallbacks(),
    8383  pBuffer);
    8384  if(res >= 0)
    8385  {
    8386  // 2. vkGetBufferMemoryRequirements.
    8387  VkMemoryRequirements vkMemReq = {};
    8388  bool requiresDedicatedAllocation = false;
    8389  bool prefersDedicatedAllocation = false;
    8390  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
    8391  requiresDedicatedAllocation, prefersDedicatedAllocation);
    8392 
    8393  // Make sure alignment requirements for specific buffer usages reported
    8394  // in Physical Device Properties are included in alignment reported by memory requirements.
    8395  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
    8396  {
    8397  VMA_ASSERT(vkMemReq.alignment %
    8398  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
    8399  }
    8400  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
    8401  {
    8402  VMA_ASSERT(vkMemReq.alignment %
    8403  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
    8404  }
    8405  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
    8406  {
    8407  VMA_ASSERT(vkMemReq.alignment %
    8408  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
    8409  }
    8410 
    8411  // 3. Allocate memory using allocator.
    8412  res = allocator->AllocateMemory(
    8413  vkMemReq,
    8414  requiresDedicatedAllocation,
    8415  prefersDedicatedAllocation,
    8416  *pBuffer, // dedicatedBuffer
    8417  VK_NULL_HANDLE, // dedicatedImage
    8418  *pAllocationCreateInfo,
    8419  VMA_SUBALLOCATION_TYPE_BUFFER,
    8420  pAllocation);
    8421  if(res >= 0)
    8422  {
    8423  // 3. Bind buffer with memory.
    8424  res = (*allocator->GetVulkanFunctions().vkBindBufferMemory)(
    8425  allocator->m_hDevice,
    8426  *pBuffer,
    8427  (*pAllocation)->GetMemory(),
    8428  (*pAllocation)->GetOffset());
    8429  if(res >= 0)
    8430  {
    8431  // All steps succeeded.
    8432  if(pAllocationInfo != VMA_NULL)
    8433  {
    8434  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8435  }
    8436  return VK_SUCCESS;
    8437  }
    8438  allocator->FreeMemory(*pAllocation);
    8439  *pAllocation = VK_NULL_HANDLE;
    8440  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
    8441  *pBuffer = VK_NULL_HANDLE;
    8442  return res;
    8443  }
    8444  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
    8445  *pBuffer = VK_NULL_HANDLE;
    8446  return res;
    8447  }
    8448  return res;
    8449 }
    8450 
    8451 void vmaDestroyBuffer(
    8452  VmaAllocator allocator,
    8453  VkBuffer buffer,
    8454  VmaAllocation allocation)
    8455 {
    8456  if(buffer != VK_NULL_HANDLE)
    8457  {
    8458  VMA_ASSERT(allocator);
    8459 
    8460  VMA_DEBUG_LOG("vmaDestroyBuffer");
    8461 
    8462  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8463 
    8464  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
    8465 
    8466  allocator->FreeMemory(allocation);
    8467  }
    8468 }
    8469 
    8470 VkResult vmaCreateImage(
    8471  VmaAllocator allocator,
    8472  const VkImageCreateInfo* pImageCreateInfo,
    8473  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    8474  VkImage* pImage,
    8475  VmaAllocation* pAllocation,
    8476  VmaAllocationInfo* pAllocationInfo)
    8477 {
    8478  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
    8479 
    8480  VMA_DEBUG_LOG("vmaCreateImage");
    8481 
    8482  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8483 
    8484  *pImage = VK_NULL_HANDLE;
    8485  *pAllocation = VK_NULL_HANDLE;
    8486 
    8487  // 1. Create VkImage.
    8488  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
    8489  allocator->m_hDevice,
    8490  pImageCreateInfo,
    8491  allocator->GetAllocationCallbacks(),
    8492  pImage);
    8493  if(res >= 0)
    8494  {
    8495  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
    8496  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
    8497  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
    8498 
    8499  // 2. Allocate memory using allocator.
    8500  res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation);
    8501  if(res >= 0)
    8502  {
    8503  // 3. Bind image with memory.
    8504  res = (*allocator->GetVulkanFunctions().vkBindImageMemory)(
    8505  allocator->m_hDevice,
    8506  *pImage,
    8507  (*pAllocation)->GetMemory(),
    8508  (*pAllocation)->GetOffset());
    8509  if(res >= 0)
    8510  {
    8511  // All steps succeeded.
    8512  if(pAllocationInfo != VMA_NULL)
    8513  {
    8514  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8515  }
    8516  return VK_SUCCESS;
    8517  }
    8518  allocator->FreeMemory(*pAllocation);
    8519  *pAllocation = VK_NULL_HANDLE;
    8520  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
    8521  *pImage = VK_NULL_HANDLE;
    8522  return res;
    8523  }
    8524  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
    8525  *pImage = VK_NULL_HANDLE;
    8526  return res;
    8527  }
    8528  return res;
    8529 }
    8530 
    8531 void vmaDestroyImage(
    8532  VmaAllocator allocator,
    8533  VkImage image,
    8534  VmaAllocation allocation)
    8535 {
    8536  if(image != VK_NULL_HANDLE)
    8537  {
    8538  VMA_ASSERT(allocator);
    8539 
    8540  VMA_DEBUG_LOG("vmaDestroyImage");
    8541 
    8542  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8543 
    8544  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
    8545 
    8546  allocator->FreeMemory(allocation);
    8547  }
    8548 }
    8549 
    8550 #endif // #ifdef VMA_IMPLEMENTATION
    VmaVulkanFunctions::vkGetPhysicalDeviceProperties
    PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
    Definition: vk_mem_alloc.h:758
    -
    VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
    Set this flag if the allocation should have its own memory block.
    Definition: vk_mem_alloc.h:1009
    +Go to the documentation of this file.
    1 //
    2 // Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved.
    3 //
    4 // Permission is hereby granted, free of charge, to any person obtaining a copy
    5 // of this software and associated documentation files (the "Software"), to deal
    6 // in the Software without restriction, including without limitation the rights
    7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    8 // copies of the Software, and to permit persons to whom the Software is
    9 // furnished to do so, subject to the following conditions:
    10 //
    11 // The above copyright notice and this permission notice shall be included in
    12 // all copies or substantial portions of the Software.
    13 //
    14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    20 // THE SOFTWARE.
    21 //
    22 
    23 #ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
    24 #define AMD_VULKAN_MEMORY_ALLOCATOR_H
    25 
    26 #ifdef __cplusplus
    27 extern "C" {
    28 #endif
    29 
    723 #include <vulkan/vulkan.h>
    724 
    725 VK_DEFINE_HANDLE(VmaAllocator)
    726 
    727 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
    729  VmaAllocator allocator,
    730  uint32_t memoryType,
    731  VkDeviceMemory memory,
    732  VkDeviceSize size);
    734 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
    735  VmaAllocator allocator,
    736  uint32_t memoryType,
    737  VkDeviceMemory memory,
    738  VkDeviceSize size);
    739 
    747 typedef struct VmaDeviceMemoryCallbacks {
    749  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
    751  PFN_vmaFreeDeviceMemoryFunction pfnFree;
    752 } VmaDeviceMemoryCallbacks;
    753 
    755 typedef enum VmaAllocatorCreateFlagBits {
    760  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
    782  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
    783 
    784  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    785 } VmaAllocatorCreateFlagBits;
    786 typedef VkFlags VmaAllocatorCreateFlags;
    787 
    792 typedef struct VmaVulkanFunctions {
    793  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
    794  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
    795  PFN_vkAllocateMemory vkAllocateMemory;
    796  PFN_vkFreeMemory vkFreeMemory;
    797  PFN_vkMapMemory vkMapMemory;
    798  PFN_vkUnmapMemory vkUnmapMemory;
    799  PFN_vkBindBufferMemory vkBindBufferMemory;
    800  PFN_vkBindImageMemory vkBindImageMemory;
    801  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
    802  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
    803  PFN_vkCreateBuffer vkCreateBuffer;
    804  PFN_vkDestroyBuffer vkDestroyBuffer;
    805  PFN_vkCreateImage vkCreateImage;
    806  PFN_vkDestroyImage vkDestroyImage;
    807  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
    808  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
    809 } VmaVulkanFunctions;
    810 
    812 typedef struct VmaAllocatorCreateInfo
    813 {
    815  VmaAllocatorCreateFlags flags;
    817 
    818  VkPhysicalDevice physicalDevice;
    820 
    821  VkDevice device;
    823 
    824  VkDeviceSize preferredLargeHeapBlockSize;
    826 
    827  const VkAllocationCallbacks* pAllocationCallbacks;
    829 
    830  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
    844  uint32_t frameInUseCount;
    868  const VkDeviceSize* pHeapSizeLimit;
    880  const VmaVulkanFunctions* pVulkanFunctions;
    881 } VmaAllocatorCreateInfo;
    882 
    884 VkResult vmaCreateAllocator(
    885  const VmaAllocatorCreateInfo* pCreateInfo,
    886  VmaAllocator* pAllocator);
    887 
    889 void vmaDestroyAllocator(
    890  VmaAllocator allocator);
    891 
    896 void vmaGetPhysicalDeviceProperties(
    897  VmaAllocator allocator,
    898  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
    899 
    904 void vmaGetMemoryProperties(
    905  VmaAllocator allocator,
    906  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
    907 
    914 void vmaGetMemoryTypeProperties(
    915  VmaAllocator allocator,
    916  uint32_t memoryTypeIndex,
    917  VkMemoryPropertyFlags* pFlags);
    918 
    927 void vmaSetCurrentFrameIndex(
    928  VmaAllocator allocator,
    929  uint32_t frameIndex);
    930 
    933 typedef struct VmaStatInfo
    934 {
    936  uint32_t blockCount;
    938  uint32_t allocationCount;
    940  uint32_t unusedRangeCount;
    942  VkDeviceSize usedBytes;
    944  VkDeviceSize unusedBytes;
    945  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
    946  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
    947 } VmaStatInfo;
    948 
    950 typedef struct VmaStats
    951 {
    952  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
    953  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
    954  VmaStatInfo total;
    955 } VmaStats;
    956 
    958 void vmaCalculateStats(
    959  VmaAllocator allocator,
    960  VmaStats* pStats);
    961 
    962 #define VMA_STATS_STRING_ENABLED 1
    963 
    964 #if VMA_STATS_STRING_ENABLED
    965 
    967 
    969 void vmaBuildStatsString(
    970  VmaAllocator allocator,
    971  char** ppStatsString,
    972  VkBool32 detailedMap);
    973 
    974 void vmaFreeStatsString(
    975  VmaAllocator allocator,
    976  char* pStatsString);
    977 
    978 #endif // #if VMA_STATS_STRING_ENABLED
    979 
    980 VK_DEFINE_HANDLE(VmaPool)
    981 
    982 typedef enum VmaMemoryUsage
    983 {
    987  VMA_MEMORY_USAGE_UNKNOWN = 0,
    1004  VMA_MEMORY_USAGE_GPU_ONLY = 1,
    1014  VMA_MEMORY_USAGE_CPU_ONLY = 2,
    1021  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
    1030  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
    1031  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
    1032 } VmaMemoryUsage;
    1033 
    1035 typedef enum VmaAllocationCreateFlagBits {
    1047  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
    1048 
    1058  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
    1071  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
    1084  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
    1091  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
    1097  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
    1098 
    1099  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    1100 } VmaAllocationCreateFlagBits;
    1101 typedef VkFlags VmaAllocationCreateFlags;
    1102 
    1103 typedef struct VmaAllocationCreateInfo
    1104 {
    1106  VmaAllocationCreateFlags flags;
    1112  VmaMemoryUsage usage;
    1117  VkMemoryPropertyFlags requiredFlags;
    1122  VkMemoryPropertyFlags preferredFlags;
    1130  uint32_t memoryTypeBits;
    1136  VmaPool pool;
    1143  void* pUserData;
    1144 } VmaAllocationCreateInfo;
    1145 
    1160 VkResult vmaFindMemoryTypeIndex(
    1161  VmaAllocator allocator,
    1162  uint32_t memoryTypeBits,
    1163  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    1164  uint32_t* pMemoryTypeIndex);
    1165 
    1167 typedef enum VmaPoolCreateFlagBits {
    1185  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
    1186 
    1187  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
    1188 } VmaPoolCreateFlagBits;
    1189 typedef VkFlags VmaPoolCreateFlags;
    1190 
    1193 typedef struct VmaPoolCreateInfo {
    1196  uint32_t memoryTypeIndex;
    1199  VmaPoolCreateFlags flags;
    1204  VkDeviceSize blockSize;
    1209  size_t minBlockCount;
    1217  size_t maxBlockCount;
    1231  uint32_t frameInUseCount;
    1232 } VmaPoolCreateInfo;
    1233 
    1236 typedef struct VmaPoolStats {
    1239  VkDeviceSize size;
    1242  VkDeviceSize unusedSize;
    1245  size_t allocationCount;
    1248  size_t unusedRangeCount;
    1255  VkDeviceSize unusedRangeSizeMax;
    1256 } VmaPoolStats;
    1257 
    1264 VkResult vmaCreatePool(
    1265  VmaAllocator allocator,
    1266  const VmaPoolCreateInfo* pCreateInfo,
    1267  VmaPool* pPool);
    1268 
    1271 void vmaDestroyPool(
    1272  VmaAllocator allocator,
    1273  VmaPool pool);
    1274 
    1281 void vmaGetPoolStats(
    1282  VmaAllocator allocator,
    1283  VmaPool pool,
    1284  VmaPoolStats* pPoolStats);
    1285 
    1292 void vmaMakePoolAllocationsLost(
    1293  VmaAllocator allocator,
    1294  VmaPool pool,
    1295  size_t* pLostAllocationCount);
    1296 
    1297 VK_DEFINE_HANDLE(VmaAllocation)
    1298 
    1299 
    1301 typedef struct VmaAllocationInfo {
    1306  uint32_t memoryType;
    1315  VkDeviceMemory deviceMemory;
    1320  VkDeviceSize offset;
    1325  VkDeviceSize size;
    1334  void* pMappedData;
    1339  void* pUserData;
    1340 } VmaAllocationInfo;
    1341 
    1352 VkResult vmaAllocateMemory(
    1353  VmaAllocator allocator,
    1354  const VkMemoryRequirements* pVkMemoryRequirements,
    1355  const VmaAllocationCreateInfo* pCreateInfo,
    1356  VmaAllocation* pAllocation,
    1357  VmaAllocationInfo* pAllocationInfo);
    1358 
    1365 VkResult vmaAllocateMemoryForBuffer(
    1366  VmaAllocator allocator,
    1367  VkBuffer buffer,
    1368  const VmaAllocationCreateInfo* pCreateInfo,
    1369  VmaAllocation* pAllocation,
    1370  VmaAllocationInfo* pAllocationInfo);
    1371 
    1373 VkResult vmaAllocateMemoryForImage(
    1374  VmaAllocator allocator,
    1375  VkImage image,
    1376  const VmaAllocationCreateInfo* pCreateInfo,
    1377  VmaAllocation* pAllocation,
    1378  VmaAllocationInfo* pAllocationInfo);
    1379 
    1381 void vmaFreeMemory(
    1382  VmaAllocator allocator,
    1383  VmaAllocation allocation);
    1384 
    1386 void vmaGetAllocationInfo(
    1387  VmaAllocator allocator,
    1388  VmaAllocation allocation,
    1389  VmaAllocationInfo* pAllocationInfo);
    1390 
    1404 void vmaSetAllocationUserData(
    1405  VmaAllocator allocator,
    1406  VmaAllocation allocation,
    1407  void* pUserData);
    1408 
    1419 void vmaCreateLostAllocation(
    1420  VmaAllocator allocator,
    1421  VmaAllocation* pAllocation);
    1422 
    1457 VkResult vmaMapMemory(
    1458  VmaAllocator allocator,
    1459  VmaAllocation allocation,
    1460  void** ppData);
    1461 
    1466 void vmaUnmapMemory(
    1467  VmaAllocator allocator,
    1468  VmaAllocation allocation);
    1469 
    1471 typedef struct VmaDefragmentationInfo {
    1476  VkDeviceSize maxBytesToMove;
    1481  uint32_t maxAllocationsToMove;
    1482 } VmaDefragmentationInfo;
    1483 
    1485 typedef struct VmaDefragmentationStats {
    1487  VkDeviceSize bytesMoved;
    1489  VkDeviceSize bytesFreed;
    1491  uint32_t allocationsMoved;
    1493  uint32_t deviceMemoryBlocksFreed;
    1494 } VmaDefragmentationStats;
    1495 
    1572 VkResult vmaDefragment(
    1573  VmaAllocator allocator,
    1574  VmaAllocation* pAllocations,
    1575  size_t allocationCount,
    1576  VkBool32* pAllocationsChanged,
    1577  const VmaDefragmentationInfo *pDefragmentationInfo,
    1578  VmaDefragmentationStats* pDefragmentationStats);
    1579 
    1606 VkResult vmaCreateBuffer(
    1607  VmaAllocator allocator,
    1608  const VkBufferCreateInfo* pBufferCreateInfo,
    1609  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    1610  VkBuffer* pBuffer,
    1611  VmaAllocation* pAllocation,
    1612  VmaAllocationInfo* pAllocationInfo);
    1613 
    1625 void vmaDestroyBuffer(
    1626  VmaAllocator allocator,
    1627  VkBuffer buffer,
    1628  VmaAllocation allocation);
    1629 
    1631 VkResult vmaCreateImage(
    1632  VmaAllocator allocator,
    1633  const VkImageCreateInfo* pImageCreateInfo,
    1634  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    1635  VkImage* pImage,
    1636  VmaAllocation* pAllocation,
    1637  VmaAllocationInfo* pAllocationInfo);
    1638 
    1650 void vmaDestroyImage(
    1651  VmaAllocator allocator,
    1652  VkImage image,
    1653  VmaAllocation allocation);
    1654 
    1655 #ifdef __cplusplus
    1656 }
    1657 #endif
    1658 
    1659 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
    1660 
    1661 // For Visual Studio IntelliSense.
    1662 #ifdef __INTELLISENSE__
    1663 #define VMA_IMPLEMENTATION
    1664 #endif
    1665 
    1666 #ifdef VMA_IMPLEMENTATION
    1667 #undef VMA_IMPLEMENTATION
    1668 
    1669 #include <cstdint>
    1670 #include <cstdlib>
    1671 #include <cstring>
    1672 
    1673 /*******************************************************************************
    1674 CONFIGURATION SECTION
    1675 
    1676 Define some of these macros before each #include of this header or change them
    1677 here if you need other then default behavior depending on your environment.
    1678 */
    1679 
    1680 /*
    1681 Define this macro to 1 to make the library fetch pointers to Vulkan functions
    1682 internally, like:
    1683 
    1684  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
    1685 
    1686 Define to 0 if you are going to provide you own pointers to Vulkan functions via
    1687 VmaAllocatorCreateInfo::pVulkanFunctions.
    1688 */
    1689 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
    1690 #define VMA_STATIC_VULKAN_FUNCTIONS 1
    1691 #endif
    1692 
    1693 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
    1694 //#define VMA_USE_STL_CONTAINERS 1
    1695 
    1696 /* Set this macro to 1 to make the library including and using STL containers:
    1697 std::pair, std::vector, std::list, std::unordered_map.
    1698 
    1699 Set it to 0 or undefined to make the library using its own implementation of
    1700 the containers.
    1701 */
    1702 #if VMA_USE_STL_CONTAINERS
    1703  #define VMA_USE_STL_VECTOR 1
    1704  #define VMA_USE_STL_UNORDERED_MAP 1
    1705  #define VMA_USE_STL_LIST 1
    1706 #endif
    1707 
    1708 #if VMA_USE_STL_VECTOR
    1709  #include <vector>
    1710 #endif
    1711 
    1712 #if VMA_USE_STL_UNORDERED_MAP
    1713  #include <unordered_map>
    1714 #endif
    1715 
    1716 #if VMA_USE_STL_LIST
    1717  #include <list>
    1718 #endif
    1719 
    1720 /*
    1721 Following headers are used in this CONFIGURATION section only, so feel free to
    1722 remove them if not needed.
    1723 */
    1724 #include <cassert> // for assert
    1725 #include <algorithm> // for min, max
    1726 #include <mutex> // for std::mutex
    1727 #include <atomic> // for std::atomic
    1728 
    1729 #if !defined(_WIN32)
    1730  #include <malloc.h> // for aligned_alloc()
    1731 #endif
    1732 
    1733 // Normal assert to check for programmer's errors, especially in Debug configuration.
    1734 #ifndef VMA_ASSERT
    1735  #ifdef _DEBUG
    1736  #define VMA_ASSERT(expr) assert(expr)
    1737  #else
    1738  #define VMA_ASSERT(expr)
    1739  #endif
    1740 #endif
    1741 
    1742 // Assert that will be called very often, like inside data structures e.g. operator[].
    1743 // Making it non-empty can make program slow.
    1744 #ifndef VMA_HEAVY_ASSERT
    1745  #ifdef _DEBUG
    1746  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
    1747  #else
    1748  #define VMA_HEAVY_ASSERT(expr)
    1749  #endif
    1750 #endif
    1751 
    1752 #ifndef VMA_NULL
    1753  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
    1754  #define VMA_NULL nullptr
    1755 #endif
    1756 
    1757 #ifndef VMA_ALIGN_OF
    1758  #define VMA_ALIGN_OF(type) (__alignof(type))
    1759 #endif
    1760 
    1761 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
    1762  #if defined(_WIN32)
    1763  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
    1764  #else
    1765  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
    1766  #endif
    1767 #endif
    1768 
    1769 #ifndef VMA_SYSTEM_FREE
    1770  #if defined(_WIN32)
    1771  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
    1772  #else
    1773  #define VMA_SYSTEM_FREE(ptr) free(ptr)
    1774  #endif
    1775 #endif
    1776 
    1777 #ifndef VMA_MIN
    1778  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
    1779 #endif
    1780 
    1781 #ifndef VMA_MAX
    1782  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
    1783 #endif
    1784 
    1785 #ifndef VMA_SWAP
    1786  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
    1787 #endif
    1788 
    1789 #ifndef VMA_SORT
    1790  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
    1791 #endif
    1792 
    1793 #ifndef VMA_DEBUG_LOG
    1794  #define VMA_DEBUG_LOG(format, ...)
    1795  /*
    1796  #define VMA_DEBUG_LOG(format, ...) do { \
    1797  printf(format, __VA_ARGS__); \
    1798  printf("\n"); \
    1799  } while(false)
    1800  */
    1801 #endif
    1802 
    1803 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
    1804 #if VMA_STATS_STRING_ENABLED
    1805  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
    1806  {
    1807  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
    1808  }
    1809  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
    1810  {
    1811  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
    1812  }
    1813  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
    1814  {
    1815  snprintf(outStr, strLen, "%p", ptr);
    1816  }
    1817 #endif
    1818 
    1819 #ifndef VMA_MUTEX
    1820  class VmaMutex
    1821  {
    1822  public:
    1823  VmaMutex() { }
    1824  ~VmaMutex() { }
    1825  void Lock() { m_Mutex.lock(); }
    1826  void Unlock() { m_Mutex.unlock(); }
    1827  private:
    1828  std::mutex m_Mutex;
    1829  };
    1830  #define VMA_MUTEX VmaMutex
    1831 #endif
    1832 
    1833 /*
    1834 If providing your own implementation, you need to implement a subset of std::atomic:
    1835 
    1836 - Constructor(uint32_t desired)
    1837 - uint32_t load() const
    1838 - void store(uint32_t desired)
    1839 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
    1840 */
    1841 #ifndef VMA_ATOMIC_UINT32
    1842  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
    1843 #endif
    1844 
    1845 #ifndef VMA_BEST_FIT
    1846 
    1858  #define VMA_BEST_FIT (1)
    1859 #endif
    1860 
    1861 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
    1862 
    1866  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
    1867 #endif
    1868 
    1869 #ifndef VMA_DEBUG_ALIGNMENT
    1870 
    1874  #define VMA_DEBUG_ALIGNMENT (1)
    1875 #endif
    1876 
    1877 #ifndef VMA_DEBUG_MARGIN
    1878 
    1882  #define VMA_DEBUG_MARGIN (0)
    1883 #endif
    1884 
    1885 #ifndef VMA_DEBUG_GLOBAL_MUTEX
    1886 
    1890  #define VMA_DEBUG_GLOBAL_MUTEX (0)
    1891 #endif
    1892 
    1893 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
    1894 
    1898  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
    1899 #endif
    1900 
    1901 #ifndef VMA_SMALL_HEAP_MAX_SIZE
    1902  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
    1904 #endif
    1905 
    1906 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
    1907  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
    1909 #endif
    1910 
    1911 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
    1912 
    1913 /*******************************************************************************
    1914 END OF CONFIGURATION
    1915 */
    1916 
    1917 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
    1918  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
    1919 
    1920 // Returns number of bits set to 1 in (v).
    1921 static inline uint32_t VmaCountBitsSet(uint32_t v)
    1922 {
    1923  uint32_t c = v - ((v >> 1) & 0x55555555);
    1924  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
    1925  c = ((c >> 4) + c) & 0x0F0F0F0F;
    1926  c = ((c >> 8) + c) & 0x00FF00FF;
    1927  c = ((c >> 16) + c) & 0x0000FFFF;
    1928  return c;
    1929 }
    1930 
    1931 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
    1932 // Use types like uint32_t, uint64_t as T.
    1933 template <typename T>
    1934 static inline T VmaAlignUp(T val, T align)
    1935 {
    1936  return (val + align - 1) / align * align;
    1937 }
    1938 
    1939 // Division with mathematical rounding to nearest number.
    1940 template <typename T>
    1941 inline T VmaRoundDiv(T x, T y)
    1942 {
    1943  return (x + (y / (T)2)) / y;
    1944 }
    1945 
    1946 #ifndef VMA_SORT
    1947 
    1948 template<typename Iterator, typename Compare>
    1949 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
    1950 {
    1951  Iterator centerValue = end; --centerValue;
    1952  Iterator insertIndex = beg;
    1953  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
    1954  {
    1955  if(cmp(*memTypeIndex, *centerValue))
    1956  {
    1957  if(insertIndex != memTypeIndex)
    1958  {
    1959  VMA_SWAP(*memTypeIndex, *insertIndex);
    1960  }
    1961  ++insertIndex;
    1962  }
    1963  }
    1964  if(insertIndex != centerValue)
    1965  {
    1966  VMA_SWAP(*insertIndex, *centerValue);
    1967  }
    1968  return insertIndex;
    1969 }
    1970 
    1971 template<typename Iterator, typename Compare>
    1972 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
    1973 {
    1974  if(beg < end)
    1975  {
    1976  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
    1977  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
    1978  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
    1979  }
    1980 }
    1981 
    1982 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
    1983 
    1984 #endif // #ifndef VMA_SORT
    1985 
    1986 /*
    1987 Returns true if two memory blocks occupy overlapping pages.
    1988 ResourceA must be in less memory offset than ResourceB.
    1989 
    1990 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
    1991 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
    1992 */
    1993 static inline bool VmaBlocksOnSamePage(
    1994  VkDeviceSize resourceAOffset,
    1995  VkDeviceSize resourceASize,
    1996  VkDeviceSize resourceBOffset,
    1997  VkDeviceSize pageSize)
    1998 {
    1999  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
    2000  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
    2001  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
    2002  VkDeviceSize resourceBStart = resourceBOffset;
    2003  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
    2004  return resourceAEndPage == resourceBStartPage;
    2005 }
    2006 
    2007 enum VmaSuballocationType
    2008 {
    2009  VMA_SUBALLOCATION_TYPE_FREE = 0,
    2010  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
    2011  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
    2012  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
    2013  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
    2014  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
    2015  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
    2016 };
    2017 
    2018 /*
    2019 Returns true if given suballocation types could conflict and must respect
    2020 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
    2021 or linear image and another one is optimal image. If type is unknown, behave
    2022 conservatively.
    2023 */
    2024 static inline bool VmaIsBufferImageGranularityConflict(
    2025  VmaSuballocationType suballocType1,
    2026  VmaSuballocationType suballocType2)
    2027 {
    2028  if(suballocType1 > suballocType2)
    2029  {
    2030  VMA_SWAP(suballocType1, suballocType2);
    2031  }
    2032 
    2033  switch(suballocType1)
    2034  {
    2035  case VMA_SUBALLOCATION_TYPE_FREE:
    2036  return false;
    2037  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
    2038  return true;
    2039  case VMA_SUBALLOCATION_TYPE_BUFFER:
    2040  return
    2041  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
    2042  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    2043  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
    2044  return
    2045  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
    2046  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
    2047  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    2048  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
    2049  return
    2050  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
    2051  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
    2052  return false;
    2053  default:
    2054  VMA_ASSERT(0);
    2055  return true;
    2056  }
    2057 }
    2058 
    2059 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
    2060 struct VmaMutexLock
    2061 {
    2062 public:
    2063  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
    2064  m_pMutex(useMutex ? &mutex : VMA_NULL)
    2065  {
    2066  if(m_pMutex)
    2067  {
    2068  m_pMutex->Lock();
    2069  }
    2070  }
    2071 
    2072  ~VmaMutexLock()
    2073  {
    2074  if(m_pMutex)
    2075  {
    2076  m_pMutex->Unlock();
    2077  }
    2078  }
    2079 
    2080 private:
    2081  VMA_MUTEX* m_pMutex;
    2082 };
    2083 
    2084 #if VMA_DEBUG_GLOBAL_MUTEX
    2085  static VMA_MUTEX gDebugGlobalMutex;
    2086  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
    2087 #else
    2088  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
    2089 #endif
    2090 
    2091 // Minimum size of a free suballocation to register it in the free suballocation collection.
    2092 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
    2093 
    2094 /*
    2095 Performs binary search and returns iterator to first element that is greater or
    2096 equal to (key), according to comparison (cmp).
    2097 
    2098 Cmp should return true if first argument is less than second argument.
    2099 
    2100 Returned value is the found element, if present in the collection or place where
    2101 new element with value (key) should be inserted.
    2102 */
    2103 template <typename IterT, typename KeyT, typename CmpT>
    2104 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)
    2105 {
    2106  size_t down = 0, up = (end - beg);
    2107  while(down < up)
    2108  {
    2109  const size_t mid = (down + up) / 2;
    2110  if(cmp(*(beg+mid), key))
    2111  {
    2112  down = mid + 1;
    2113  }
    2114  else
    2115  {
    2116  up = mid;
    2117  }
    2118  }
    2119  return beg + down;
    2120 }
    2121 
    2123 // Memory allocation
    2124 
    2125 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
    2126 {
    2127  if((pAllocationCallbacks != VMA_NULL) &&
    2128  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
    2129  {
    2130  return (*pAllocationCallbacks->pfnAllocation)(
    2131  pAllocationCallbacks->pUserData,
    2132  size,
    2133  alignment,
    2134  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    2135  }
    2136  else
    2137  {
    2138  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
    2139  }
    2140 }
    2141 
    2142 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
    2143 {
    2144  if((pAllocationCallbacks != VMA_NULL) &&
    2145  (pAllocationCallbacks->pfnFree != VMA_NULL))
    2146  {
    2147  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
    2148  }
    2149  else
    2150  {
    2151  VMA_SYSTEM_FREE(ptr);
    2152  }
    2153 }
    2154 
    2155 template<typename T>
    2156 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
    2157 {
    2158  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
    2159 }
    2160 
    2161 template<typename T>
    2162 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
    2163 {
    2164  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
    2165 }
    2166 
    2167 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
    2168 
    2169 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
    2170 
    2171 template<typename T>
    2172 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
    2173 {
    2174  ptr->~T();
    2175  VmaFree(pAllocationCallbacks, ptr);
    2176 }
    2177 
    2178 template<typename T>
    2179 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
    2180 {
    2181  if(ptr != VMA_NULL)
    2182  {
    2183  for(size_t i = count; i--; )
    2184  {
    2185  ptr[i].~T();
    2186  }
    2187  VmaFree(pAllocationCallbacks, ptr);
    2188  }
    2189 }
    2190 
    2191 // STL-compatible allocator.
    2192 template<typename T>
    2193 class VmaStlAllocator
    2194 {
    2195 public:
    2196  const VkAllocationCallbacks* const m_pCallbacks;
    2197  typedef T value_type;
    2198 
    2199  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
    2200  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
    2201 
    2202  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
    2203  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
    2204 
    2205  template<typename U>
    2206  bool operator==(const VmaStlAllocator<U>& rhs) const
    2207  {
    2208  return m_pCallbacks == rhs.m_pCallbacks;
    2209  }
    2210  template<typename U>
    2211  bool operator!=(const VmaStlAllocator<U>& rhs) const
    2212  {
    2213  return m_pCallbacks != rhs.m_pCallbacks;
    2214  }
    2215 
    2216  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
    2217 };
    2218 
    2219 #if VMA_USE_STL_VECTOR
    2220 
    2221 #define VmaVector std::vector
    2222 
    2223 template<typename T, typename allocatorT>
    2224 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
    2225 {
    2226  vec.insert(vec.begin() + index, item);
    2227 }
    2228 
    2229 template<typename T, typename allocatorT>
    2230 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
    2231 {
    2232  vec.erase(vec.begin() + index);
    2233 }
    2234 
    2235 #else // #if VMA_USE_STL_VECTOR
    2236 
    2237 /* Class with interface compatible with subset of std::vector.
    2238 T must be POD because constructors and destructors are not called and memcpy is
    2239 used for these objects. */
    2240 template<typename T, typename AllocatorT>
    2241 class VmaVector
    2242 {
    2243 public:
    2244  typedef T value_type;
    2245 
    2246  VmaVector(const AllocatorT& allocator) :
    2247  m_Allocator(allocator),
    2248  m_pArray(VMA_NULL),
    2249  m_Count(0),
    2250  m_Capacity(0)
    2251  {
    2252  }
    2253 
    2254  VmaVector(size_t count, const AllocatorT& allocator) :
    2255  m_Allocator(allocator),
    2256  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
    2257  m_Count(count),
    2258  m_Capacity(count)
    2259  {
    2260  }
    2261 
    2262  VmaVector(const VmaVector<T, AllocatorT>& src) :
    2263  m_Allocator(src.m_Allocator),
    2264  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
    2265  m_Count(src.m_Count),
    2266  m_Capacity(src.m_Count)
    2267  {
    2268  if(m_Count != 0)
    2269  {
    2270  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
    2271  }
    2272  }
    2273 
    2274  ~VmaVector()
    2275  {
    2276  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
    2277  }
    2278 
    2279  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
    2280  {
    2281  if(&rhs != this)
    2282  {
    2283  resize(rhs.m_Count);
    2284  if(m_Count != 0)
    2285  {
    2286  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
    2287  }
    2288  }
    2289  return *this;
    2290  }
    2291 
    2292  bool empty() const { return m_Count == 0; }
    2293  size_t size() const { return m_Count; }
    2294  T* data() { return m_pArray; }
    2295  const T* data() const { return m_pArray; }
    2296 
    2297  T& operator[](size_t index)
    2298  {
    2299  VMA_HEAVY_ASSERT(index < m_Count);
    2300  return m_pArray[index];
    2301  }
    2302  const T& operator[](size_t index) const
    2303  {
    2304  VMA_HEAVY_ASSERT(index < m_Count);
    2305  return m_pArray[index];
    2306  }
    2307 
    2308  T& front()
    2309  {
    2310  VMA_HEAVY_ASSERT(m_Count > 0);
    2311  return m_pArray[0];
    2312  }
    2313  const T& front() const
    2314  {
    2315  VMA_HEAVY_ASSERT(m_Count > 0);
    2316  return m_pArray[0];
    2317  }
    2318  T& back()
    2319  {
    2320  VMA_HEAVY_ASSERT(m_Count > 0);
    2321  return m_pArray[m_Count - 1];
    2322  }
    2323  const T& back() const
    2324  {
    2325  VMA_HEAVY_ASSERT(m_Count > 0);
    2326  return m_pArray[m_Count - 1];
    2327  }
    2328 
    2329  void reserve(size_t newCapacity, bool freeMemory = false)
    2330  {
    2331  newCapacity = VMA_MAX(newCapacity, m_Count);
    2332 
    2333  if((newCapacity < m_Capacity) && !freeMemory)
    2334  {
    2335  newCapacity = m_Capacity;
    2336  }
    2337 
    2338  if(newCapacity != m_Capacity)
    2339  {
    2340  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
    2341  if(m_Count != 0)
    2342  {
    2343  memcpy(newArray, m_pArray, m_Count * sizeof(T));
    2344  }
    2345  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
    2346  m_Capacity = newCapacity;
    2347  m_pArray = newArray;
    2348  }
    2349  }
    2350 
    2351  void resize(size_t newCount, bool freeMemory = false)
    2352  {
    2353  size_t newCapacity = m_Capacity;
    2354  if(newCount > m_Capacity)
    2355  {
    2356  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
    2357  }
    2358  else if(freeMemory)
    2359  {
    2360  newCapacity = newCount;
    2361  }
    2362 
    2363  if(newCapacity != m_Capacity)
    2364  {
    2365  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
    2366  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
    2367  if(elementsToCopy != 0)
    2368  {
    2369  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
    2370  }
    2371  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
    2372  m_Capacity = newCapacity;
    2373  m_pArray = newArray;
    2374  }
    2375 
    2376  m_Count = newCount;
    2377  }
    2378 
    2379  void clear(bool freeMemory = false)
    2380  {
    2381  resize(0, freeMemory);
    2382  }
    2383 
    2384  void insert(size_t index, const T& src)
    2385  {
    2386  VMA_HEAVY_ASSERT(index <= m_Count);
    2387  const size_t oldCount = size();
    2388  resize(oldCount + 1);
    2389  if(index < oldCount)
    2390  {
    2391  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
    2392  }
    2393  m_pArray[index] = src;
    2394  }
    2395 
    2396  void remove(size_t index)
    2397  {
    2398  VMA_HEAVY_ASSERT(index < m_Count);
    2399  const size_t oldCount = size();
    2400  if(index < oldCount - 1)
    2401  {
    2402  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
    2403  }
    2404  resize(oldCount - 1);
    2405  }
    2406 
    2407  void push_back(const T& src)
    2408  {
    2409  const size_t newIndex = size();
    2410  resize(newIndex + 1);
    2411  m_pArray[newIndex] = src;
    2412  }
    2413 
    2414  void pop_back()
    2415  {
    2416  VMA_HEAVY_ASSERT(m_Count > 0);
    2417  resize(size() - 1);
    2418  }
    2419 
    2420  void push_front(const T& src)
    2421  {
    2422  insert(0, src);
    2423  }
    2424 
    2425  void pop_front()
    2426  {
    2427  VMA_HEAVY_ASSERT(m_Count > 0);
    2428  remove(0);
    2429  }
    2430 
    2431  typedef T* iterator;
    2432 
    2433  iterator begin() { return m_pArray; }
    2434  iterator end() { return m_pArray + m_Count; }
    2435 
    2436 private:
    2437  AllocatorT m_Allocator;
    2438  T* m_pArray;
    2439  size_t m_Count;
    2440  size_t m_Capacity;
    2441 };
    2442 
    2443 template<typename T, typename allocatorT>
    2444 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
    2445 {
    2446  vec.insert(index, item);
    2447 }
    2448 
    2449 template<typename T, typename allocatorT>
    2450 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
    2451 {
    2452  vec.remove(index);
    2453 }
    2454 
    2455 #endif // #if VMA_USE_STL_VECTOR
    2456 
    2457 template<typename CmpLess, typename VectorT>
    2458 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
    2459 {
    2460  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
    2461  vector.data(),
    2462  vector.data() + vector.size(),
    2463  value,
    2464  CmpLess()) - vector.data();
    2465  VmaVectorInsert(vector, indexToInsert, value);
    2466  return indexToInsert;
    2467 }
    2468 
    2469 template<typename CmpLess, typename VectorT>
    2470 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
    2471 {
    2472  CmpLess comparator;
    2473  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
    2474  vector.begin(),
    2475  vector.end(),
    2476  value,
    2477  comparator);
    2478  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
    2479  {
    2480  size_t indexToRemove = it - vector.begin();
    2481  VmaVectorRemove(vector, indexToRemove);
    2482  return true;
    2483  }
    2484  return false;
    2485 }
    2486 
    2487 template<typename CmpLess, typename VectorT>
    2488 size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)
    2489 {
    2490  CmpLess comparator;
    2491  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
    2492  vector.data(),
    2493  vector.data() + vector.size(),
    2494  value,
    2495  comparator);
    2496  if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))
    2497  {
    2498  return it - vector.begin();
    2499  }
    2500  else
    2501  {
    2502  return vector.size();
    2503  }
    2504 }
    2505 
    2507 // class VmaPoolAllocator
    2508 
    2509 /*
    2510 Allocator for objects of type T using a list of arrays (pools) to speed up
    2511 allocation. Number of elements that can be allocated is not bounded because
    2512 allocator can create multiple blocks.
    2513 */
    2514 template<typename T>
    2515 class VmaPoolAllocator
    2516 {
    2517 public:
    2518  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
    2519  ~VmaPoolAllocator();
    2520  void Clear();
    2521  T* Alloc();
    2522  void Free(T* ptr);
    2523 
    2524 private:
    2525  union Item
    2526  {
    2527  uint32_t NextFreeIndex;
    2528  T Value;
    2529  };
    2530 
    2531  struct ItemBlock
    2532  {
    2533  Item* pItems;
    2534  uint32_t FirstFreeIndex;
    2535  };
    2536 
    2537  const VkAllocationCallbacks* m_pAllocationCallbacks;
    2538  size_t m_ItemsPerBlock;
    2539  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
    2540 
    2541  ItemBlock& CreateNewBlock();
    2542 };
    2543 
    2544 template<typename T>
    2545 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
    2546  m_pAllocationCallbacks(pAllocationCallbacks),
    2547  m_ItemsPerBlock(itemsPerBlock),
    2548  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
    2549 {
    2550  VMA_ASSERT(itemsPerBlock > 0);
    2551 }
    2552 
    2553 template<typename T>
    2554 VmaPoolAllocator<T>::~VmaPoolAllocator()
    2555 {
    2556  Clear();
    2557 }
    2558 
    2559 template<typename T>
    2560 void VmaPoolAllocator<T>::Clear()
    2561 {
    2562  for(size_t i = m_ItemBlocks.size(); i--; )
    2563  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
    2564  m_ItemBlocks.clear();
    2565 }
    2566 
    2567 template<typename T>
    2568 T* VmaPoolAllocator<T>::Alloc()
    2569 {
    2570  for(size_t i = m_ItemBlocks.size(); i--; )
    2571  {
    2572  ItemBlock& block = m_ItemBlocks[i];
    2573  // This block has some free items: Use first one.
    2574  if(block.FirstFreeIndex != UINT32_MAX)
    2575  {
    2576  Item* const pItem = &block.pItems[block.FirstFreeIndex];
    2577  block.FirstFreeIndex = pItem->NextFreeIndex;
    2578  return &pItem->Value;
    2579  }
    2580  }
    2581 
    2582  // No block has free item: Create new one and use it.
    2583  ItemBlock& newBlock = CreateNewBlock();
    2584  Item* const pItem = &newBlock.pItems[0];
    2585  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
    2586  return &pItem->Value;
    2587 }
    2588 
    2589 template<typename T>
    2590 void VmaPoolAllocator<T>::Free(T* ptr)
    2591 {
    2592  // Search all memory blocks to find ptr.
    2593  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
    2594  {
    2595  ItemBlock& block = m_ItemBlocks[i];
    2596 
    2597  // Casting to union.
    2598  Item* pItemPtr;
    2599  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
    2600 
    2601  // Check if pItemPtr is in address range of this block.
    2602  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
    2603  {
    2604  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
    2605  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
    2606  block.FirstFreeIndex = index;
    2607  return;
    2608  }
    2609  }
    2610  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
    2611 }
    2612 
    2613 template<typename T>
    2614 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
    2615 {
    2616  ItemBlock newBlock = {
    2617  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
    2618 
    2619  m_ItemBlocks.push_back(newBlock);
    2620 
    2621  // Setup singly-linked list of all free items in this block.
    2622  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
    2623  newBlock.pItems[i].NextFreeIndex = i + 1;
    2624  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
    2625  return m_ItemBlocks.back();
    2626 }
    2627 
    2629 // class VmaRawList, VmaList
    2630 
    2631 #if VMA_USE_STL_LIST
    2632 
    2633 #define VmaList std::list
    2634 
    2635 #else // #if VMA_USE_STL_LIST
    2636 
    2637 template<typename T>
    2638 struct VmaListItem
    2639 {
    2640  VmaListItem* pPrev;
    2641  VmaListItem* pNext;
    2642  T Value;
    2643 };
    2644 
    2645 // Doubly linked list.
    2646 template<typename T>
    2647 class VmaRawList
    2648 {
    2649 public:
    2650  typedef VmaListItem<T> ItemType;
    2651 
    2652  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
    2653  ~VmaRawList();
    2654  void Clear();
    2655 
    2656  size_t GetCount() const { return m_Count; }
    2657  bool IsEmpty() const { return m_Count == 0; }
    2658 
    2659  ItemType* Front() { return m_pFront; }
    2660  const ItemType* Front() const { return m_pFront; }
    2661  ItemType* Back() { return m_pBack; }
    2662  const ItemType* Back() const { return m_pBack; }
    2663 
    2664  ItemType* PushBack();
    2665  ItemType* PushFront();
    2666  ItemType* PushBack(const T& value);
    2667  ItemType* PushFront(const T& value);
    2668  void PopBack();
    2669  void PopFront();
    2670 
    2671  // Item can be null - it means PushBack.
    2672  ItemType* InsertBefore(ItemType* pItem);
    2673  // Item can be null - it means PushFront.
    2674  ItemType* InsertAfter(ItemType* pItem);
    2675 
    2676  ItemType* InsertBefore(ItemType* pItem, const T& value);
    2677  ItemType* InsertAfter(ItemType* pItem, const T& value);
    2678 
    2679  void Remove(ItemType* pItem);
    2680 
    2681 private:
    2682  const VkAllocationCallbacks* const m_pAllocationCallbacks;
    2683  VmaPoolAllocator<ItemType> m_ItemAllocator;
    2684  ItemType* m_pFront;
    2685  ItemType* m_pBack;
    2686  size_t m_Count;
    2687 
    2688  // Declared not defined, to block copy constructor and assignment operator.
    2689  VmaRawList(const VmaRawList<T>& src);
    2690  VmaRawList<T>& operator=(const VmaRawList<T>& rhs);
    2691 };
    2692 
    2693 template<typename T>
    2694 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
    2695  m_pAllocationCallbacks(pAllocationCallbacks),
    2696  m_ItemAllocator(pAllocationCallbacks, 128),
    2697  m_pFront(VMA_NULL),
    2698  m_pBack(VMA_NULL),
    2699  m_Count(0)
    2700 {
    2701 }
    2702 
    2703 template<typename T>
    2704 VmaRawList<T>::~VmaRawList()
    2705 {
    2706  // Intentionally not calling Clear, because that would be unnecessary
    2707  // computations to return all items to m_ItemAllocator as free.
    2708 }
    2709 
    2710 template<typename T>
    2711 void VmaRawList<T>::Clear()
    2712 {
    2713  if(IsEmpty() == false)
    2714  {
    2715  ItemType* pItem = m_pBack;
    2716  while(pItem != VMA_NULL)
    2717  {
    2718  ItemType* const pPrevItem = pItem->pPrev;
    2719  m_ItemAllocator.Free(pItem);
    2720  pItem = pPrevItem;
    2721  }
    2722  m_pFront = VMA_NULL;
    2723  m_pBack = VMA_NULL;
    2724  m_Count = 0;
    2725  }
    2726 }
    2727 
    2728 template<typename T>
    2729 VmaListItem<T>* VmaRawList<T>::PushBack()
    2730 {
    2731  ItemType* const pNewItem = m_ItemAllocator.Alloc();
    2732  pNewItem->pNext = VMA_NULL;
    2733  if(IsEmpty())
    2734  {
    2735  pNewItem->pPrev = VMA_NULL;
    2736  m_pFront = pNewItem;
    2737  m_pBack = pNewItem;
    2738  m_Count = 1;
    2739  }
    2740  else
    2741  {
    2742  pNewItem->pPrev = m_pBack;
    2743  m_pBack->pNext = pNewItem;
    2744  m_pBack = pNewItem;
    2745  ++m_Count;
    2746  }
    2747  return pNewItem;
    2748 }
    2749 
    2750 template<typename T>
    2751 VmaListItem<T>* VmaRawList<T>::PushFront()
    2752 {
    2753  ItemType* const pNewItem = m_ItemAllocator.Alloc();
    2754  pNewItem->pPrev = VMA_NULL;
    2755  if(IsEmpty())
    2756  {
    2757  pNewItem->pNext = VMA_NULL;
    2758  m_pFront = pNewItem;
    2759  m_pBack = pNewItem;
    2760  m_Count = 1;
    2761  }
    2762  else
    2763  {
    2764  pNewItem->pNext = m_pFront;
    2765  m_pFront->pPrev = pNewItem;
    2766  m_pFront = pNewItem;
    2767  ++m_Count;
    2768  }
    2769  return pNewItem;
    2770 }
    2771 
    2772 template<typename T>
    2773 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
    2774 {
    2775  ItemType* const pNewItem = PushBack();
    2776  pNewItem->Value = value;
    2777  return pNewItem;
    2778 }
    2779 
    2780 template<typename T>
    2781 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
    2782 {
    2783  ItemType* const pNewItem = PushFront();
    2784  pNewItem->Value = value;
    2785  return pNewItem;
    2786 }
    2787 
    2788 template<typename T>
    2789 void VmaRawList<T>::PopBack()
    2790 {
    2791  VMA_HEAVY_ASSERT(m_Count > 0);
    2792  ItemType* const pBackItem = m_pBack;
    2793  ItemType* const pPrevItem = pBackItem->pPrev;
    2794  if(pPrevItem != VMA_NULL)
    2795  {
    2796  pPrevItem->pNext = VMA_NULL;
    2797  }
    2798  m_pBack = pPrevItem;
    2799  m_ItemAllocator.Free(pBackItem);
    2800  --m_Count;
    2801 }
    2802 
    2803 template<typename T>
    2804 void VmaRawList<T>::PopFront()
    2805 {
    2806  VMA_HEAVY_ASSERT(m_Count > 0);
    2807  ItemType* const pFrontItem = m_pFront;
    2808  ItemType* const pNextItem = pFrontItem->pNext;
    2809  if(pNextItem != VMA_NULL)
    2810  {
    2811  pNextItem->pPrev = VMA_NULL;
    2812  }
    2813  m_pFront = pNextItem;
    2814  m_ItemAllocator.Free(pFrontItem);
    2815  --m_Count;
    2816 }
    2817 
    2818 template<typename T>
    2819 void VmaRawList<T>::Remove(ItemType* pItem)
    2820 {
    2821  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
    2822  VMA_HEAVY_ASSERT(m_Count > 0);
    2823 
    2824  if(pItem->pPrev != VMA_NULL)
    2825  {
    2826  pItem->pPrev->pNext = pItem->pNext;
    2827  }
    2828  else
    2829  {
    2830  VMA_HEAVY_ASSERT(m_pFront == pItem);
    2831  m_pFront = pItem->pNext;
    2832  }
    2833 
    2834  if(pItem->pNext != VMA_NULL)
    2835  {
    2836  pItem->pNext->pPrev = pItem->pPrev;
    2837  }
    2838  else
    2839  {
    2840  VMA_HEAVY_ASSERT(m_pBack == pItem);
    2841  m_pBack = pItem->pPrev;
    2842  }
    2843 
    2844  m_ItemAllocator.Free(pItem);
    2845  --m_Count;
    2846 }
    2847 
    2848 template<typename T>
    2849 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
    2850 {
    2851  if(pItem != VMA_NULL)
    2852  {
    2853  ItemType* const prevItem = pItem->pPrev;
    2854  ItemType* const newItem = m_ItemAllocator.Alloc();
    2855  newItem->pPrev = prevItem;
    2856  newItem->pNext = pItem;
    2857  pItem->pPrev = newItem;
    2858  if(prevItem != VMA_NULL)
    2859  {
    2860  prevItem->pNext = newItem;
    2861  }
    2862  else
    2863  {
    2864  VMA_HEAVY_ASSERT(m_pFront == pItem);
    2865  m_pFront = newItem;
    2866  }
    2867  ++m_Count;
    2868  return newItem;
    2869  }
    2870  else
    2871  return PushBack();
    2872 }
    2873 
    2874 template<typename T>
    2875 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
    2876 {
    2877  if(pItem != VMA_NULL)
    2878  {
    2879  ItemType* const nextItem = pItem->pNext;
    2880  ItemType* const newItem = m_ItemAllocator.Alloc();
    2881  newItem->pNext = nextItem;
    2882  newItem->pPrev = pItem;
    2883  pItem->pNext = newItem;
    2884  if(nextItem != VMA_NULL)
    2885  {
    2886  nextItem->pPrev = newItem;
    2887  }
    2888  else
    2889  {
    2890  VMA_HEAVY_ASSERT(m_pBack == pItem);
    2891  m_pBack = newItem;
    2892  }
    2893  ++m_Count;
    2894  return newItem;
    2895  }
    2896  else
    2897  return PushFront();
    2898 }
    2899 
    2900 template<typename T>
    2901 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
    2902 {
    2903  ItemType* const newItem = InsertBefore(pItem);
    2904  newItem->Value = value;
    2905  return newItem;
    2906 }
    2907 
    2908 template<typename T>
    2909 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
    2910 {
    2911  ItemType* const newItem = InsertAfter(pItem);
    2912  newItem->Value = value;
    2913  return newItem;
    2914 }
    2915 
    2916 template<typename T, typename AllocatorT>
    2917 class VmaList
    2918 {
    2919 public:
    2920  class iterator
    2921  {
    2922  public:
    2923  iterator() :
    2924  m_pList(VMA_NULL),
    2925  m_pItem(VMA_NULL)
    2926  {
    2927  }
    2928 
    2929  T& operator*() const
    2930  {
    2931  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2932  return m_pItem->Value;
    2933  }
    2934  T* operator->() const
    2935  {
    2936  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2937  return &m_pItem->Value;
    2938  }
    2939 
    2940  iterator& operator++()
    2941  {
    2942  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    2943  m_pItem = m_pItem->pNext;
    2944  return *this;
    2945  }
    2946  iterator& operator--()
    2947  {
    2948  if(m_pItem != VMA_NULL)
    2949  {
    2950  m_pItem = m_pItem->pPrev;
    2951  }
    2952  else
    2953  {
    2954  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
    2955  m_pItem = m_pList->Back();
    2956  }
    2957  return *this;
    2958  }
    2959 
    2960  iterator operator++(int)
    2961  {
    2962  iterator result = *this;
    2963  ++*this;
    2964  return result;
    2965  }
    2966  iterator operator--(int)
    2967  {
    2968  iterator result = *this;
    2969  --*this;
    2970  return result;
    2971  }
    2972 
    2973  bool operator==(const iterator& rhs) const
    2974  {
    2975  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    2976  return m_pItem == rhs.m_pItem;
    2977  }
    2978  bool operator!=(const iterator& rhs) const
    2979  {
    2980  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    2981  return m_pItem != rhs.m_pItem;
    2982  }
    2983 
    2984  private:
    2985  VmaRawList<T>* m_pList;
    2986  VmaListItem<T>* m_pItem;
    2987 
    2988  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
    2989  m_pList(pList),
    2990  m_pItem(pItem)
    2991  {
    2992  }
    2993 
    2994  friend class VmaList<T, AllocatorT>;
    2995  };
    2996 
    2997  class const_iterator
    2998  {
    2999  public:
    3000  const_iterator() :
    3001  m_pList(VMA_NULL),
    3002  m_pItem(VMA_NULL)
    3003  {
    3004  }
    3005 
    3006  const_iterator(const iterator& src) :
    3007  m_pList(src.m_pList),
    3008  m_pItem(src.m_pItem)
    3009  {
    3010  }
    3011 
    3012  const T& operator*() const
    3013  {
    3014  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    3015  return m_pItem->Value;
    3016  }
    3017  const T* operator->() const
    3018  {
    3019  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    3020  return &m_pItem->Value;
    3021  }
    3022 
    3023  const_iterator& operator++()
    3024  {
    3025  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
    3026  m_pItem = m_pItem->pNext;
    3027  return *this;
    3028  }
    3029  const_iterator& operator--()
    3030  {
    3031  if(m_pItem != VMA_NULL)
    3032  {
    3033  m_pItem = m_pItem->pPrev;
    3034  }
    3035  else
    3036  {
    3037  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
    3038  m_pItem = m_pList->Back();
    3039  }
    3040  return *this;
    3041  }
    3042 
    3043  const_iterator operator++(int)
    3044  {
    3045  const_iterator result = *this;
    3046  ++*this;
    3047  return result;
    3048  }
    3049  const_iterator operator--(int)
    3050  {
    3051  const_iterator result = *this;
    3052  --*this;
    3053  return result;
    3054  }
    3055 
    3056  bool operator==(const const_iterator& rhs) const
    3057  {
    3058  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    3059  return m_pItem == rhs.m_pItem;
    3060  }
    3061  bool operator!=(const const_iterator& rhs) const
    3062  {
    3063  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
    3064  return m_pItem != rhs.m_pItem;
    3065  }
    3066 
    3067  private:
    3068  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
    3069  m_pList(pList),
    3070  m_pItem(pItem)
    3071  {
    3072  }
    3073 
    3074  const VmaRawList<T>* m_pList;
    3075  const VmaListItem<T>* m_pItem;
    3076 
    3077  friend class VmaList<T, AllocatorT>;
    3078  };
    3079 
    3080  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
    3081 
    3082  bool empty() const { return m_RawList.IsEmpty(); }
    3083  size_t size() const { return m_RawList.GetCount(); }
    3084 
    3085  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
    3086  iterator end() { return iterator(&m_RawList, VMA_NULL); }
    3087 
    3088  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
    3089  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
    3090 
    3091  void clear() { m_RawList.Clear(); }
    3092  void push_back(const T& value) { m_RawList.PushBack(value); }
    3093  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
    3094  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
    3095 
    3096 private:
    3097  VmaRawList<T> m_RawList;
    3098 };
    3099 
    3100 #endif // #if VMA_USE_STL_LIST
    3101 
    3103 // class VmaMap
    3104 
    3105 // Unused in this version.
    3106 #if 0
    3107 
    3108 #if VMA_USE_STL_UNORDERED_MAP
    3109 
    3110 #define VmaPair std::pair
    3111 
    3112 #define VMA_MAP_TYPE(KeyT, ValueT) \
    3113  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
    3114 
    3115 #else // #if VMA_USE_STL_UNORDERED_MAP
    3116 
    3117 template<typename T1, typename T2>
    3118 struct VmaPair
    3119 {
    3120  T1 first;
    3121  T2 second;
    3122 
    3123  VmaPair() : first(), second() { }
    3124  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
    3125 };
    3126 
    3127 /* Class compatible with subset of interface of std::unordered_map.
    3128 KeyT, ValueT must be POD because they will be stored in VmaVector.
    3129 */
    3130 template<typename KeyT, typename ValueT>
    3131 class VmaMap
    3132 {
    3133 public:
    3134  typedef VmaPair<KeyT, ValueT> PairType;
    3135  typedef PairType* iterator;
    3136 
    3137  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
    3138 
    3139  iterator begin() { return m_Vector.begin(); }
    3140  iterator end() { return m_Vector.end(); }
    3141 
    3142  void insert(const PairType& pair);
    3143  iterator find(const KeyT& key);
    3144  void erase(iterator it);
    3145 
    3146 private:
    3147  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
    3148 };
    3149 
    3150 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
    3151 
    3152 template<typename FirstT, typename SecondT>
    3153 struct VmaPairFirstLess
    3154 {
    3155  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
    3156  {
    3157  return lhs.first < rhs.first;
    3158  }
    3159  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
    3160  {
    3161  return lhs.first < rhsFirst;
    3162  }
    3163 };
    3164 
    3165 template<typename KeyT, typename ValueT>
    3166 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
    3167 {
    3168  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
    3169  m_Vector.data(),
    3170  m_Vector.data() + m_Vector.size(),
    3171  pair,
    3172  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
    3173  VmaVectorInsert(m_Vector, indexToInsert, pair);
    3174 }
    3175 
    3176 template<typename KeyT, typename ValueT>
    3177 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
    3178 {
    3179  PairType* it = VmaBinaryFindFirstNotLess(
    3180  m_Vector.data(),
    3181  m_Vector.data() + m_Vector.size(),
    3182  key,
    3183  VmaPairFirstLess<KeyT, ValueT>());
    3184  if((it != m_Vector.end()) && (it->first == key))
    3185  {
    3186  return it;
    3187  }
    3188  else
    3189  {
    3190  return m_Vector.end();
    3191  }
    3192 }
    3193 
    3194 template<typename KeyT, typename ValueT>
    3195 void VmaMap<KeyT, ValueT>::erase(iterator it)
    3196 {
    3197  VmaVectorRemove(m_Vector, it - m_Vector.begin());
    3198 }
    3199 
    3200 #endif // #if VMA_USE_STL_UNORDERED_MAP
    3201 
    3202 #endif // #if 0
    3203 
    3205 
    3206 class VmaDeviceMemoryBlock;
    3207 
    3208 struct VmaAllocation_T
    3209 {
    3210 private:
    3211  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
    3212 
    3213  enum FLAGS
    3214  {
    3215  FLAG_USER_DATA_STRING = 0x01,
    3216  };
    3217 
    3218 public:
    3219  enum ALLOCATION_TYPE
    3220  {
    3221  ALLOCATION_TYPE_NONE,
    3222  ALLOCATION_TYPE_BLOCK,
    3223  ALLOCATION_TYPE_DEDICATED,
    3224  };
    3225 
    3226  VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
    3227  m_Alignment(1),
    3228  m_Size(0),
    3229  m_pUserData(VMA_NULL),
    3230  m_LastUseFrameIndex(currentFrameIndex),
    3231  m_Type((uint8_t)ALLOCATION_TYPE_NONE),
    3232  m_SuballocationType((uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN),
    3233  m_MapCount(0),
    3234  m_Flags(userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0)
    3235  {
    3236  }
    3237 
    3238  ~VmaAllocation_T()
    3239  {
    3240  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
    3241 
    3242  // Check if owned string was freed.
    3243  VMA_ASSERT(m_pUserData == VMA_NULL);
    3244  }
    3245 
    3246  void InitBlockAllocation(
    3247  VmaPool hPool,
    3248  VmaDeviceMemoryBlock* block,
    3249  VkDeviceSize offset,
    3250  VkDeviceSize alignment,
    3251  VkDeviceSize size,
    3252  VmaSuballocationType suballocationType,
    3253  bool mapped,
    3254  bool canBecomeLost)
    3255  {
    3256  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    3257  VMA_ASSERT(block != VMA_NULL);
    3258  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
    3259  m_Alignment = alignment;
    3260  m_Size = size;
    3261  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
    3262  m_SuballocationType = (uint8_t)suballocationType;
    3263  m_BlockAllocation.m_hPool = hPool;
    3264  m_BlockAllocation.m_Block = block;
    3265  m_BlockAllocation.m_Offset = offset;
    3266  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
    3267  }
    3268 
    3269  void InitLost()
    3270  {
    3271  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    3272  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
    3273  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
    3274  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
    3275  m_BlockAllocation.m_Block = VMA_NULL;
    3276  m_BlockAllocation.m_Offset = 0;
    3277  m_BlockAllocation.m_CanBecomeLost = true;
    3278  }
    3279 
    3280  void ChangeBlockAllocation(
    3281  VmaAllocator hAllocator,
    3282  VmaDeviceMemoryBlock* block,
    3283  VkDeviceSize offset);
    3284 
    3285  // pMappedData not null means allocation is created with MAPPED flag.
    3286  void InitDedicatedAllocation(
    3287  uint32_t memoryTypeIndex,
    3288  VkDeviceMemory hMemory,
    3289  VmaSuballocationType suballocationType,
    3290  void* pMappedData,
    3291  VkDeviceSize size)
    3292  {
    3293  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
    3294  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
    3295  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
    3296  m_Alignment = 0;
    3297  m_Size = size;
    3298  m_SuballocationType = (uint8_t)suballocationType;
    3299  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
    3300  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
    3301  m_DedicatedAllocation.m_hMemory = hMemory;
    3302  m_DedicatedAllocation.m_pMappedData = pMappedData;
    3303  }
    3304 
    3305  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
    3306  VkDeviceSize GetAlignment() const { return m_Alignment; }
    3307  VkDeviceSize GetSize() const { return m_Size; }
    3308  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
    3309  void* GetUserData() const { return m_pUserData; }
    3310  void SetUserData(VmaAllocator hAllocator, void* pUserData);
    3311  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
    3312 
    3313  VmaDeviceMemoryBlock* GetBlock() const
    3314  {
    3315  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    3316  return m_BlockAllocation.m_Block;
    3317  }
    3318  VkDeviceSize GetOffset() const;
    3319  VkDeviceMemory GetMemory() const;
    3320  uint32_t GetMemoryTypeIndex() const;
    3321  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
    3322  void* GetMappedData() const;
    3323  bool CanBecomeLost() const;
    3324  VmaPool GetPool() const;
    3325 
    3326  uint32_t GetLastUseFrameIndex() const
    3327  {
    3328  return m_LastUseFrameIndex.load();
    3329  }
    3330  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
    3331  {
    3332  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
    3333  }
    3334  /*
    3335  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
    3336  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
    3337  - Else, returns false.
    3338 
    3339  If hAllocation is already lost, assert - you should not call it then.
    3340  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
    3341  */
    3342  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
    3343 
    3344  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
    3345  {
    3346  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
    3347  outInfo.blockCount = 1;
    3348  outInfo.allocationCount = 1;
    3349  outInfo.unusedRangeCount = 0;
    3350  outInfo.usedBytes = m_Size;
    3351  outInfo.unusedBytes = 0;
    3352  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
    3353  outInfo.unusedRangeSizeMin = UINT64_MAX;
    3354  outInfo.unusedRangeSizeMax = 0;
    3355  }
    3356 
    3357  void BlockAllocMap();
    3358  void BlockAllocUnmap();
    3359  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
    3360  void DedicatedAllocUnmap(VmaAllocator hAllocator);
    3361 
    3362 private:
    3363  VkDeviceSize m_Alignment;
    3364  VkDeviceSize m_Size;
    3365  void* m_pUserData;
    3366  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
    3367  uint8_t m_Type; // ALLOCATION_TYPE
    3368  uint8_t m_SuballocationType; // VmaSuballocationType
    3369  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
    3370  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
    3371  uint8_t m_MapCount;
    3372  uint8_t m_Flags; // enum FLAGS
    3373 
    3374  // Allocation out of VmaDeviceMemoryBlock.
    3375  struct BlockAllocation
    3376  {
    3377  VmaPool m_hPool; // Null if belongs to general memory.
    3378  VmaDeviceMemoryBlock* m_Block;
    3379  VkDeviceSize m_Offset;
    3380  bool m_CanBecomeLost;
    3381  };
    3382 
    3383  // Allocation for an object that has its own private VkDeviceMemory.
    3384  struct DedicatedAllocation
    3385  {
    3386  uint32_t m_MemoryTypeIndex;
    3387  VkDeviceMemory m_hMemory;
    3388  void* m_pMappedData; // Not null means memory is mapped.
    3389  };
    3390 
    3391  union
    3392  {
    3393  // Allocation out of VmaDeviceMemoryBlock.
    3394  BlockAllocation m_BlockAllocation;
    3395  // Allocation for an object that has its own private VkDeviceMemory.
    3396  DedicatedAllocation m_DedicatedAllocation;
    3397  };
    3398 
    3399  void FreeUserDataString(VmaAllocator hAllocator);
    3400 };
    3401 
    3402 /*
    3403 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
    3404 allocated memory block or free.
    3405 */
    3406 struct VmaSuballocation
    3407 {
    3408  VkDeviceSize offset;
    3409  VkDeviceSize size;
    3410  VmaAllocation hAllocation;
    3411  VmaSuballocationType type;
    3412 };
    3413 
    3414 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
    3415 
    3416 // Cost of one additional allocation lost, as equivalent in bytes.
    3417 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
    3418 
    3419 /*
    3420 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
    3421 
    3422 If canMakeOtherLost was false:
    3423 - item points to a FREE suballocation.
    3424 - itemsToMakeLostCount is 0.
    3425 
    3426 If canMakeOtherLost was true:
    3427 - item points to first of sequence of suballocations, which are either FREE,
    3428  or point to VmaAllocations that can become lost.
    3429 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
    3430  the requested allocation to succeed.
    3431 */
    3432 struct VmaAllocationRequest
    3433 {
    3434  VkDeviceSize offset;
    3435  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
    3436  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
    3437  VmaSuballocationList::iterator item;
    3438  size_t itemsToMakeLostCount;
    3439 
    3440  VkDeviceSize CalcCost() const
    3441  {
    3442  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
    3443  }
    3444 };
    3445 
    3446 /*
    3447 Data structure used for bookkeeping of allocations and unused ranges of memory
    3448 in a single VkDeviceMemory block.
    3449 */
    3450 class VmaBlockMetadata
    3451 {
    3452 public:
    3453  VmaBlockMetadata(VmaAllocator hAllocator);
    3454  ~VmaBlockMetadata();
    3455  void Init(VkDeviceSize size);
    3456 
    3457  // Validates all data structures inside this object. If not valid, returns false.
    3458  bool Validate() const;
    3459  VkDeviceSize GetSize() const { return m_Size; }
    3460  size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
    3461  VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
    3462  VkDeviceSize GetUnusedRangeSizeMax() const;
    3463  // Returns true if this block is empty - contains only single free suballocation.
    3464  bool IsEmpty() const;
    3465 
    3466  void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
    3467  void AddPoolStats(VmaPoolStats& inoutStats) const;
    3468 
    3469 #if VMA_STATS_STRING_ENABLED
    3470  void PrintDetailedMap(class VmaJsonWriter& json) const;
    3471 #endif
    3472 
    3473  // Creates trivial request for case when block is empty.
    3474  void CreateFirstAllocationRequest(VmaAllocationRequest* pAllocationRequest);
    3475 
    3476  // Tries to find a place for suballocation with given parameters inside this block.
    3477  // If succeeded, fills pAllocationRequest and returns true.
    3478  // If failed, returns false.
    3479  bool CreateAllocationRequest(
    3480  uint32_t currentFrameIndex,
    3481  uint32_t frameInUseCount,
    3482  VkDeviceSize bufferImageGranularity,
    3483  VkDeviceSize allocSize,
    3484  VkDeviceSize allocAlignment,
    3485  VmaSuballocationType allocType,
    3486  bool canMakeOtherLost,
    3487  VmaAllocationRequest* pAllocationRequest);
    3488 
    3489  bool MakeRequestedAllocationsLost(
    3490  uint32_t currentFrameIndex,
    3491  uint32_t frameInUseCount,
    3492  VmaAllocationRequest* pAllocationRequest);
    3493 
    3494  uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
    3495 
    3496  // Makes actual allocation based on request. Request must already be checked and valid.
    3497  void Alloc(
    3498  const VmaAllocationRequest& request,
    3499  VmaSuballocationType type,
    3500  VkDeviceSize allocSize,
    3501  VmaAllocation hAllocation);
    3502 
    3503  // Frees suballocation assigned to given memory region.
    3504  void Free(const VmaAllocation allocation);
    3505  void FreeAtOffset(VkDeviceSize offset);
    3506 
    3507 private:
    3508  VkDeviceSize m_Size;
    3509  uint32_t m_FreeCount;
    3510  VkDeviceSize m_SumFreeSize;
    3511  VmaSuballocationList m_Suballocations;
    3512  // Suballocations that are free and have size greater than certain threshold.
    3513  // Sorted by size, ascending.
    3514  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
    3515 
    3516  bool ValidateFreeSuballocationList() const;
    3517 
    3518  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
    3519  // If yes, fills pOffset and returns true. If no, returns false.
    3520  bool CheckAllocation(
    3521  uint32_t currentFrameIndex,
    3522  uint32_t frameInUseCount,
    3523  VkDeviceSize bufferImageGranularity,
    3524  VkDeviceSize allocSize,
    3525  VkDeviceSize allocAlignment,
    3526  VmaSuballocationType allocType,
    3527  VmaSuballocationList::const_iterator suballocItem,
    3528  bool canMakeOtherLost,
    3529  VkDeviceSize* pOffset,
    3530  size_t* itemsToMakeLostCount,
    3531  VkDeviceSize* pSumFreeSize,
    3532  VkDeviceSize* pSumItemSize) const;
    3533  // Given free suballocation, it merges it with following one, which must also be free.
    3534  void MergeFreeWithNext(VmaSuballocationList::iterator item);
    3535  // Releases given suballocation, making it free.
    3536  // Merges it with adjacent free suballocations if applicable.
    3537  // Returns iterator to new free suballocation at this place.
    3538  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
    3539  // Given free suballocation, it inserts it into sorted list of
    3540  // m_FreeSuballocationsBySize if it's suitable.
    3541  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
    3542  // Given free suballocation, it removes it from sorted list of
    3543  // m_FreeSuballocationsBySize if it's suitable.
    3544  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
    3545 };
    3546 
    3547 // Helper class that represents mapped memory. Synchronized internally.
    3548 class VmaDeviceMemoryMapping
    3549 {
    3550 public:
    3551  VmaDeviceMemoryMapping();
    3552  ~VmaDeviceMemoryMapping();
    3553 
    3554  void* GetMappedData() const { return m_pMappedData; }
    3555 
    3556  // ppData can be null.
    3557  VkResult Map(VmaAllocator hAllocator, VkDeviceMemory hMemory, uint32_t count, void **ppData);
    3558  void Unmap(VmaAllocator hAllocator, VkDeviceMemory hMemory, uint32_t count);
    3559 
    3560 private:
    3561  VMA_MUTEX m_Mutex;
    3562  uint32_t m_MapCount;
    3563  void* m_pMappedData;
    3564 };
    3565 
    3566 /*
    3567 Represents a single block of device memory (`VkDeviceMemory`) with all the
    3568 data about its regions (aka suballocations, `VmaAllocation`), assigned and free.
    3569 
    3570 Thread-safety: This class must be externally synchronized.
    3571 */
    3572 class VmaDeviceMemoryBlock
    3573 {
    3574 public:
    3575  uint32_t m_MemoryTypeIndex;
    3576  VkDeviceMemory m_hMemory;
    3577  VmaDeviceMemoryMapping m_Mapping;
    3578  VmaBlockMetadata m_Metadata;
    3579 
    3580  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
    3581 
    3582  ~VmaDeviceMemoryBlock()
    3583  {
    3584  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
    3585  }
    3586 
    3587  // Always call after construction.
    3588  void Init(
    3589  uint32_t newMemoryTypeIndex,
    3590  VkDeviceMemory newMemory,
    3591  VkDeviceSize newSize);
    3592  // Always call before destruction.
    3593  void Destroy(VmaAllocator allocator);
    3594 
    3595  // Validates all data structures inside this object. If not valid, returns false.
    3596  bool Validate() const;
    3597 
    3598  // ppData can be null.
    3599  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
    3600  void Unmap(VmaAllocator hAllocator, uint32_t count);
    3601 };
    3602 
    3603 struct VmaPointerLess
    3604 {
    3605  bool operator()(const void* lhs, const void* rhs) const
    3606  {
    3607  return lhs < rhs;
    3608  }
    3609 };
    3610 
    3611 class VmaDefragmentator;
    3612 
    3613 /*
    3614 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
    3615 Vulkan memory type.
    3616 
    3617 Synchronized internally with a mutex.
    3618 */
    3619 struct VmaBlockVector
    3620 {
    3621  VmaBlockVector(
    3622  VmaAllocator hAllocator,
    3623  uint32_t memoryTypeIndex,
    3624  VkDeviceSize preferredBlockSize,
    3625  size_t minBlockCount,
    3626  size_t maxBlockCount,
    3627  VkDeviceSize bufferImageGranularity,
    3628  uint32_t frameInUseCount,
    3629  bool isCustomPool);
    3630  ~VmaBlockVector();
    3631 
    3632  VkResult CreateMinBlocks();
    3633 
    3634  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
    3635  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
    3636  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
    3637  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
    3638 
    3639  void GetPoolStats(VmaPoolStats* pStats);
    3640 
    3641  bool IsEmpty() const { return m_Blocks.empty(); }
    3642 
    3643  VkResult Allocate(
    3644  VmaPool hCurrentPool,
    3645  uint32_t currentFrameIndex,
    3646  const VkMemoryRequirements& vkMemReq,
    3647  const VmaAllocationCreateInfo& createInfo,
    3648  VmaSuballocationType suballocType,
    3649  VmaAllocation* pAllocation);
    3650 
    3651  void Free(
    3652  VmaAllocation hAllocation);
    3653 
    3654  // Adds statistics of this BlockVector to pStats.
    3655  void AddStats(VmaStats* pStats);
    3656 
    3657 #if VMA_STATS_STRING_ENABLED
    3658  void PrintDetailedMap(class VmaJsonWriter& json);
    3659 #endif
    3660 
    3661  void MakePoolAllocationsLost(
    3662  uint32_t currentFrameIndex,
    3663  size_t* pLostAllocationCount);
    3664 
    3665  VmaDefragmentator* EnsureDefragmentator(
    3666  VmaAllocator hAllocator,
    3667  uint32_t currentFrameIndex);
    3668 
    3669  VkResult Defragment(
    3670  VmaDefragmentationStats* pDefragmentationStats,
    3671  VkDeviceSize& maxBytesToMove,
    3672  uint32_t& maxAllocationsToMove);
    3673 
    3674  void DestroyDefragmentator();
    3675 
    3676 private:
    3677  friend class VmaDefragmentator;
    3678 
    3679  const VmaAllocator m_hAllocator;
    3680  const uint32_t m_MemoryTypeIndex;
    3681  const VkDeviceSize m_PreferredBlockSize;
    3682  const size_t m_MinBlockCount;
    3683  const size_t m_MaxBlockCount;
    3684  const VkDeviceSize m_BufferImageGranularity;
    3685  const uint32_t m_FrameInUseCount;
    3686  const bool m_IsCustomPool;
    3687  VMA_MUTEX m_Mutex;
    3688  // Incrementally sorted by sumFreeSize, ascending.
    3689  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
    3690  /* There can be at most one allocation that is completely empty - a
    3691  hysteresis to avoid pessimistic case of alternating creation and destruction
    3692  of a VkDeviceMemory. */
    3693  bool m_HasEmptyBlock;
    3694  VmaDefragmentator* m_pDefragmentator;
    3695 
    3696  size_t CalcMaxBlockSize() const;
    3697 
    3698  // Finds and removes given block from vector.
    3699  void Remove(VmaDeviceMemoryBlock* pBlock);
    3700 
    3701  // Performs single step in sorting m_Blocks. They may not be fully sorted
    3702  // after this call.
    3703  void IncrementallySortBlocks();
    3704 
    3705  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
    3706 };
    3707 
    3708 struct VmaPool_T
    3709 {
    3710 public:
    3711  VmaBlockVector m_BlockVector;
    3712 
    3713  // Takes ownership.
    3714  VmaPool_T(
    3715  VmaAllocator hAllocator,
    3716  const VmaPoolCreateInfo& createInfo);
    3717  ~VmaPool_T();
    3718 
    3719  VmaBlockVector& GetBlockVector() { return m_BlockVector; }
    3720 
    3721 #if VMA_STATS_STRING_ENABLED
    3722  //void PrintDetailedMap(class VmaStringBuilder& sb);
    3723 #endif
    3724 };
    3725 
    3726 class VmaDefragmentator
    3727 {
    3728  const VmaAllocator m_hAllocator;
    3729  VmaBlockVector* const m_pBlockVector;
    3730  uint32_t m_CurrentFrameIndex;
    3731  VkDeviceSize m_BytesMoved;
    3732  uint32_t m_AllocationsMoved;
    3733 
    3734  struct AllocationInfo
    3735  {
    3736  VmaAllocation m_hAllocation;
    3737  VkBool32* m_pChanged;
    3738 
    3739  AllocationInfo() :
    3740  m_hAllocation(VK_NULL_HANDLE),
    3741  m_pChanged(VMA_NULL)
    3742  {
    3743  }
    3744  };
    3745 
    3746  struct AllocationInfoSizeGreater
    3747  {
    3748  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
    3749  {
    3750  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
    3751  }
    3752  };
    3753 
    3754  // Used between AddAllocation and Defragment.
    3755  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
    3756 
    3757  struct BlockInfo
    3758  {
    3759  VmaDeviceMemoryBlock* m_pBlock;
    3760  bool m_HasNonMovableAllocations;
    3761  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
    3762 
    3763  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
    3764  m_pBlock(VMA_NULL),
    3765  m_HasNonMovableAllocations(true),
    3766  m_Allocations(pAllocationCallbacks),
    3767  m_pMappedDataForDefragmentation(VMA_NULL)
    3768  {
    3769  }
    3770 
    3771  void CalcHasNonMovableAllocations()
    3772  {
    3773  const size_t blockAllocCount = m_pBlock->m_Metadata.GetAllocationCount();
    3774  const size_t defragmentAllocCount = m_Allocations.size();
    3775  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
    3776  }
    3777 
    3778  void SortAllocationsBySizeDescecnding()
    3779  {
    3780  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
    3781  }
    3782 
    3783  VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);
    3784  void Unmap(VmaAllocator hAllocator);
    3785 
    3786  private:
    3787  // Not null if mapped for defragmentation only, not originally mapped.
    3788  void* m_pMappedDataForDefragmentation;
    3789  };
    3790 
    3791  struct BlockPointerLess
    3792  {
    3793  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
    3794  {
    3795  return pLhsBlockInfo->m_pBlock < pRhsBlock;
    3796  }
    3797  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
    3798  {
    3799  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
    3800  }
    3801  };
    3802 
    3803  // 1. Blocks with some non-movable allocations go first.
    3804  // 2. Blocks with smaller sumFreeSize go first.
    3805  struct BlockInfoCompareMoveDestination
    3806  {
    3807  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
    3808  {
    3809  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
    3810  {
    3811  return true;
    3812  }
    3813  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
    3814  {
    3815  return false;
    3816  }
    3817  if(pLhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize())
    3818  {
    3819  return true;
    3820  }
    3821  return false;
    3822  }
    3823  };
    3824 
    3825  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
    3826  BlockInfoVector m_Blocks;
    3827 
    3828  VkResult DefragmentRound(
    3829  VkDeviceSize maxBytesToMove,
    3830  uint32_t maxAllocationsToMove);
    3831 
    3832  static bool MoveMakesSense(
    3833  size_t dstBlockIndex, VkDeviceSize dstOffset,
    3834  size_t srcBlockIndex, VkDeviceSize srcOffset);
    3835 
    3836 public:
    3837  VmaDefragmentator(
    3838  VmaAllocator hAllocator,
    3839  VmaBlockVector* pBlockVector,
    3840  uint32_t currentFrameIndex);
    3841 
    3842  ~VmaDefragmentator();
    3843 
    3844  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
    3845  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
    3846 
    3847  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
    3848 
    3849  VkResult Defragment(
    3850  VkDeviceSize maxBytesToMove,
    3851  uint32_t maxAllocationsToMove);
    3852 };
    3853 
    3854 // Main allocator object.
    3855 struct VmaAllocator_T
    3856 {
    3857  bool m_UseMutex;
    3858  bool m_UseKhrDedicatedAllocation;
    3859  VkDevice m_hDevice;
    3860  bool m_AllocationCallbacksSpecified;
    3861  VkAllocationCallbacks m_AllocationCallbacks;
    3862  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
    3863 
    3864  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
    3865  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
    3866  VMA_MUTEX m_HeapSizeLimitMutex;
    3867 
    3868  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
    3869  VkPhysicalDeviceMemoryProperties m_MemProps;
    3870 
    3871  // Default pools.
    3872  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
    3873 
    3874  // Each vector is sorted by memory (handle value).
    3875  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
    3876  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
    3877  VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
    3878 
    3879  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
    3880  ~VmaAllocator_T();
    3881 
    3882  const VkAllocationCallbacks* GetAllocationCallbacks() const
    3883  {
    3884  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
    3885  }
    3886  const VmaVulkanFunctions& GetVulkanFunctions() const
    3887  {
    3888  return m_VulkanFunctions;
    3889  }
    3890 
    3891  VkDeviceSize GetBufferImageGranularity() const
    3892  {
    3893  return VMA_MAX(
    3894  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
    3895  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
    3896  }
    3897 
    3898  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
    3899  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
    3900 
    3901  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
    3902  {
    3903  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
    3904  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
    3905  }
    3906 
    3907  void GetBufferMemoryRequirements(
    3908  VkBuffer hBuffer,
    3909  VkMemoryRequirements& memReq,
    3910  bool& requiresDedicatedAllocation,
    3911  bool& prefersDedicatedAllocation) const;
    3912  void GetImageMemoryRequirements(
    3913  VkImage hImage,
    3914  VkMemoryRequirements& memReq,
    3915  bool& requiresDedicatedAllocation,
    3916  bool& prefersDedicatedAllocation) const;
    3917 
    3918  // Main allocation function.
    3919  VkResult AllocateMemory(
    3920  const VkMemoryRequirements& vkMemReq,
    3921  bool requiresDedicatedAllocation,
    3922  bool prefersDedicatedAllocation,
    3923  VkBuffer dedicatedBuffer,
    3924  VkImage dedicatedImage,
    3925  const VmaAllocationCreateInfo& createInfo,
    3926  VmaSuballocationType suballocType,
    3927  VmaAllocation* pAllocation);
    3928 
    3929  // Main deallocation function.
    3930  void FreeMemory(const VmaAllocation allocation);
    3931 
    3932  void CalculateStats(VmaStats* pStats);
    3933 
    3934 #if VMA_STATS_STRING_ENABLED
    3935  void PrintDetailedMap(class VmaJsonWriter& json);
    3936 #endif
    3937 
    3938  VkResult Defragment(
    3939  VmaAllocation* pAllocations,
    3940  size_t allocationCount,
    3941  VkBool32* pAllocationsChanged,
    3942  const VmaDefragmentationInfo* pDefragmentationInfo,
    3943  VmaDefragmentationStats* pDefragmentationStats);
    3944 
    3945  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
    3946 
    3947  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
    3948  void DestroyPool(VmaPool pool);
    3949  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
    3950 
    3951  void SetCurrentFrameIndex(uint32_t frameIndex);
    3952 
    3953  void MakePoolAllocationsLost(
    3954  VmaPool hPool,
    3955  size_t* pLostAllocationCount);
    3956 
    3957  void CreateLostAllocation(VmaAllocation* pAllocation);
    3958 
    3959  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
    3960  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
    3961 
    3962  VkResult Map(VmaAllocation hAllocation, void** ppData);
    3963  void Unmap(VmaAllocation hAllocation);
    3964 
    3965 private:
    3966  VkDeviceSize m_PreferredLargeHeapBlockSize;
    3967 
    3968  VkPhysicalDevice m_PhysicalDevice;
    3969  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
    3970 
    3971  VMA_MUTEX m_PoolsMutex;
    3972  // Protected by m_PoolsMutex. Sorted by pointer value.
    3973  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
    3974 
    3975  VmaVulkanFunctions m_VulkanFunctions;
    3976 
    3977  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
    3978 
    3979  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
    3980 
    3981  VkResult AllocateMemoryOfType(
    3982  const VkMemoryRequirements& vkMemReq,
    3983  bool dedicatedAllocation,
    3984  VkBuffer dedicatedBuffer,
    3985  VkImage dedicatedImage,
    3986  const VmaAllocationCreateInfo& createInfo,
    3987  uint32_t memTypeIndex,
    3988  VmaSuballocationType suballocType,
    3989  VmaAllocation* pAllocation);
    3990 
    3991  // Allocates and registers new VkDeviceMemory specifically for single allocation.
    3992  VkResult AllocateDedicatedMemory(
    3993  VkDeviceSize size,
    3994  VmaSuballocationType suballocType,
    3995  uint32_t memTypeIndex,
    3996  bool map,
    3997  bool isUserDataString,
    3998  void* pUserData,
    3999  VkBuffer dedicatedBuffer,
    4000  VkImage dedicatedImage,
    4001  VmaAllocation* pAllocation);
    4002 
    4003  // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.
    4004  void FreeDedicatedMemory(VmaAllocation allocation);
    4005 };
    4006 
    4008 // Memory allocation #2 after VmaAllocator_T definition
    4009 
    4010 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
    4011 {
    4012  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
    4013 }
    4014 
    4015 static void VmaFree(VmaAllocator hAllocator, void* ptr)
    4016 {
    4017  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
    4018 }
    4019 
    4020 template<typename T>
    4021 static T* VmaAllocate(VmaAllocator hAllocator)
    4022 {
    4023  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
    4024 }
    4025 
    4026 template<typename T>
    4027 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
    4028 {
    4029  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
    4030 }
    4031 
    4032 template<typename T>
    4033 static void vma_delete(VmaAllocator hAllocator, T* ptr)
    4034 {
    4035  if(ptr != VMA_NULL)
    4036  {
    4037  ptr->~T();
    4038  VmaFree(hAllocator, ptr);
    4039  }
    4040 }
    4041 
    4042 template<typename T>
    4043 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
    4044 {
    4045  if(ptr != VMA_NULL)
    4046  {
    4047  for(size_t i = count; i--; )
    4048  ptr[i].~T();
    4049  VmaFree(hAllocator, ptr);
    4050  }
    4051 }
    4052 
    4054 // VmaStringBuilder
    4055 
    4056 #if VMA_STATS_STRING_ENABLED
    4057 
    4058 class VmaStringBuilder
    4059 {
    4060 public:
    4061  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
    4062  size_t GetLength() const { return m_Data.size(); }
    4063  const char* GetData() const { return m_Data.data(); }
    4064 
    4065  void Add(char ch) { m_Data.push_back(ch); }
    4066  void Add(const char* pStr);
    4067  void AddNewLine() { Add('\n'); }
    4068  void AddNumber(uint32_t num);
    4069  void AddNumber(uint64_t num);
    4070  void AddPointer(const void* ptr);
    4071 
    4072 private:
    4073  VmaVector< char, VmaStlAllocator<char> > m_Data;
    4074 };
    4075 
    4076 void VmaStringBuilder::Add(const char* pStr)
    4077 {
    4078  const size_t strLen = strlen(pStr);
    4079  if(strLen > 0)
    4080  {
    4081  const size_t oldCount = m_Data.size();
    4082  m_Data.resize(oldCount + strLen);
    4083  memcpy(m_Data.data() + oldCount, pStr, strLen);
    4084  }
    4085 }
    4086 
    4087 void VmaStringBuilder::AddNumber(uint32_t num)
    4088 {
    4089  char buf[11];
    4090  VmaUint32ToStr(buf, sizeof(buf), num);
    4091  Add(buf);
    4092 }
    4093 
    4094 void VmaStringBuilder::AddNumber(uint64_t num)
    4095 {
    4096  char buf[21];
    4097  VmaUint64ToStr(buf, sizeof(buf), num);
    4098  Add(buf);
    4099 }
    4100 
    4101 void VmaStringBuilder::AddPointer(const void* ptr)
    4102 {
    4103  char buf[21];
    4104  VmaPtrToStr(buf, sizeof(buf), ptr);
    4105  Add(buf);
    4106 }
    4107 
    4108 #endif // #if VMA_STATS_STRING_ENABLED
    4109 
    4111 // VmaJsonWriter
    4112 
    4113 #if VMA_STATS_STRING_ENABLED
    4114 
    4115 class VmaJsonWriter
    4116 {
    4117 public:
    4118  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
    4119  ~VmaJsonWriter();
    4120 
    4121  void BeginObject(bool singleLine = false);
    4122  void EndObject();
    4123 
    4124  void BeginArray(bool singleLine = false);
    4125  void EndArray();
    4126 
    4127  void WriteString(const char* pStr);
    4128  void BeginString(const char* pStr = VMA_NULL);
    4129  void ContinueString(const char* pStr);
    4130  void ContinueString(uint32_t n);
    4131  void ContinueString(uint64_t n);
    4132  void ContinueString_Pointer(const void* ptr);
    4133  void EndString(const char* pStr = VMA_NULL);
    4134 
    4135  void WriteNumber(uint32_t n);
    4136  void WriteNumber(uint64_t n);
    4137  void WriteBool(bool b);
    4138  void WriteNull();
    4139 
    4140 private:
    4141  static const char* const INDENT;
    4142 
    4143  enum COLLECTION_TYPE
    4144  {
    4145  COLLECTION_TYPE_OBJECT,
    4146  COLLECTION_TYPE_ARRAY,
    4147  };
    4148  struct StackItem
    4149  {
    4150  COLLECTION_TYPE type;
    4151  uint32_t valueCount;
    4152  bool singleLineMode;
    4153  };
    4154 
    4155  VmaStringBuilder& m_SB;
    4156  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
    4157  bool m_InsideString;
    4158 
    4159  void BeginValue(bool isString);
    4160  void WriteIndent(bool oneLess = false);
    4161 };
    4162 
    4163 const char* const VmaJsonWriter::INDENT = " ";
    4164 
    4165 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
    4166  m_SB(sb),
    4167  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
    4168  m_InsideString(false)
    4169 {
    4170 }
    4171 
    4172 VmaJsonWriter::~VmaJsonWriter()
    4173 {
    4174  VMA_ASSERT(!m_InsideString);
    4175  VMA_ASSERT(m_Stack.empty());
    4176 }
    4177 
    4178 void VmaJsonWriter::BeginObject(bool singleLine)
    4179 {
    4180  VMA_ASSERT(!m_InsideString);
    4181 
    4182  BeginValue(false);
    4183  m_SB.Add('{');
    4184 
    4185  StackItem item;
    4186  item.type = COLLECTION_TYPE_OBJECT;
    4187  item.valueCount = 0;
    4188  item.singleLineMode = singleLine;
    4189  m_Stack.push_back(item);
    4190 }
    4191 
    4192 void VmaJsonWriter::EndObject()
    4193 {
    4194  VMA_ASSERT(!m_InsideString);
    4195 
    4196  WriteIndent(true);
    4197  m_SB.Add('}');
    4198 
    4199  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
    4200  m_Stack.pop_back();
    4201 }
    4202 
    4203 void VmaJsonWriter::BeginArray(bool singleLine)
    4204 {
    4205  VMA_ASSERT(!m_InsideString);
    4206 
    4207  BeginValue(false);
    4208  m_SB.Add('[');
    4209 
    4210  StackItem item;
    4211  item.type = COLLECTION_TYPE_ARRAY;
    4212  item.valueCount = 0;
    4213  item.singleLineMode = singleLine;
    4214  m_Stack.push_back(item);
    4215 }
    4216 
    4217 void VmaJsonWriter::EndArray()
    4218 {
    4219  VMA_ASSERT(!m_InsideString);
    4220 
    4221  WriteIndent(true);
    4222  m_SB.Add(']');
    4223 
    4224  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
    4225  m_Stack.pop_back();
    4226 }
    4227 
    4228 void VmaJsonWriter::WriteString(const char* pStr)
    4229 {
    4230  BeginString(pStr);
    4231  EndString();
    4232 }
    4233 
    4234 void VmaJsonWriter::BeginString(const char* pStr)
    4235 {
    4236  VMA_ASSERT(!m_InsideString);
    4237 
    4238  BeginValue(true);
    4239  m_SB.Add('"');
    4240  m_InsideString = true;
    4241  if(pStr != VMA_NULL && pStr[0] != '\0')
    4242  {
    4243  ContinueString(pStr);
    4244  }
    4245 }
    4246 
    4247 void VmaJsonWriter::ContinueString(const char* pStr)
    4248 {
    4249  VMA_ASSERT(m_InsideString);
    4250 
    4251  const size_t strLen = strlen(pStr);
    4252  for(size_t i = 0; i < strLen; ++i)
    4253  {
    4254  char ch = pStr[i];
    4255  if(ch == '\'')
    4256  {
    4257  m_SB.Add("\\\\");
    4258  }
    4259  else if(ch == '"')
    4260  {
    4261  m_SB.Add("\\\"");
    4262  }
    4263  else if(ch >= 32)
    4264  {
    4265  m_SB.Add(ch);
    4266  }
    4267  else switch(ch)
    4268  {
    4269  case '\b':
    4270  m_SB.Add("\\b");
    4271  break;
    4272  case '\f':
    4273  m_SB.Add("\\f");
    4274  break;
    4275  case '\n':
    4276  m_SB.Add("\\n");
    4277  break;
    4278  case '\r':
    4279  m_SB.Add("\\r");
    4280  break;
    4281  case '\t':
    4282  m_SB.Add("\\t");
    4283  break;
    4284  default:
    4285  VMA_ASSERT(0 && "Character not currently supported.");
    4286  break;
    4287  }
    4288  }
    4289 }
    4290 
    4291 void VmaJsonWriter::ContinueString(uint32_t n)
    4292 {
    4293  VMA_ASSERT(m_InsideString);
    4294  m_SB.AddNumber(n);
    4295 }
    4296 
    4297 void VmaJsonWriter::ContinueString(uint64_t n)
    4298 {
    4299  VMA_ASSERT(m_InsideString);
    4300  m_SB.AddNumber(n);
    4301 }
    4302 
    4303 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
    4304 {
    4305  VMA_ASSERT(m_InsideString);
    4306  m_SB.AddPointer(ptr);
    4307 }
    4308 
    4309 void VmaJsonWriter::EndString(const char* pStr)
    4310 {
    4311  VMA_ASSERT(m_InsideString);
    4312  if(pStr != VMA_NULL && pStr[0] != '\0')
    4313  {
    4314  ContinueString(pStr);
    4315  }
    4316  m_SB.Add('"');
    4317  m_InsideString = false;
    4318 }
    4319 
    4320 void VmaJsonWriter::WriteNumber(uint32_t n)
    4321 {
    4322  VMA_ASSERT(!m_InsideString);
    4323  BeginValue(false);
    4324  m_SB.AddNumber(n);
    4325 }
    4326 
    4327 void VmaJsonWriter::WriteNumber(uint64_t n)
    4328 {
    4329  VMA_ASSERT(!m_InsideString);
    4330  BeginValue(false);
    4331  m_SB.AddNumber(n);
    4332 }
    4333 
    4334 void VmaJsonWriter::WriteBool(bool b)
    4335 {
    4336  VMA_ASSERT(!m_InsideString);
    4337  BeginValue(false);
    4338  m_SB.Add(b ? "true" : "false");
    4339 }
    4340 
    4341 void VmaJsonWriter::WriteNull()
    4342 {
    4343  VMA_ASSERT(!m_InsideString);
    4344  BeginValue(false);
    4345  m_SB.Add("null");
    4346 }
    4347 
    4348 void VmaJsonWriter::BeginValue(bool isString)
    4349 {
    4350  if(!m_Stack.empty())
    4351  {
    4352  StackItem& currItem = m_Stack.back();
    4353  if(currItem.type == COLLECTION_TYPE_OBJECT &&
    4354  currItem.valueCount % 2 == 0)
    4355  {
    4356  VMA_ASSERT(isString);
    4357  }
    4358 
    4359  if(currItem.type == COLLECTION_TYPE_OBJECT &&
    4360  currItem.valueCount % 2 != 0)
    4361  {
    4362  m_SB.Add(": ");
    4363  }
    4364  else if(currItem.valueCount > 0)
    4365  {
    4366  m_SB.Add(", ");
    4367  WriteIndent();
    4368  }
    4369  else
    4370  {
    4371  WriteIndent();
    4372  }
    4373  ++currItem.valueCount;
    4374  }
    4375 }
    4376 
    4377 void VmaJsonWriter::WriteIndent(bool oneLess)
    4378 {
    4379  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
    4380  {
    4381  m_SB.AddNewLine();
    4382 
    4383  size_t count = m_Stack.size();
    4384  if(count > 0 && oneLess)
    4385  {
    4386  --count;
    4387  }
    4388  for(size_t i = 0; i < count; ++i)
    4389  {
    4390  m_SB.Add(INDENT);
    4391  }
    4392  }
    4393 }
    4394 
    4395 #endif // #if VMA_STATS_STRING_ENABLED
    4396 
    4398 
    4399 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
    4400 {
    4401  if(IsUserDataString())
    4402  {
    4403  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
    4404 
    4405  FreeUserDataString(hAllocator);
    4406 
    4407  if(pUserData != VMA_NULL)
    4408  {
    4409  const char* const newStrSrc = (char*)pUserData;
    4410  const size_t newStrLen = strlen(newStrSrc);
    4411  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
    4412  memcpy(newStrDst, newStrSrc, newStrLen + 1);
    4413  m_pUserData = newStrDst;
    4414  }
    4415  }
    4416  else
    4417  {
    4418  m_pUserData = pUserData;
    4419  }
    4420 }
    4421 
    4422 void VmaAllocation_T::ChangeBlockAllocation(
    4423  VmaAllocator hAllocator,
    4424  VmaDeviceMemoryBlock* block,
    4425  VkDeviceSize offset)
    4426 {
    4427  VMA_ASSERT(block != VMA_NULL);
    4428  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    4429 
    4430  // Move mapping reference counter from old block to new block.
    4431  if(block != m_BlockAllocation.m_Block)
    4432  {
    4433  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
    4434  if(IsPersistentMap())
    4435  ++mapRefCount;
    4436  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
    4437  block->Map(hAllocator, mapRefCount, VMA_NULL);
    4438  }
    4439 
    4440  m_BlockAllocation.m_Block = block;
    4441  m_BlockAllocation.m_Offset = offset;
    4442 }
    4443 
    4444 VkDeviceSize VmaAllocation_T::GetOffset() const
    4445 {
    4446  switch(m_Type)
    4447  {
    4448  case ALLOCATION_TYPE_BLOCK:
    4449  return m_BlockAllocation.m_Offset;
    4450  case ALLOCATION_TYPE_DEDICATED:
    4451  return 0;
    4452  default:
    4453  VMA_ASSERT(0);
    4454  return 0;
    4455  }
    4456 }
    4457 
    4458 VkDeviceMemory VmaAllocation_T::GetMemory() const
    4459 {
    4460  switch(m_Type)
    4461  {
    4462  case ALLOCATION_TYPE_BLOCK:
    4463  return m_BlockAllocation.m_Block->m_hMemory;
    4464  case ALLOCATION_TYPE_DEDICATED:
    4465  return m_DedicatedAllocation.m_hMemory;
    4466  default:
    4467  VMA_ASSERT(0);
    4468  return VK_NULL_HANDLE;
    4469  }
    4470 }
    4471 
    4472 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
    4473 {
    4474  switch(m_Type)
    4475  {
    4476  case ALLOCATION_TYPE_BLOCK:
    4477  return m_BlockAllocation.m_Block->m_MemoryTypeIndex;
    4478  case ALLOCATION_TYPE_DEDICATED:
    4479  return m_DedicatedAllocation.m_MemoryTypeIndex;
    4480  default:
    4481  VMA_ASSERT(0);
    4482  return UINT32_MAX;
    4483  }
    4484 }
    4485 
    4486 void* VmaAllocation_T::GetMappedData() const
    4487 {
    4488  switch(m_Type)
    4489  {
    4490  case ALLOCATION_TYPE_BLOCK:
    4491  if(m_MapCount != 0)
    4492  {
    4493  void* pBlockData = m_BlockAllocation.m_Block->m_Mapping.GetMappedData();
    4494  VMA_ASSERT(pBlockData != VMA_NULL);
    4495  return (char*)pBlockData + m_BlockAllocation.m_Offset;
    4496  }
    4497  else
    4498  {
    4499  return VMA_NULL;
    4500  }
    4501  break;
    4502  case ALLOCATION_TYPE_DEDICATED:
    4503  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
    4504  return m_DedicatedAllocation.m_pMappedData;
    4505  default:
    4506  VMA_ASSERT(0);
    4507  return VMA_NULL;
    4508  }
    4509 }
    4510 
    4511 bool VmaAllocation_T::CanBecomeLost() const
    4512 {
    4513  switch(m_Type)
    4514  {
    4515  case ALLOCATION_TYPE_BLOCK:
    4516  return m_BlockAllocation.m_CanBecomeLost;
    4517  case ALLOCATION_TYPE_DEDICATED:
    4518  return false;
    4519  default:
    4520  VMA_ASSERT(0);
    4521  return false;
    4522  }
    4523 }
    4524 
    4525 VmaPool VmaAllocation_T::GetPool() const
    4526 {
    4527  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
    4528  return m_BlockAllocation.m_hPool;
    4529 }
    4530 
    4531 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
    4532 {
    4533  VMA_ASSERT(CanBecomeLost());
    4534 
    4535  /*
    4536  Warning: This is a carefully designed algorithm.
    4537  Do not modify unless you really know what you're doing :)
    4538  */
    4539  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
    4540  for(;;)
    4541  {
    4542  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
    4543  {
    4544  VMA_ASSERT(0);
    4545  return false;
    4546  }
    4547  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
    4548  {
    4549  return false;
    4550  }
    4551  else // Last use time earlier than current time.
    4552  {
    4553  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
    4554  {
    4555  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
    4556  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
    4557  return true;
    4558  }
    4559  }
    4560  }
    4561 }
    4562 
    4563 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
    4564 {
    4565  VMA_ASSERT(IsUserDataString());
    4566  if(m_pUserData != VMA_NULL)
    4567  {
    4568  char* const oldStr = (char*)m_pUserData;
    4569  const size_t oldStrLen = strlen(oldStr);
    4570  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
    4571  m_pUserData = VMA_NULL;
    4572  }
    4573 }
    4574 
    4575 void VmaAllocation_T::BlockAllocMap()
    4576 {
    4577  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
    4578 
    4579  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
    4580  {
    4581  ++m_MapCount;
    4582  }
    4583  else
    4584  {
    4585  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
    4586  }
    4587 }
    4588 
    4589 void VmaAllocation_T::BlockAllocUnmap()
    4590 {
    4591  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
    4592 
    4593  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
    4594  {
    4595  --m_MapCount;
    4596  }
    4597  else
    4598  {
    4599  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
    4600  }
    4601 }
    4602 
    4603 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
    4604 {
    4605  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
    4606 
    4607  if(m_MapCount != 0)
    4608  {
    4609  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
    4610  {
    4611  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
    4612  *ppData = m_DedicatedAllocation.m_pMappedData;
    4613  ++m_MapCount;
    4614  return VK_SUCCESS;
    4615  }
    4616  else
    4617  {
    4618  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
    4619  return VK_ERROR_MEMORY_MAP_FAILED;
    4620  }
    4621  }
    4622  else
    4623  {
    4624  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
    4625  hAllocator->m_hDevice,
    4626  m_DedicatedAllocation.m_hMemory,
    4627  0, // offset
    4628  VK_WHOLE_SIZE,
    4629  0, // flags
    4630  ppData);
    4631  if(result == VK_SUCCESS)
    4632  {
    4633  m_DedicatedAllocation.m_pMappedData = *ppData;
    4634  m_MapCount = 1;
    4635  }
    4636  return result;
    4637  }
    4638 }
    4639 
    4640 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
    4641 {
    4642  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
    4643 
    4644  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
    4645  {
    4646  --m_MapCount;
    4647  if(m_MapCount == 0)
    4648  {
    4649  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
    4650  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
    4651  hAllocator->m_hDevice,
    4652  m_DedicatedAllocation.m_hMemory);
    4653  }
    4654  }
    4655  else
    4656  {
    4657  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
    4658  }
    4659 }
    4660 
    4661 #if VMA_STATS_STRING_ENABLED
    4662 
    4663 // Correspond to values of enum VmaSuballocationType.
    4664 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
    4665  "FREE",
    4666  "UNKNOWN",
    4667  "BUFFER",
    4668  "IMAGE_UNKNOWN",
    4669  "IMAGE_LINEAR",
    4670  "IMAGE_OPTIMAL",
    4671 };
    4672 
    4673 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
    4674 {
    4675  json.BeginObject();
    4676 
    4677  json.WriteString("Blocks");
    4678  json.WriteNumber(stat.blockCount);
    4679 
    4680  json.WriteString("Allocations");
    4681  json.WriteNumber(stat.allocationCount);
    4682 
    4683  json.WriteString("UnusedRanges");
    4684  json.WriteNumber(stat.unusedRangeCount);
    4685 
    4686  json.WriteString("UsedBytes");
    4687  json.WriteNumber(stat.usedBytes);
    4688 
    4689  json.WriteString("UnusedBytes");
    4690  json.WriteNumber(stat.unusedBytes);
    4691 
    4692  if(stat.allocationCount > 1)
    4693  {
    4694  json.WriteString("AllocationSize");
    4695  json.BeginObject(true);
    4696  json.WriteString("Min");
    4697  json.WriteNumber(stat.allocationSizeMin);
    4698  json.WriteString("Avg");
    4699  json.WriteNumber(stat.allocationSizeAvg);
    4700  json.WriteString("Max");
    4701  json.WriteNumber(stat.allocationSizeMax);
    4702  json.EndObject();
    4703  }
    4704 
    4705  if(stat.unusedRangeCount > 1)
    4706  {
    4707  json.WriteString("UnusedRangeSize");
    4708  json.BeginObject(true);
    4709  json.WriteString("Min");
    4710  json.WriteNumber(stat.unusedRangeSizeMin);
    4711  json.WriteString("Avg");
    4712  json.WriteNumber(stat.unusedRangeSizeAvg);
    4713  json.WriteString("Max");
    4714  json.WriteNumber(stat.unusedRangeSizeMax);
    4715  json.EndObject();
    4716  }
    4717 
    4718  json.EndObject();
    4719 }
    4720 
    4721 #endif // #if VMA_STATS_STRING_ENABLED
    4722 
    4723 struct VmaSuballocationItemSizeLess
    4724 {
    4725  bool operator()(
    4726  const VmaSuballocationList::iterator lhs,
    4727  const VmaSuballocationList::iterator rhs) const
    4728  {
    4729  return lhs->size < rhs->size;
    4730  }
    4731  bool operator()(
    4732  const VmaSuballocationList::iterator lhs,
    4733  VkDeviceSize rhsSize) const
    4734  {
    4735  return lhs->size < rhsSize;
    4736  }
    4737 };
    4738 
    4740 // class VmaBlockMetadata
    4741 
    4742 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
    4743  m_Size(0),
    4744  m_FreeCount(0),
    4745  m_SumFreeSize(0),
    4746  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
    4747  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
    4748 {
    4749 }
    4750 
    4751 VmaBlockMetadata::~VmaBlockMetadata()
    4752 {
    4753 }
    4754 
    4755 void VmaBlockMetadata::Init(VkDeviceSize size)
    4756 {
    4757  m_Size = size;
    4758  m_FreeCount = 1;
    4759  m_SumFreeSize = size;
    4760 
    4761  VmaSuballocation suballoc = {};
    4762  suballoc.offset = 0;
    4763  suballoc.size = size;
    4764  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    4765  suballoc.hAllocation = VK_NULL_HANDLE;
    4766 
    4767  m_Suballocations.push_back(suballoc);
    4768  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
    4769  --suballocItem;
    4770  m_FreeSuballocationsBySize.push_back(suballocItem);
    4771 }
    4772 
    4773 bool VmaBlockMetadata::Validate() const
    4774 {
    4775  if(m_Suballocations.empty())
    4776  {
    4777  return false;
    4778  }
    4779 
    4780  // Expected offset of new suballocation as calculates from previous ones.
    4781  VkDeviceSize calculatedOffset = 0;
    4782  // Expected number of free suballocations as calculated from traversing their list.
    4783  uint32_t calculatedFreeCount = 0;
    4784  // Expected sum size of free suballocations as calculated from traversing their list.
    4785  VkDeviceSize calculatedSumFreeSize = 0;
    4786  // Expected number of free suballocations that should be registered in
    4787  // m_FreeSuballocationsBySize calculated from traversing their list.
    4788  size_t freeSuballocationsToRegister = 0;
    4789  // True if previous visisted suballocation was free.
    4790  bool prevFree = false;
    4791 
    4792  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
    4793  suballocItem != m_Suballocations.cend();
    4794  ++suballocItem)
    4795  {
    4796  const VmaSuballocation& subAlloc = *suballocItem;
    4797 
    4798  // Actual offset of this suballocation doesn't match expected one.
    4799  if(subAlloc.offset != calculatedOffset)
    4800  {
    4801  return false;
    4802  }
    4803 
    4804  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
    4805  // Two adjacent free suballocations are invalid. They should be merged.
    4806  if(prevFree && currFree)
    4807  {
    4808  return false;
    4809  }
    4810 
    4811  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
    4812  {
    4813  return false;
    4814  }
    4815 
    4816  if(currFree)
    4817  {
    4818  calculatedSumFreeSize += subAlloc.size;
    4819  ++calculatedFreeCount;
    4820  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    4821  {
    4822  ++freeSuballocationsToRegister;
    4823  }
    4824  }
    4825  else
    4826  {
    4827  if(subAlloc.hAllocation->GetOffset() != subAlloc.offset)
    4828  {
    4829  return false;
    4830  }
    4831  if(subAlloc.hAllocation->GetSize() != subAlloc.size)
    4832  {
    4833  return false;
    4834  }
    4835  }
    4836 
    4837  calculatedOffset += subAlloc.size;
    4838  prevFree = currFree;
    4839  }
    4840 
    4841  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
    4842  // match expected one.
    4843  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
    4844  {
    4845  return false;
    4846  }
    4847 
    4848  VkDeviceSize lastSize = 0;
    4849  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
    4850  {
    4851  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
    4852 
    4853  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
    4854  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
    4855  {
    4856  return false;
    4857  }
    4858  // They must be sorted by size ascending.
    4859  if(suballocItem->size < lastSize)
    4860  {
    4861  return false;
    4862  }
    4863 
    4864  lastSize = suballocItem->size;
    4865  }
    4866 
    4867  // Check if totals match calculacted values.
    4868  if(!ValidateFreeSuballocationList() ||
    4869  (calculatedOffset != m_Size) ||
    4870  (calculatedSumFreeSize != m_SumFreeSize) ||
    4871  (calculatedFreeCount != m_FreeCount))
    4872  {
    4873  return false;
    4874  }
    4875 
    4876  return true;
    4877 }
    4878 
    4879 VkDeviceSize VmaBlockMetadata::GetUnusedRangeSizeMax() const
    4880 {
    4881  if(!m_FreeSuballocationsBySize.empty())
    4882  {
    4883  return m_FreeSuballocationsBySize.back()->size;
    4884  }
    4885  else
    4886  {
    4887  return 0;
    4888  }
    4889 }
    4890 
    4891 bool VmaBlockMetadata::IsEmpty() const
    4892 {
    4893  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
    4894 }
    4895 
    4896 void VmaBlockMetadata::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
    4897 {
    4898  outInfo.blockCount = 1;
    4899 
    4900  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
    4901  outInfo.allocationCount = rangeCount - m_FreeCount;
    4902  outInfo.unusedRangeCount = m_FreeCount;
    4903 
    4904  outInfo.unusedBytes = m_SumFreeSize;
    4905  outInfo.usedBytes = m_Size - outInfo.unusedBytes;
    4906 
    4907  outInfo.allocationSizeMin = UINT64_MAX;
    4908  outInfo.allocationSizeMax = 0;
    4909  outInfo.unusedRangeSizeMin = UINT64_MAX;
    4910  outInfo.unusedRangeSizeMax = 0;
    4911 
    4912  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
    4913  suballocItem != m_Suballocations.cend();
    4914  ++suballocItem)
    4915  {
    4916  const VmaSuballocation& suballoc = *suballocItem;
    4917  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
    4918  {
    4919  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
    4920  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
    4921  }
    4922  else
    4923  {
    4924  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
    4925  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
    4926  }
    4927  }
    4928 }
    4929 
    4930 void VmaBlockMetadata::AddPoolStats(VmaPoolStats& inoutStats) const
    4931 {
    4932  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
    4933 
    4934  inoutStats.size += m_Size;
    4935  inoutStats.unusedSize += m_SumFreeSize;
    4936  inoutStats.allocationCount += rangeCount - m_FreeCount;
    4937  inoutStats.unusedRangeCount += m_FreeCount;
    4938  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
    4939 }
    4940 
    4941 #if VMA_STATS_STRING_ENABLED
    4942 
    4943 void VmaBlockMetadata::PrintDetailedMap(class VmaJsonWriter& json) const
    4944 {
    4945  json.BeginObject();
    4946 
    4947  json.WriteString("TotalBytes");
    4948  json.WriteNumber(m_Size);
    4949 
    4950  json.WriteString("UnusedBytes");
    4951  json.WriteNumber(m_SumFreeSize);
    4952 
    4953  json.WriteString("Allocations");
    4954  json.WriteNumber(m_Suballocations.size() - m_FreeCount);
    4955 
    4956  json.WriteString("UnusedRanges");
    4957  json.WriteNumber(m_FreeCount);
    4958 
    4959  json.WriteString("Suballocations");
    4960  json.BeginArray();
    4961  size_t i = 0;
    4962  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
    4963  suballocItem != m_Suballocations.cend();
    4964  ++suballocItem, ++i)
    4965  {
    4966  json.BeginObject(true);
    4967 
    4968  json.WriteString("Type");
    4969  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[suballocItem->type]);
    4970 
    4971  json.WriteString("Size");
    4972  json.WriteNumber(suballocItem->size);
    4973 
    4974  json.WriteString("Offset");
    4975  json.WriteNumber(suballocItem->offset);
    4976 
    4977  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
    4978  {
    4979  const void* pUserData = suballocItem->hAllocation->GetUserData();
    4980  if(pUserData != VMA_NULL)
    4981  {
    4982  json.WriteString("UserData");
    4983  if(suballocItem->hAllocation->IsUserDataString())
    4984  {
    4985  json.WriteString((const char*)pUserData);
    4986  }
    4987  else
    4988  {
    4989  json.BeginString();
    4990  json.ContinueString_Pointer(pUserData);
    4991  json.EndString();
    4992  }
    4993  }
    4994  }
    4995 
    4996  json.EndObject();
    4997  }
    4998  json.EndArray();
    4999 
    5000  json.EndObject();
    5001 }
    5002 
    5003 #endif // #if VMA_STATS_STRING_ENABLED
    5004 
    5005 /*
    5006 How many suitable free suballocations to analyze before choosing best one.
    5007 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
    5008  be chosen.
    5009 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
    5010  suballocations will be analized and best one will be chosen.
    5011 - Any other value is also acceptable.
    5012 */
    5013 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
    5014 
    5015 void VmaBlockMetadata::CreateFirstAllocationRequest(VmaAllocationRequest* pAllocationRequest)
    5016 {
    5017  VMA_ASSERT(IsEmpty());
    5018  pAllocationRequest->offset = 0;
    5019  pAllocationRequest->sumFreeSize = m_SumFreeSize;
    5020  pAllocationRequest->sumItemSize = 0;
    5021  pAllocationRequest->item = m_Suballocations.begin();
    5022  pAllocationRequest->itemsToMakeLostCount = 0;
    5023 }
    5024 
    5025 bool VmaBlockMetadata::CreateAllocationRequest(
    5026  uint32_t currentFrameIndex,
    5027  uint32_t frameInUseCount,
    5028  VkDeviceSize bufferImageGranularity,
    5029  VkDeviceSize allocSize,
    5030  VkDeviceSize allocAlignment,
    5031  VmaSuballocationType allocType,
    5032  bool canMakeOtherLost,
    5033  VmaAllocationRequest* pAllocationRequest)
    5034 {
    5035  VMA_ASSERT(allocSize > 0);
    5036  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    5037  VMA_ASSERT(pAllocationRequest != VMA_NULL);
    5038  VMA_HEAVY_ASSERT(Validate());
    5039 
    5040  // There is not enough total free space in this block to fullfill the request: Early return.
    5041  if(canMakeOtherLost == false && m_SumFreeSize < allocSize)
    5042  {
    5043  return false;
    5044  }
    5045 
    5046  // New algorithm, efficiently searching freeSuballocationsBySize.
    5047  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
    5048  if(freeSuballocCount > 0)
    5049  {
    5050  if(VMA_BEST_FIT)
    5051  {
    5052  // Find first free suballocation with size not less than allocSize.
    5053  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
    5054  m_FreeSuballocationsBySize.data(),
    5055  m_FreeSuballocationsBySize.data() + freeSuballocCount,
    5056  allocSize,
    5057  VmaSuballocationItemSizeLess());
    5058  size_t index = it - m_FreeSuballocationsBySize.data();
    5059  for(; index < freeSuballocCount; ++index)
    5060  {
    5061  if(CheckAllocation(
    5062  currentFrameIndex,
    5063  frameInUseCount,
    5064  bufferImageGranularity,
    5065  allocSize,
    5066  allocAlignment,
    5067  allocType,
    5068  m_FreeSuballocationsBySize[index],
    5069  false, // canMakeOtherLost
    5070  &pAllocationRequest->offset,
    5071  &pAllocationRequest->itemsToMakeLostCount,
    5072  &pAllocationRequest->sumFreeSize,
    5073  &pAllocationRequest->sumItemSize))
    5074  {
    5075  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
    5076  return true;
    5077  }
    5078  }
    5079  }
    5080  else
    5081  {
    5082  // Search staring from biggest suballocations.
    5083  for(size_t index = freeSuballocCount; index--; )
    5084  {
    5085  if(CheckAllocation(
    5086  currentFrameIndex,
    5087  frameInUseCount,
    5088  bufferImageGranularity,
    5089  allocSize,
    5090  allocAlignment,
    5091  allocType,
    5092  m_FreeSuballocationsBySize[index],
    5093  false, // canMakeOtherLost
    5094  &pAllocationRequest->offset,
    5095  &pAllocationRequest->itemsToMakeLostCount,
    5096  &pAllocationRequest->sumFreeSize,
    5097  &pAllocationRequest->sumItemSize))
    5098  {
    5099  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
    5100  return true;
    5101  }
    5102  }
    5103  }
    5104  }
    5105 
    5106  if(canMakeOtherLost)
    5107  {
    5108  // Brute-force algorithm. TODO: Come up with something better.
    5109 
    5110  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
    5111  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
    5112 
    5113  VmaAllocationRequest tmpAllocRequest = {};
    5114  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
    5115  suballocIt != m_Suballocations.end();
    5116  ++suballocIt)
    5117  {
    5118  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
    5119  suballocIt->hAllocation->CanBecomeLost())
    5120  {
    5121  if(CheckAllocation(
    5122  currentFrameIndex,
    5123  frameInUseCount,
    5124  bufferImageGranularity,
    5125  allocSize,
    5126  allocAlignment,
    5127  allocType,
    5128  suballocIt,
    5129  canMakeOtherLost,
    5130  &tmpAllocRequest.offset,
    5131  &tmpAllocRequest.itemsToMakeLostCount,
    5132  &tmpAllocRequest.sumFreeSize,
    5133  &tmpAllocRequest.sumItemSize))
    5134  {
    5135  tmpAllocRequest.item = suballocIt;
    5136 
    5137  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
    5138  {
    5139  *pAllocationRequest = tmpAllocRequest;
    5140  }
    5141  }
    5142  }
    5143  }
    5144 
    5145  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
    5146  {
    5147  return true;
    5148  }
    5149  }
    5150 
    5151  return false;
    5152 }
    5153 
    5154 bool VmaBlockMetadata::MakeRequestedAllocationsLost(
    5155  uint32_t currentFrameIndex,
    5156  uint32_t frameInUseCount,
    5157  VmaAllocationRequest* pAllocationRequest)
    5158 {
    5159  while(pAllocationRequest->itemsToMakeLostCount > 0)
    5160  {
    5161  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
    5162  {
    5163  ++pAllocationRequest->item;
    5164  }
    5165  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
    5166  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
    5167  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
    5168  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
    5169  {
    5170  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
    5171  --pAllocationRequest->itemsToMakeLostCount;
    5172  }
    5173  else
    5174  {
    5175  return false;
    5176  }
    5177  }
    5178 
    5179  VMA_HEAVY_ASSERT(Validate());
    5180  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
    5181  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5182 
    5183  return true;
    5184 }
    5185 
    5186 uint32_t VmaBlockMetadata::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
    5187 {
    5188  uint32_t lostAllocationCount = 0;
    5189  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
    5190  it != m_Suballocations.end();
    5191  ++it)
    5192  {
    5193  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
    5194  it->hAllocation->CanBecomeLost() &&
    5195  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
    5196  {
    5197  it = FreeSuballocation(it);
    5198  ++lostAllocationCount;
    5199  }
    5200  }
    5201  return lostAllocationCount;
    5202 }
    5203 
    5204 void VmaBlockMetadata::Alloc(
    5205  const VmaAllocationRequest& request,
    5206  VmaSuballocationType type,
    5207  VkDeviceSize allocSize,
    5208  VmaAllocation hAllocation)
    5209 {
    5210  VMA_ASSERT(request.item != m_Suballocations.end());
    5211  VmaSuballocation& suballoc = *request.item;
    5212  // Given suballocation is a free block.
    5213  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
    5214  // Given offset is inside this suballocation.
    5215  VMA_ASSERT(request.offset >= suballoc.offset);
    5216  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
    5217  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
    5218  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
    5219 
    5220  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
    5221  // it to become used.
    5222  UnregisterFreeSuballocation(request.item);
    5223 
    5224  suballoc.offset = request.offset;
    5225  suballoc.size = allocSize;
    5226  suballoc.type = type;
    5227  suballoc.hAllocation = hAllocation;
    5228 
    5229  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
    5230  if(paddingEnd)
    5231  {
    5232  VmaSuballocation paddingSuballoc = {};
    5233  paddingSuballoc.offset = request.offset + allocSize;
    5234  paddingSuballoc.size = paddingEnd;
    5235  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    5236  VmaSuballocationList::iterator next = request.item;
    5237  ++next;
    5238  const VmaSuballocationList::iterator paddingEndItem =
    5239  m_Suballocations.insert(next, paddingSuballoc);
    5240  RegisterFreeSuballocation(paddingEndItem);
    5241  }
    5242 
    5243  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
    5244  if(paddingBegin)
    5245  {
    5246  VmaSuballocation paddingSuballoc = {};
    5247  paddingSuballoc.offset = request.offset - paddingBegin;
    5248  paddingSuballoc.size = paddingBegin;
    5249  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    5250  const VmaSuballocationList::iterator paddingBeginItem =
    5251  m_Suballocations.insert(request.item, paddingSuballoc);
    5252  RegisterFreeSuballocation(paddingBeginItem);
    5253  }
    5254 
    5255  // Update totals.
    5256  m_FreeCount = m_FreeCount - 1;
    5257  if(paddingBegin > 0)
    5258  {
    5259  ++m_FreeCount;
    5260  }
    5261  if(paddingEnd > 0)
    5262  {
    5263  ++m_FreeCount;
    5264  }
    5265  m_SumFreeSize -= allocSize;
    5266 }
    5267 
    5268 void VmaBlockMetadata::Free(const VmaAllocation allocation)
    5269 {
    5270  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
    5271  suballocItem != m_Suballocations.end();
    5272  ++suballocItem)
    5273  {
    5274  VmaSuballocation& suballoc = *suballocItem;
    5275  if(suballoc.hAllocation == allocation)
    5276  {
    5277  FreeSuballocation(suballocItem);
    5278  VMA_HEAVY_ASSERT(Validate());
    5279  return;
    5280  }
    5281  }
    5282  VMA_ASSERT(0 && "Not found!");
    5283 }
    5284 
    5285 void VmaBlockMetadata::FreeAtOffset(VkDeviceSize offset)
    5286 {
    5287  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
    5288  suballocItem != m_Suballocations.end();
    5289  ++suballocItem)
    5290  {
    5291  VmaSuballocation& suballoc = *suballocItem;
    5292  if(suballoc.offset == offset)
    5293  {
    5294  FreeSuballocation(suballocItem);
    5295  return;
    5296  }
    5297  }
    5298  VMA_ASSERT(0 && "Not found!");
    5299 }
    5300 
    5301 bool VmaBlockMetadata::ValidateFreeSuballocationList() const
    5302 {
    5303  VkDeviceSize lastSize = 0;
    5304  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
    5305  {
    5306  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
    5307 
    5308  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
    5309  {
    5310  VMA_ASSERT(0);
    5311  return false;
    5312  }
    5313  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    5314  {
    5315  VMA_ASSERT(0);
    5316  return false;
    5317  }
    5318  if(it->size < lastSize)
    5319  {
    5320  VMA_ASSERT(0);
    5321  return false;
    5322  }
    5323 
    5324  lastSize = it->size;
    5325  }
    5326  return true;
    5327 }
    5328 
    5329 bool VmaBlockMetadata::CheckAllocation(
    5330  uint32_t currentFrameIndex,
    5331  uint32_t frameInUseCount,
    5332  VkDeviceSize bufferImageGranularity,
    5333  VkDeviceSize allocSize,
    5334  VkDeviceSize allocAlignment,
    5335  VmaSuballocationType allocType,
    5336  VmaSuballocationList::const_iterator suballocItem,
    5337  bool canMakeOtherLost,
    5338  VkDeviceSize* pOffset,
    5339  size_t* itemsToMakeLostCount,
    5340  VkDeviceSize* pSumFreeSize,
    5341  VkDeviceSize* pSumItemSize) const
    5342 {
    5343  VMA_ASSERT(allocSize > 0);
    5344  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
    5345  VMA_ASSERT(suballocItem != m_Suballocations.cend());
    5346  VMA_ASSERT(pOffset != VMA_NULL);
    5347 
    5348  *itemsToMakeLostCount = 0;
    5349  *pSumFreeSize = 0;
    5350  *pSumItemSize = 0;
    5351 
    5352  if(canMakeOtherLost)
    5353  {
    5354  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
    5355  {
    5356  *pSumFreeSize = suballocItem->size;
    5357  }
    5358  else
    5359  {
    5360  if(suballocItem->hAllocation->CanBecomeLost() &&
    5361  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
    5362  {
    5363  ++*itemsToMakeLostCount;
    5364  *pSumItemSize = suballocItem->size;
    5365  }
    5366  else
    5367  {
    5368  return false;
    5369  }
    5370  }
    5371 
    5372  // Remaining size is too small for this request: Early return.
    5373  if(m_Size - suballocItem->offset < allocSize)
    5374  {
    5375  return false;
    5376  }
    5377 
    5378  // Start from offset equal to beginning of this suballocation.
    5379  *pOffset = suballocItem->offset;
    5380 
    5381  // Apply VMA_DEBUG_MARGIN at the beginning.
    5382  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
    5383  {
    5384  *pOffset += VMA_DEBUG_MARGIN;
    5385  }
    5386 
    5387  // Apply alignment.
    5388  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
    5389  *pOffset = VmaAlignUp(*pOffset, alignment);
    5390 
    5391  // Check previous suballocations for BufferImageGranularity conflicts.
    5392  // Make bigger alignment if necessary.
    5393  if(bufferImageGranularity > 1)
    5394  {
    5395  bool bufferImageGranularityConflict = false;
    5396  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
    5397  while(prevSuballocItem != m_Suballocations.cbegin())
    5398  {
    5399  --prevSuballocItem;
    5400  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
    5401  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
    5402  {
    5403  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
    5404  {
    5405  bufferImageGranularityConflict = true;
    5406  break;
    5407  }
    5408  }
    5409  else
    5410  // Already on previous page.
    5411  break;
    5412  }
    5413  if(bufferImageGranularityConflict)
    5414  {
    5415  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
    5416  }
    5417  }
    5418 
    5419  // Now that we have final *pOffset, check if we are past suballocItem.
    5420  // If yes, return false - this function should be called for another suballocItem as starting point.
    5421  if(*pOffset >= suballocItem->offset + suballocItem->size)
    5422  {
    5423  return false;
    5424  }
    5425 
    5426  // Calculate padding at the beginning based on current offset.
    5427  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
    5428 
    5429  // Calculate required margin at the end if this is not last suballocation.
    5430  VmaSuballocationList::const_iterator next = suballocItem;
    5431  ++next;
    5432  const VkDeviceSize requiredEndMargin =
    5433  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
    5434 
    5435  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
    5436  // Another early return check.
    5437  if(suballocItem->offset + totalSize > m_Size)
    5438  {
    5439  return false;
    5440  }
    5441 
    5442  // Advance lastSuballocItem until desired size is reached.
    5443  // Update itemsToMakeLostCount.
    5444  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
    5445  if(totalSize > suballocItem->size)
    5446  {
    5447  VkDeviceSize remainingSize = totalSize - suballocItem->size;
    5448  while(remainingSize > 0)
    5449  {
    5450  ++lastSuballocItem;
    5451  if(lastSuballocItem == m_Suballocations.cend())
    5452  {
    5453  return false;
    5454  }
    5455  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
    5456  {
    5457  *pSumFreeSize += lastSuballocItem->size;
    5458  }
    5459  else
    5460  {
    5461  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
    5462  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
    5463  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
    5464  {
    5465  ++*itemsToMakeLostCount;
    5466  *pSumItemSize += lastSuballocItem->size;
    5467  }
    5468  else
    5469  {
    5470  return false;
    5471  }
    5472  }
    5473  remainingSize = (lastSuballocItem->size < remainingSize) ?
    5474  remainingSize - lastSuballocItem->size : 0;
    5475  }
    5476  }
    5477 
    5478  // Check next suballocations for BufferImageGranularity conflicts.
    5479  // If conflict exists, we must mark more allocations lost or fail.
    5480  if(bufferImageGranularity > 1)
    5481  {
    5482  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
    5483  ++nextSuballocItem;
    5484  while(nextSuballocItem != m_Suballocations.cend())
    5485  {
    5486  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
    5487  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
    5488  {
    5489  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
    5490  {
    5491  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
    5492  if(nextSuballoc.hAllocation->CanBecomeLost() &&
    5493  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
    5494  {
    5495  ++*itemsToMakeLostCount;
    5496  }
    5497  else
    5498  {
    5499  return false;
    5500  }
    5501  }
    5502  }
    5503  else
    5504  {
    5505  // Already on next page.
    5506  break;
    5507  }
    5508  ++nextSuballocItem;
    5509  }
    5510  }
    5511  }
    5512  else
    5513  {
    5514  const VmaSuballocation& suballoc = *suballocItem;
    5515  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
    5516 
    5517  *pSumFreeSize = suballoc.size;
    5518 
    5519  // Size of this suballocation is too small for this request: Early return.
    5520  if(suballoc.size < allocSize)
    5521  {
    5522  return false;
    5523  }
    5524 
    5525  // Start from offset equal to beginning of this suballocation.
    5526  *pOffset = suballoc.offset;
    5527 
    5528  // Apply VMA_DEBUG_MARGIN at the beginning.
    5529  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
    5530  {
    5531  *pOffset += VMA_DEBUG_MARGIN;
    5532  }
    5533 
    5534  // Apply alignment.
    5535  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
    5536  *pOffset = VmaAlignUp(*pOffset, alignment);
    5537 
    5538  // Check previous suballocations for BufferImageGranularity conflicts.
    5539  // Make bigger alignment if necessary.
    5540  if(bufferImageGranularity > 1)
    5541  {
    5542  bool bufferImageGranularityConflict = false;
    5543  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
    5544  while(prevSuballocItem != m_Suballocations.cbegin())
    5545  {
    5546  --prevSuballocItem;
    5547  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
    5548  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
    5549  {
    5550  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
    5551  {
    5552  bufferImageGranularityConflict = true;
    5553  break;
    5554  }
    5555  }
    5556  else
    5557  // Already on previous page.
    5558  break;
    5559  }
    5560  if(bufferImageGranularityConflict)
    5561  {
    5562  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
    5563  }
    5564  }
    5565 
    5566  // Calculate padding at the beginning based on current offset.
    5567  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
    5568 
    5569  // Calculate required margin at the end if this is not last suballocation.
    5570  VmaSuballocationList::const_iterator next = suballocItem;
    5571  ++next;
    5572  const VkDeviceSize requiredEndMargin =
    5573  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
    5574 
    5575  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
    5576  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
    5577  {
    5578  return false;
    5579  }
    5580 
    5581  // Check next suballocations for BufferImageGranularity conflicts.
    5582  // If conflict exists, allocation cannot be made here.
    5583  if(bufferImageGranularity > 1)
    5584  {
    5585  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
    5586  ++nextSuballocItem;
    5587  while(nextSuballocItem != m_Suballocations.cend())
    5588  {
    5589  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
    5590  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
    5591  {
    5592  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
    5593  {
    5594  return false;
    5595  }
    5596  }
    5597  else
    5598  {
    5599  // Already on next page.
    5600  break;
    5601  }
    5602  ++nextSuballocItem;
    5603  }
    5604  }
    5605  }
    5606 
    5607  // All tests passed: Success. pOffset is already filled.
    5608  return true;
    5609 }
    5610 
    5611 void VmaBlockMetadata::MergeFreeWithNext(VmaSuballocationList::iterator item)
    5612 {
    5613  VMA_ASSERT(item != m_Suballocations.end());
    5614  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5615 
    5616  VmaSuballocationList::iterator nextItem = item;
    5617  ++nextItem;
    5618  VMA_ASSERT(nextItem != m_Suballocations.end());
    5619  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
    5620 
    5621  item->size += nextItem->size;
    5622  --m_FreeCount;
    5623  m_Suballocations.erase(nextItem);
    5624 }
    5625 
    5626 VmaSuballocationList::iterator VmaBlockMetadata::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
    5627 {
    5628  // Change this suballocation to be marked as free.
    5629  VmaSuballocation& suballoc = *suballocItem;
    5630  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
    5631  suballoc.hAllocation = VK_NULL_HANDLE;
    5632 
    5633  // Update totals.
    5634  ++m_FreeCount;
    5635  m_SumFreeSize += suballoc.size;
    5636 
    5637  // Merge with previous and/or next suballocation if it's also free.
    5638  bool mergeWithNext = false;
    5639  bool mergeWithPrev = false;
    5640 
    5641  VmaSuballocationList::iterator nextItem = suballocItem;
    5642  ++nextItem;
    5643  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
    5644  {
    5645  mergeWithNext = true;
    5646  }
    5647 
    5648  VmaSuballocationList::iterator prevItem = suballocItem;
    5649  if(suballocItem != m_Suballocations.begin())
    5650  {
    5651  --prevItem;
    5652  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
    5653  {
    5654  mergeWithPrev = true;
    5655  }
    5656  }
    5657 
    5658  if(mergeWithNext)
    5659  {
    5660  UnregisterFreeSuballocation(nextItem);
    5661  MergeFreeWithNext(suballocItem);
    5662  }
    5663 
    5664  if(mergeWithPrev)
    5665  {
    5666  UnregisterFreeSuballocation(prevItem);
    5667  MergeFreeWithNext(prevItem);
    5668  RegisterFreeSuballocation(prevItem);
    5669  return prevItem;
    5670  }
    5671  else
    5672  {
    5673  RegisterFreeSuballocation(suballocItem);
    5674  return suballocItem;
    5675  }
    5676 }
    5677 
    5678 void VmaBlockMetadata::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
    5679 {
    5680  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5681  VMA_ASSERT(item->size > 0);
    5682 
    5683  // You may want to enable this validation at the beginning or at the end of
    5684  // this function, depending on what do you want to check.
    5685  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5686 
    5687  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    5688  {
    5689  if(m_FreeSuballocationsBySize.empty())
    5690  {
    5691  m_FreeSuballocationsBySize.push_back(item);
    5692  }
    5693  else
    5694  {
    5695  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
    5696  }
    5697  }
    5698 
    5699  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5700 }
    5701 
    5702 
    5703 void VmaBlockMetadata::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
    5704 {
    5705  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
    5706  VMA_ASSERT(item->size > 0);
    5707 
    5708  // You may want to enable this validation at the beginning or at the end of
    5709  // this function, depending on what do you want to check.
    5710  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5711 
    5712  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
    5713  {
    5714  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
    5715  m_FreeSuballocationsBySize.data(),
    5716  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
    5717  item,
    5718  VmaSuballocationItemSizeLess());
    5719  for(size_t index = it - m_FreeSuballocationsBySize.data();
    5720  index < m_FreeSuballocationsBySize.size();
    5721  ++index)
    5722  {
    5723  if(m_FreeSuballocationsBySize[index] == item)
    5724  {
    5725  VmaVectorRemove(m_FreeSuballocationsBySize, index);
    5726  return;
    5727  }
    5728  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
    5729  }
    5730  VMA_ASSERT(0 && "Not found.");
    5731  }
    5732 
    5733  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
    5734 }
    5735 
    5737 // class VmaDeviceMemoryMapping
    5738 
    5739 VmaDeviceMemoryMapping::VmaDeviceMemoryMapping() :
    5740  m_MapCount(0),
    5741  m_pMappedData(VMA_NULL)
    5742 {
    5743 }
    5744 
    5745 VmaDeviceMemoryMapping::~VmaDeviceMemoryMapping()
    5746 {
    5747  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
    5748 }
    5749 
    5750 VkResult VmaDeviceMemoryMapping::Map(VmaAllocator hAllocator, VkDeviceMemory hMemory, uint32_t count, void **ppData)
    5751 {
    5752  if(count == 0)
    5753  {
    5754  return VK_SUCCESS;
    5755  }
    5756 
    5757  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
    5758  if(m_MapCount != 0)
    5759  {
    5760  m_MapCount += count;
    5761  VMA_ASSERT(m_pMappedData != VMA_NULL);
    5762  if(ppData != VMA_NULL)
    5763  {
    5764  *ppData = m_pMappedData;
    5765  }
    5766  return VK_SUCCESS;
    5767  }
    5768  else
    5769  {
    5770  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
    5771  hAllocator->m_hDevice,
    5772  hMemory,
    5773  0, // offset
    5774  VK_WHOLE_SIZE,
    5775  0, // flags
    5776  &m_pMappedData);
    5777  if(result == VK_SUCCESS)
    5778  {
    5779  if(ppData != VMA_NULL)
    5780  {
    5781  *ppData = m_pMappedData;
    5782  }
    5783  m_MapCount = count;
    5784  }
    5785  return result;
    5786  }
    5787 }
    5788 
    5789 void VmaDeviceMemoryMapping::Unmap(VmaAllocator hAllocator, VkDeviceMemory hMemory, uint32_t count)
    5790 {
    5791  if(count == 0)
    5792  {
    5793  return;
    5794  }
    5795 
    5796  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
    5797  if(m_MapCount >= count)
    5798  {
    5799  m_MapCount -= count;
    5800  if(m_MapCount == 0)
    5801  {
    5802  m_pMappedData = VMA_NULL;
    5803  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, hMemory);
    5804  }
    5805  }
    5806  else
    5807  {
    5808  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
    5809  }
    5810 }
    5811 
    5813 // class VmaDeviceMemoryBlock
    5814 
    5815 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
    5816  m_MemoryTypeIndex(UINT32_MAX),
    5817  m_hMemory(VK_NULL_HANDLE),
    5818  m_Metadata(hAllocator)
    5819 {
    5820 }
    5821 
    5822 void VmaDeviceMemoryBlock::Init(
    5823  uint32_t newMemoryTypeIndex,
    5824  VkDeviceMemory newMemory,
    5825  VkDeviceSize newSize)
    5826 {
    5827  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
    5828 
    5829  m_MemoryTypeIndex = newMemoryTypeIndex;
    5830  m_hMemory = newMemory;
    5831 
    5832  m_Metadata.Init(newSize);
    5833 }
    5834 
    5835 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
    5836 {
    5837  // This is the most important assert in the entire library.
    5838  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
    5839  VMA_ASSERT(m_Metadata.IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
    5840 
    5841  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
    5842  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Metadata.GetSize(), m_hMemory);
    5843  m_hMemory = VK_NULL_HANDLE;
    5844 }
    5845 
    5846 bool VmaDeviceMemoryBlock::Validate() const
    5847 {
    5848  if((m_hMemory == VK_NULL_HANDLE) ||
    5849  (m_Metadata.GetSize() == 0))
    5850  {
    5851  return false;
    5852  }
    5853 
    5854  return m_Metadata.Validate();
    5855 }
    5856 
    5857 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
    5858 {
    5859  return m_Mapping.Map(hAllocator, m_hMemory, count, ppData);
    5860 }
    5861 
    5862 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
    5863 {
    5864  m_Mapping.Unmap(hAllocator, m_hMemory, count);
    5865 }
    5866 
    5867 static void InitStatInfo(VmaStatInfo& outInfo)
    5868 {
    5869  memset(&outInfo, 0, sizeof(outInfo));
    5870  outInfo.allocationSizeMin = UINT64_MAX;
    5871  outInfo.unusedRangeSizeMin = UINT64_MAX;
    5872 }
    5873 
    5874 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
    5875 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
    5876 {
    5877  inoutInfo.blockCount += srcInfo.blockCount;
    5878  inoutInfo.allocationCount += srcInfo.allocationCount;
    5879  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
    5880  inoutInfo.usedBytes += srcInfo.usedBytes;
    5881  inoutInfo.unusedBytes += srcInfo.unusedBytes;
    5882  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
    5883  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
    5884  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
    5885  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
    5886 }
    5887 
    5888 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
    5889 {
    5890  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
    5891  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
    5892  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
    5893  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
    5894 }
    5895 
    5896 VmaPool_T::VmaPool_T(
    5897  VmaAllocator hAllocator,
    5898  const VmaPoolCreateInfo& createInfo) :
    5899  m_BlockVector(
    5900  hAllocator,
    5901  createInfo.memoryTypeIndex,
    5902  createInfo.blockSize,
    5903  createInfo.minBlockCount,
    5904  createInfo.maxBlockCount,
    5905  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
    5906  createInfo.frameInUseCount,
    5907  true) // isCustomPool
    5908 {
    5909 }
    5910 
    5911 VmaPool_T::~VmaPool_T()
    5912 {
    5913 }
    5914 
    5915 #if VMA_STATS_STRING_ENABLED
    5916 
    5917 #endif // #if VMA_STATS_STRING_ENABLED
    5918 
    5919 VmaBlockVector::VmaBlockVector(
    5920  VmaAllocator hAllocator,
    5921  uint32_t memoryTypeIndex,
    5922  VkDeviceSize preferredBlockSize,
    5923  size_t minBlockCount,
    5924  size_t maxBlockCount,
    5925  VkDeviceSize bufferImageGranularity,
    5926  uint32_t frameInUseCount,
    5927  bool isCustomPool) :
    5928  m_hAllocator(hAllocator),
    5929  m_MemoryTypeIndex(memoryTypeIndex),
    5930  m_PreferredBlockSize(preferredBlockSize),
    5931  m_MinBlockCount(minBlockCount),
    5932  m_MaxBlockCount(maxBlockCount),
    5933  m_BufferImageGranularity(bufferImageGranularity),
    5934  m_FrameInUseCount(frameInUseCount),
    5935  m_IsCustomPool(isCustomPool),
    5936  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
    5937  m_HasEmptyBlock(false),
    5938  m_pDefragmentator(VMA_NULL)
    5939 {
    5940 }
    5941 
    5942 VmaBlockVector::~VmaBlockVector()
    5943 {
    5944  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
    5945 
    5946  for(size_t i = m_Blocks.size(); i--; )
    5947  {
    5948  m_Blocks[i]->Destroy(m_hAllocator);
    5949  vma_delete(m_hAllocator, m_Blocks[i]);
    5950  }
    5951 }
    5952 
    5953 VkResult VmaBlockVector::CreateMinBlocks()
    5954 {
    5955  for(size_t i = 0; i < m_MinBlockCount; ++i)
    5956  {
    5957  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
    5958  if(res != VK_SUCCESS)
    5959  {
    5960  return res;
    5961  }
    5962  }
    5963  return VK_SUCCESS;
    5964 }
    5965 
    5966 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
    5967 {
    5968  pStats->size = 0;
    5969  pStats->unusedSize = 0;
    5970  pStats->allocationCount = 0;
    5971  pStats->unusedRangeCount = 0;
    5972  pStats->unusedRangeSizeMax = 0;
    5973 
    5974  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    5975 
    5976  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    5977  {
    5978  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
    5979  VMA_ASSERT(pBlock);
    5980  VMA_HEAVY_ASSERT(pBlock->Validate());
    5981  pBlock->m_Metadata.AddPoolStats(*pStats);
    5982  }
    5983 }
    5984 
    5985 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
    5986 
    5987 VkResult VmaBlockVector::Allocate(
    5988  VmaPool hCurrentPool,
    5989  uint32_t currentFrameIndex,
    5990  const VkMemoryRequirements& vkMemReq,
    5991  const VmaAllocationCreateInfo& createInfo,
    5992  VmaSuballocationType suballocType,
    5993  VmaAllocation* pAllocation)
    5994 {
    5995  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
    5996  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
    5997 
    5998  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    5999 
    6000  // 1. Search existing allocations. Try to allocate without making other allocations lost.
    6001  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
    6002  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
    6003  {
    6004  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
    6005  VMA_ASSERT(pCurrBlock);
    6006  VmaAllocationRequest currRequest = {};
    6007  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
    6008  currentFrameIndex,
    6009  m_FrameInUseCount,
    6010  m_BufferImageGranularity,
    6011  vkMemReq.size,
    6012  vkMemReq.alignment,
    6013  suballocType,
    6014  false, // canMakeOtherLost
    6015  &currRequest))
    6016  {
    6017  // Allocate from pCurrBlock.
    6018  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
    6019 
    6020  if(mapped)
    6021  {
    6022  VkResult res = pCurrBlock->Map(m_hAllocator, 1, VMA_NULL);
    6023  if(res != VK_SUCCESS)
    6024  {
    6025  return res;
    6026  }
    6027  }
    6028 
    6029  // We no longer have an empty Allocation.
    6030  if(pCurrBlock->m_Metadata.IsEmpty())
    6031  {
    6032  m_HasEmptyBlock = false;
    6033  }
    6034 
    6035  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
    6036  pCurrBlock->m_Metadata.Alloc(currRequest, suballocType, vkMemReq.size, *pAllocation);
    6037  (*pAllocation)->InitBlockAllocation(
    6038  hCurrentPool,
    6039  pCurrBlock,
    6040  currRequest.offset,
    6041  vkMemReq.alignment,
    6042  vkMemReq.size,
    6043  suballocType,
    6044  mapped,
    6045  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
    6046  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
    6047  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
    6048  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
    6049  return VK_SUCCESS;
    6050  }
    6051  }
    6052 
    6053  const bool canCreateNewBlock =
    6054  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
    6055  (m_Blocks.size() < m_MaxBlockCount);
    6056 
    6057  // 2. Try to create new block.
    6058  if(canCreateNewBlock)
    6059  {
    6060  // Calculate optimal size for new block.
    6061  VkDeviceSize newBlockSize = m_PreferredBlockSize;
    6062  uint32_t newBlockSizeShift = 0;
    6063  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
    6064 
    6065  // Allocating blocks of other sizes is allowed only in default pools.
    6066  // In custom pools block size is fixed.
    6067  if(m_IsCustomPool == false)
    6068  {
    6069  // Allocate 1/8, 1/4, 1/2 as first blocks.
    6070  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
    6071  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
    6072  {
    6073  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
    6074  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= vkMemReq.size * 2)
    6075  {
    6076  newBlockSize = smallerNewBlockSize;
    6077  ++newBlockSizeShift;
    6078  }
    6079  else
    6080  {
    6081  break;
    6082  }
    6083  }
    6084  }
    6085 
    6086  size_t newBlockIndex = 0;
    6087  VkResult res = CreateBlock(newBlockSize, &newBlockIndex);
    6088  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
    6089  if(m_IsCustomPool == false)
    6090  {
    6091  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
    6092  {
    6093  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
    6094  if(smallerNewBlockSize >= vkMemReq.size)
    6095  {
    6096  newBlockSize = smallerNewBlockSize;
    6097  ++newBlockSizeShift;
    6098  res = CreateBlock(newBlockSize, &newBlockIndex);
    6099  }
    6100  else
    6101  {
    6102  break;
    6103  }
    6104  }
    6105  }
    6106 
    6107  if(res == VK_SUCCESS)
    6108  {
    6109  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
    6110  VMA_ASSERT(pBlock->m_Metadata.GetSize() >= vkMemReq.size);
    6111 
    6112  if(mapped)
    6113  {
    6114  res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
    6115  if(res != VK_SUCCESS)
    6116  {
    6117  return res;
    6118  }
    6119  }
    6120 
    6121  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
    6122  VmaAllocationRequest allocRequest;
    6123  pBlock->m_Metadata.CreateFirstAllocationRequest(&allocRequest);
    6124  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
    6125  pBlock->m_Metadata.Alloc(allocRequest, suballocType, vkMemReq.size, *pAllocation);
    6126  (*pAllocation)->InitBlockAllocation(
    6127  hCurrentPool,
    6128  pBlock,
    6129  allocRequest.offset,
    6130  vkMemReq.alignment,
    6131  vkMemReq.size,
    6132  suballocType,
    6133  mapped,
    6134  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
    6135  VMA_HEAVY_ASSERT(pBlock->Validate());
    6136  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
    6137  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
    6138  return VK_SUCCESS;
    6139  }
    6140  }
    6141 
    6142  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
    6143 
    6144  // 3. Try to allocate from existing blocks with making other allocations lost.
    6145  if(canMakeOtherLost)
    6146  {
    6147  uint32_t tryIndex = 0;
    6148  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
    6149  {
    6150  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
    6151  VmaAllocationRequest bestRequest = {};
    6152  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
    6153 
    6154  // 1. Search existing allocations.
    6155  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
    6156  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
    6157  {
    6158  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
    6159  VMA_ASSERT(pCurrBlock);
    6160  VmaAllocationRequest currRequest = {};
    6161  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
    6162  currentFrameIndex,
    6163  m_FrameInUseCount,
    6164  m_BufferImageGranularity,
    6165  vkMemReq.size,
    6166  vkMemReq.alignment,
    6167  suballocType,
    6168  canMakeOtherLost,
    6169  &currRequest))
    6170  {
    6171  const VkDeviceSize currRequestCost = currRequest.CalcCost();
    6172  if(pBestRequestBlock == VMA_NULL ||
    6173  currRequestCost < bestRequestCost)
    6174  {
    6175  pBestRequestBlock = pCurrBlock;
    6176  bestRequest = currRequest;
    6177  bestRequestCost = currRequestCost;
    6178 
    6179  if(bestRequestCost == 0)
    6180  {
    6181  break;
    6182  }
    6183  }
    6184  }
    6185  }
    6186 
    6187  if(pBestRequestBlock != VMA_NULL)
    6188  {
    6189  if(mapped)
    6190  {
    6191  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
    6192  if(res != VK_SUCCESS)
    6193  {
    6194  return res;
    6195  }
    6196  }
    6197 
    6198  if(pBestRequestBlock->m_Metadata.MakeRequestedAllocationsLost(
    6199  currentFrameIndex,
    6200  m_FrameInUseCount,
    6201  &bestRequest))
    6202  {
    6203  // We no longer have an empty Allocation.
    6204  if(pBestRequestBlock->m_Metadata.IsEmpty())
    6205  {
    6206  m_HasEmptyBlock = false;
    6207  }
    6208  // Allocate from this pBlock.
    6209  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
    6210  pBestRequestBlock->m_Metadata.Alloc(bestRequest, suballocType, vkMemReq.size, *pAllocation);
    6211  (*pAllocation)->InitBlockAllocation(
    6212  hCurrentPool,
    6213  pBestRequestBlock,
    6214  bestRequest.offset,
    6215  vkMemReq.alignment,
    6216  vkMemReq.size,
    6217  suballocType,
    6218  mapped,
    6219  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
    6220  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
    6221  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
    6222  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
    6223  return VK_SUCCESS;
    6224  }
    6225  // else: Some allocations must have been touched while we are here. Next try.
    6226  }
    6227  else
    6228  {
    6229  // Could not find place in any of the blocks - break outer loop.
    6230  break;
    6231  }
    6232  }
    6233  /* Maximum number of tries exceeded - a very unlike event when many other
    6234  threads are simultaneously touching allocations making it impossible to make
    6235  lost at the same time as we try to allocate. */
    6236  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
    6237  {
    6238  return VK_ERROR_TOO_MANY_OBJECTS;
    6239  }
    6240  }
    6241 
    6242  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    6243 }
    6244 
    6245 void VmaBlockVector::Free(
    6246  VmaAllocation hAllocation)
    6247 {
    6248  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
    6249 
    6250  // Scope for lock.
    6251  {
    6252  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6253 
    6254  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
    6255 
    6256  if(hAllocation->IsPersistentMap())
    6257  {
    6258  pBlock->m_Mapping.Unmap(m_hAllocator, pBlock->m_hMemory, 1);
    6259  }
    6260 
    6261  pBlock->m_Metadata.Free(hAllocation);
    6262  VMA_HEAVY_ASSERT(pBlock->Validate());
    6263 
    6264  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
    6265 
    6266  // pBlock became empty after this deallocation.
    6267  if(pBlock->m_Metadata.IsEmpty())
    6268  {
    6269  // Already has empty Allocation. We don't want to have two, so delete this one.
    6270  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
    6271  {
    6272  pBlockToDelete = pBlock;
    6273  Remove(pBlock);
    6274  }
    6275  // We now have first empty Allocation.
    6276  else
    6277  {
    6278  m_HasEmptyBlock = true;
    6279  }
    6280  }
    6281  // pBlock didn't become empty, but we have another empty block - find and free that one.
    6282  // (This is optional, heuristics.)
    6283  else if(m_HasEmptyBlock)
    6284  {
    6285  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
    6286  if(pLastBlock->m_Metadata.IsEmpty() && m_Blocks.size() > m_MinBlockCount)
    6287  {
    6288  pBlockToDelete = pLastBlock;
    6289  m_Blocks.pop_back();
    6290  m_HasEmptyBlock = false;
    6291  }
    6292  }
    6293 
    6294  IncrementallySortBlocks();
    6295  }
    6296 
    6297  // Destruction of a free Allocation. Deferred until this point, outside of mutex
    6298  // lock, for performance reason.
    6299  if(pBlockToDelete != VMA_NULL)
    6300  {
    6301  VMA_DEBUG_LOG(" Deleted empty allocation");
    6302  pBlockToDelete->Destroy(m_hAllocator);
    6303  vma_delete(m_hAllocator, pBlockToDelete);
    6304  }
    6305 }
    6306 
    6307 size_t VmaBlockVector::CalcMaxBlockSize() const
    6308 {
    6309  size_t result = 0;
    6310  for(size_t i = m_Blocks.size(); i--; )
    6311  {
    6312  result = VMA_MAX(result, m_Blocks[i]->m_Metadata.GetSize());
    6313  if(result >= m_PreferredBlockSize)
    6314  {
    6315  break;
    6316  }
    6317  }
    6318  return result;
    6319 }
    6320 
    6321 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
    6322 {
    6323  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    6324  {
    6325  if(m_Blocks[blockIndex] == pBlock)
    6326  {
    6327  VmaVectorRemove(m_Blocks, blockIndex);
    6328  return;
    6329  }
    6330  }
    6331  VMA_ASSERT(0);
    6332 }
    6333 
    6334 void VmaBlockVector::IncrementallySortBlocks()
    6335 {
    6336  // Bubble sort only until first swap.
    6337  for(size_t i = 1; i < m_Blocks.size(); ++i)
    6338  {
    6339  if(m_Blocks[i - 1]->m_Metadata.GetSumFreeSize() > m_Blocks[i]->m_Metadata.GetSumFreeSize())
    6340  {
    6341  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
    6342  return;
    6343  }
    6344  }
    6345 }
    6346 
    6347 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
    6348 {
    6349  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
    6350  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
    6351  allocInfo.allocationSize = blockSize;
    6352  VkDeviceMemory mem = VK_NULL_HANDLE;
    6353  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
    6354  if(res < 0)
    6355  {
    6356  return res;
    6357  }
    6358 
    6359  // New VkDeviceMemory successfully created.
    6360 
    6361  // Create new Allocation for it.
    6362  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
    6363  pBlock->Init(
    6364  m_MemoryTypeIndex,
    6365  mem,
    6366  allocInfo.allocationSize);
    6367 
    6368  m_Blocks.push_back(pBlock);
    6369  if(pNewBlockIndex != VMA_NULL)
    6370  {
    6371  *pNewBlockIndex = m_Blocks.size() - 1;
    6372  }
    6373 
    6374  return VK_SUCCESS;
    6375 }
    6376 
    6377 #if VMA_STATS_STRING_ENABLED
    6378 
    6379 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
    6380 {
    6381  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6382 
    6383  json.BeginObject();
    6384 
    6385  if(m_IsCustomPool)
    6386  {
    6387  json.WriteString("MemoryTypeIndex");
    6388  json.WriteNumber(m_MemoryTypeIndex);
    6389 
    6390  json.WriteString("BlockSize");
    6391  json.WriteNumber(m_PreferredBlockSize);
    6392 
    6393  json.WriteString("BlockCount");
    6394  json.BeginObject(true);
    6395  if(m_MinBlockCount > 0)
    6396  {
    6397  json.WriteString("Min");
    6398  json.WriteNumber(m_MinBlockCount);
    6399  }
    6400  if(m_MaxBlockCount < SIZE_MAX)
    6401  {
    6402  json.WriteString("Max");
    6403  json.WriteNumber(m_MaxBlockCount);
    6404  }
    6405  json.WriteString("Cur");
    6406  json.WriteNumber(m_Blocks.size());
    6407  json.EndObject();
    6408 
    6409  if(m_FrameInUseCount > 0)
    6410  {
    6411  json.WriteString("FrameInUseCount");
    6412  json.WriteNumber(m_FrameInUseCount);
    6413  }
    6414  }
    6415  else
    6416  {
    6417  json.WriteString("PreferredBlockSize");
    6418  json.WriteNumber(m_PreferredBlockSize);
    6419  }
    6420 
    6421  json.WriteString("Blocks");
    6422  json.BeginArray();
    6423  for(size_t i = 0; i < m_Blocks.size(); ++i)
    6424  {
    6425  m_Blocks[i]->m_Metadata.PrintDetailedMap(json);
    6426  }
    6427  json.EndArray();
    6428 
    6429  json.EndObject();
    6430 }
    6431 
    6432 #endif // #if VMA_STATS_STRING_ENABLED
    6433 
    6434 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
    6435  VmaAllocator hAllocator,
    6436  uint32_t currentFrameIndex)
    6437 {
    6438  if(m_pDefragmentator == VMA_NULL)
    6439  {
    6440  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
    6441  hAllocator,
    6442  this,
    6443  currentFrameIndex);
    6444  }
    6445 
    6446  return m_pDefragmentator;
    6447 }
    6448 
    6449 VkResult VmaBlockVector::Defragment(
    6450  VmaDefragmentationStats* pDefragmentationStats,
    6451  VkDeviceSize& maxBytesToMove,
    6452  uint32_t& maxAllocationsToMove)
    6453 {
    6454  if(m_pDefragmentator == VMA_NULL)
    6455  {
    6456  return VK_SUCCESS;
    6457  }
    6458 
    6459  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6460 
    6461  // Defragment.
    6462  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
    6463 
    6464  // Accumulate statistics.
    6465  if(pDefragmentationStats != VMA_NULL)
    6466  {
    6467  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
    6468  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
    6469  pDefragmentationStats->bytesMoved += bytesMoved;
    6470  pDefragmentationStats->allocationsMoved += allocationsMoved;
    6471  VMA_ASSERT(bytesMoved <= maxBytesToMove);
    6472  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
    6473  maxBytesToMove -= bytesMoved;
    6474  maxAllocationsToMove -= allocationsMoved;
    6475  }
    6476 
    6477  // Free empty blocks.
    6478  m_HasEmptyBlock = false;
    6479  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
    6480  {
    6481  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
    6482  if(pBlock->m_Metadata.IsEmpty())
    6483  {
    6484  if(m_Blocks.size() > m_MinBlockCount)
    6485  {
    6486  if(pDefragmentationStats != VMA_NULL)
    6487  {
    6488  ++pDefragmentationStats->deviceMemoryBlocksFreed;
    6489  pDefragmentationStats->bytesFreed += pBlock->m_Metadata.GetSize();
    6490  }
    6491 
    6492  VmaVectorRemove(m_Blocks, blockIndex);
    6493  pBlock->Destroy(m_hAllocator);
    6494  vma_delete(m_hAllocator, pBlock);
    6495  }
    6496  else
    6497  {
    6498  m_HasEmptyBlock = true;
    6499  }
    6500  }
    6501  }
    6502 
    6503  return result;
    6504 }
    6505 
    6506 void VmaBlockVector::DestroyDefragmentator()
    6507 {
    6508  if(m_pDefragmentator != VMA_NULL)
    6509  {
    6510  vma_delete(m_hAllocator, m_pDefragmentator);
    6511  m_pDefragmentator = VMA_NULL;
    6512  }
    6513 }
    6514 
    6515 void VmaBlockVector::MakePoolAllocationsLost(
    6516  uint32_t currentFrameIndex,
    6517  size_t* pLostAllocationCount)
    6518 {
    6519  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6520  size_t lostAllocationCount = 0;
    6521  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    6522  {
    6523  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
    6524  VMA_ASSERT(pBlock);
    6525  lostAllocationCount += pBlock->m_Metadata.MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
    6526  }
    6527  if(pLostAllocationCount != VMA_NULL)
    6528  {
    6529  *pLostAllocationCount = lostAllocationCount;
    6530  }
    6531 }
    6532 
    6533 void VmaBlockVector::AddStats(VmaStats* pStats)
    6534 {
    6535  const uint32_t memTypeIndex = m_MemoryTypeIndex;
    6536  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
    6537 
    6538  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
    6539 
    6540  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
    6541  {
    6542  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
    6543  VMA_ASSERT(pBlock);
    6544  VMA_HEAVY_ASSERT(pBlock->Validate());
    6545  VmaStatInfo allocationStatInfo;
    6546  pBlock->m_Metadata.CalcAllocationStatInfo(allocationStatInfo);
    6547  VmaAddStatInfo(pStats->total, allocationStatInfo);
    6548  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
    6549  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
    6550  }
    6551 }
    6552 
    6554 // VmaDefragmentator members definition
    6555 
    6556 VmaDefragmentator::VmaDefragmentator(
    6557  VmaAllocator hAllocator,
    6558  VmaBlockVector* pBlockVector,
    6559  uint32_t currentFrameIndex) :
    6560  m_hAllocator(hAllocator),
    6561  m_pBlockVector(pBlockVector),
    6562  m_CurrentFrameIndex(currentFrameIndex),
    6563  m_BytesMoved(0),
    6564  m_AllocationsMoved(0),
    6565  m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),
    6566  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
    6567 {
    6568 }
    6569 
    6570 VmaDefragmentator::~VmaDefragmentator()
    6571 {
    6572  for(size_t i = m_Blocks.size(); i--; )
    6573  {
    6574  vma_delete(m_hAllocator, m_Blocks[i]);
    6575  }
    6576 }
    6577 
    6578 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
    6579 {
    6580  AllocationInfo allocInfo;
    6581  allocInfo.m_hAllocation = hAlloc;
    6582  allocInfo.m_pChanged = pChanged;
    6583  m_Allocations.push_back(allocInfo);
    6584 }
    6585 
    6586 VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)
    6587 {
    6588  // It has already been mapped for defragmentation.
    6589  if(m_pMappedDataForDefragmentation)
    6590  {
    6591  *ppMappedData = m_pMappedDataForDefragmentation;
    6592  return VK_SUCCESS;
    6593  }
    6594 
    6595  // It is originally mapped.
    6596  if(m_pBlock->m_Mapping.GetMappedData())
    6597  {
    6598  *ppMappedData = m_pBlock->m_Mapping.GetMappedData();
    6599  return VK_SUCCESS;
    6600  }
    6601 
    6602  // Map on first usage.
    6603  VkResult res = m_pBlock->Map(hAllocator, 1, &m_pMappedDataForDefragmentation);
    6604  *ppMappedData = m_pMappedDataForDefragmentation;
    6605  return res;
    6606 }
    6607 
    6608 void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)
    6609 {
    6610  if(m_pMappedDataForDefragmentation != VMA_NULL)
    6611  {
    6612  m_pBlock->Unmap(hAllocator, 1);
    6613  }
    6614 }
    6615 
    6616 VkResult VmaDefragmentator::DefragmentRound(
    6617  VkDeviceSize maxBytesToMove,
    6618  uint32_t maxAllocationsToMove)
    6619 {
    6620  if(m_Blocks.empty())
    6621  {
    6622  return VK_SUCCESS;
    6623  }
    6624 
    6625  size_t srcBlockIndex = m_Blocks.size() - 1;
    6626  size_t srcAllocIndex = SIZE_MAX;
    6627  for(;;)
    6628  {
    6629  // 1. Find next allocation to move.
    6630  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
    6631  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
    6632  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
    6633  {
    6634  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
    6635  {
    6636  // Finished: no more allocations to process.
    6637  if(srcBlockIndex == 0)
    6638  {
    6639  return VK_SUCCESS;
    6640  }
    6641  else
    6642  {
    6643  --srcBlockIndex;
    6644  srcAllocIndex = SIZE_MAX;
    6645  }
    6646  }
    6647  else
    6648  {
    6649  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
    6650  }
    6651  }
    6652 
    6653  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
    6654  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
    6655 
    6656  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
    6657  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
    6658  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
    6659  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
    6660 
    6661  // 2. Try to find new place for this allocation in preceding or current block.
    6662  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
    6663  {
    6664  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
    6665  VmaAllocationRequest dstAllocRequest;
    6666  if(pDstBlockInfo->m_pBlock->m_Metadata.CreateAllocationRequest(
    6667  m_CurrentFrameIndex,
    6668  m_pBlockVector->GetFrameInUseCount(),
    6669  m_pBlockVector->GetBufferImageGranularity(),
    6670  size,
    6671  alignment,
    6672  suballocType,
    6673  false, // canMakeOtherLost
    6674  &dstAllocRequest) &&
    6675  MoveMakesSense(
    6676  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
    6677  {
    6678  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
    6679 
    6680  // Reached limit on number of allocations or bytes to move.
    6681  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
    6682  (m_BytesMoved + size > maxBytesToMove))
    6683  {
    6684  return VK_INCOMPLETE;
    6685  }
    6686 
    6687  void* pDstMappedData = VMA_NULL;
    6688  VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);
    6689  if(res != VK_SUCCESS)
    6690  {
    6691  return res;
    6692  }
    6693 
    6694  void* pSrcMappedData = VMA_NULL;
    6695  res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);
    6696  if(res != VK_SUCCESS)
    6697  {
    6698  return res;
    6699  }
    6700 
    6701  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
    6702  memcpy(
    6703  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
    6704  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
    6705  static_cast<size_t>(size));
    6706 
    6707  pDstBlockInfo->m_pBlock->m_Metadata.Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);
    6708  pSrcBlockInfo->m_pBlock->m_Metadata.FreeAtOffset(srcOffset);
    6709 
    6710  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
    6711 
    6712  if(allocInfo.m_pChanged != VMA_NULL)
    6713  {
    6714  *allocInfo.m_pChanged = VK_TRUE;
    6715  }
    6716 
    6717  ++m_AllocationsMoved;
    6718  m_BytesMoved += size;
    6719 
    6720  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
    6721 
    6722  break;
    6723  }
    6724  }
    6725 
    6726  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
    6727 
    6728  if(srcAllocIndex > 0)
    6729  {
    6730  --srcAllocIndex;
    6731  }
    6732  else
    6733  {
    6734  if(srcBlockIndex > 0)
    6735  {
    6736  --srcBlockIndex;
    6737  srcAllocIndex = SIZE_MAX;
    6738  }
    6739  else
    6740  {
    6741  return VK_SUCCESS;
    6742  }
    6743  }
    6744  }
    6745 }
    6746 
    6747 VkResult VmaDefragmentator::Defragment(
    6748  VkDeviceSize maxBytesToMove,
    6749  uint32_t maxAllocationsToMove)
    6750 {
    6751  if(m_Allocations.empty())
    6752  {
    6753  return VK_SUCCESS;
    6754  }
    6755 
    6756  // Create block info for each block.
    6757  const size_t blockCount = m_pBlockVector->m_Blocks.size();
    6758  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    6759  {
    6760  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
    6761  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
    6762  m_Blocks.push_back(pBlockInfo);
    6763  }
    6764 
    6765  // Sort them by m_pBlock pointer value.
    6766  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
    6767 
    6768  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
    6769  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
    6770  {
    6771  AllocationInfo& allocInfo = m_Allocations[blockIndex];
    6772  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
    6773  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
    6774  {
    6775  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
    6776  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
    6777  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
    6778  {
    6779  (*it)->m_Allocations.push_back(allocInfo);
    6780  }
    6781  else
    6782  {
    6783  VMA_ASSERT(0);
    6784  }
    6785  }
    6786  }
    6787  m_Allocations.clear();
    6788 
    6789  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    6790  {
    6791  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
    6792  pBlockInfo->CalcHasNonMovableAllocations();
    6793  pBlockInfo->SortAllocationsBySizeDescecnding();
    6794  }
    6795 
    6796  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
    6797  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
    6798 
    6799  // Execute defragmentation rounds (the main part).
    6800  VkResult result = VK_SUCCESS;
    6801  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
    6802  {
    6803  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
    6804  }
    6805 
    6806  // Unmap blocks that were mapped for defragmentation.
    6807  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
    6808  {
    6809  m_Blocks[blockIndex]->Unmap(m_hAllocator);
    6810  }
    6811 
    6812  return result;
    6813 }
    6814 
    6815 bool VmaDefragmentator::MoveMakesSense(
    6816  size_t dstBlockIndex, VkDeviceSize dstOffset,
    6817  size_t srcBlockIndex, VkDeviceSize srcOffset)
    6818 {
    6819  if(dstBlockIndex < srcBlockIndex)
    6820  {
    6821  return true;
    6822  }
    6823  if(dstBlockIndex > srcBlockIndex)
    6824  {
    6825  return false;
    6826  }
    6827  if(dstOffset < srcOffset)
    6828  {
    6829  return true;
    6830  }
    6831  return false;
    6832 }
    6833 
    6835 // VmaAllocator_T
    6836 
    6837 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
    6838  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
    6839  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
    6840  m_hDevice(pCreateInfo->device),
    6841  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
    6842  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
    6843  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
    6844  m_PreferredLargeHeapBlockSize(0),
    6845  m_PhysicalDevice(pCreateInfo->physicalDevice),
    6846  m_CurrentFrameIndex(0),
    6847  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks()))
    6848 {
    6849  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
    6850 
    6851  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
    6852  memset(&m_MemProps, 0, sizeof(m_MemProps));
    6853  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
    6854 
    6855  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
    6856  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
    6857 
    6858  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
    6859  {
    6860  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
    6861  }
    6862 
    6863  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
    6864  {
    6865  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
    6866  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
    6867  }
    6868 
    6869  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
    6870 
    6871  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
    6872  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
    6873 
    6874  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
    6875  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
    6876 
    6877  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
    6878  {
    6879  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
    6880  {
    6881  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
    6882  if(limit != VK_WHOLE_SIZE)
    6883  {
    6884  m_HeapSizeLimit[heapIndex] = limit;
    6885  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
    6886  {
    6887  m_MemProps.memoryHeaps[heapIndex].size = limit;
    6888  }
    6889  }
    6890  }
    6891  }
    6892 
    6893  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    6894  {
    6895  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
    6896 
    6897  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
    6898  this,
    6899  memTypeIndex,
    6900  preferredBlockSize,
    6901  0,
    6902  SIZE_MAX,
    6903  GetBufferImageGranularity(),
    6904  pCreateInfo->frameInUseCount,
    6905  false); // isCustomPool
    6906  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
    6907  // becase minBlockCount is 0.
    6908  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
    6909  }
    6910 }
    6911 
    6912 VmaAllocator_T::~VmaAllocator_T()
    6913 {
    6914  VMA_ASSERT(m_Pools.empty());
    6915 
    6916  for(size_t i = GetMemoryTypeCount(); i--; )
    6917  {
    6918  vma_delete(this, m_pDedicatedAllocations[i]);
    6919  vma_delete(this, m_pBlockVectors[i]);
    6920  }
    6921 }
    6922 
    6923 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
    6924 {
    6925 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
    6926  m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;
    6927  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;
    6928  m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
    6929  m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;
    6930  m_VulkanFunctions.vkMapMemory = &vkMapMemory;
    6931  m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;
    6932  m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;
    6933  m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;
    6934  m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;
    6935  m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;
    6936  m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;
    6937  m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;
    6938  m_VulkanFunctions.vkCreateImage = &vkCreateImage;
    6939  m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;
    6940  if(m_UseKhrDedicatedAllocation)
    6941  {
    6942  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
    6943  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
    6944  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
    6945  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
    6946  }
    6947 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
    6948 
    6949 #define VMA_COPY_IF_NOT_NULL(funcName) \
    6950  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
    6951 
    6952  if(pVulkanFunctions != VMA_NULL)
    6953  {
    6954  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
    6955  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
    6956  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
    6957  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
    6958  VMA_COPY_IF_NOT_NULL(vkMapMemory);
    6959  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
    6960  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
    6961  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
    6962  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
    6963  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
    6964  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
    6965  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
    6966  VMA_COPY_IF_NOT_NULL(vkCreateImage);
    6967  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
    6968  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
    6969  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
    6970  }
    6971 
    6972 #undef VMA_COPY_IF_NOT_NULL
    6973 
    6974  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
    6975  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
    6976  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
    6977  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
    6978  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
    6979  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
    6980  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
    6981  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
    6982  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
    6983  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
    6984  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
    6985  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
    6986  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
    6987  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
    6988  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
    6989  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
    6990  if(m_UseKhrDedicatedAllocation)
    6991  {
    6992  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
    6993  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
    6994  }
    6995 }
    6996 
    6997 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
    6998 {
    6999  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
    7000  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
    7001  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
    7002  return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
    7003 }
    7004 
    7005 VkResult VmaAllocator_T::AllocateMemoryOfType(
    7006  const VkMemoryRequirements& vkMemReq,
    7007  bool dedicatedAllocation,
    7008  VkBuffer dedicatedBuffer,
    7009  VkImage dedicatedImage,
    7010  const VmaAllocationCreateInfo& createInfo,
    7011  uint32_t memTypeIndex,
    7012  VmaSuballocationType suballocType,
    7013  VmaAllocation* pAllocation)
    7014 {
    7015  VMA_ASSERT(pAllocation != VMA_NULL);
    7016  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
    7017 
    7018  VmaAllocationCreateInfo finalCreateInfo = createInfo;
    7019 
    7020  // If memory type is not HOST_VISIBLE, disable MAPPED.
    7021  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
    7022  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
    7023  {
    7024  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
    7025  }
    7026 
    7027  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
    7028  VMA_ASSERT(blockVector);
    7029 
    7030  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
    7031  bool preferDedicatedMemory =
    7032  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
    7033  dedicatedAllocation ||
    7034  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
    7035  vkMemReq.size > preferredBlockSize / 2;
    7036 
    7037  if(preferDedicatedMemory &&
    7038  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
    7039  finalCreateInfo.pool == VK_NULL_HANDLE)
    7040  {
    7041  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
    7042  }
    7043 
    7044  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
    7045  {
    7046  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    7047  {
    7048  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7049  }
    7050  else
    7051  {
    7052  return AllocateDedicatedMemory(
    7053  vkMemReq.size,
    7054  suballocType,
    7055  memTypeIndex,
    7056  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
    7057  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
    7058  finalCreateInfo.pUserData,
    7059  dedicatedBuffer,
    7060  dedicatedImage,
    7061  pAllocation);
    7062  }
    7063  }
    7064  else
    7065  {
    7066  VkResult res = blockVector->Allocate(
    7067  VK_NULL_HANDLE, // hCurrentPool
    7068  m_CurrentFrameIndex.load(),
    7069  vkMemReq,
    7070  finalCreateInfo,
    7071  suballocType,
    7072  pAllocation);
    7073  if(res == VK_SUCCESS)
    7074  {
    7075  return res;
    7076  }
    7077 
    7078  // 5. Try dedicated memory.
    7079  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    7080  {
    7081  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7082  }
    7083  else
    7084  {
    7085  res = AllocateDedicatedMemory(
    7086  vkMemReq.size,
    7087  suballocType,
    7088  memTypeIndex,
    7089  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
    7090  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
    7091  finalCreateInfo.pUserData,
    7092  dedicatedBuffer,
    7093  dedicatedImage,
    7094  pAllocation);
    7095  if(res == VK_SUCCESS)
    7096  {
    7097  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
    7098  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
    7099  return VK_SUCCESS;
    7100  }
    7101  else
    7102  {
    7103  // Everything failed: Return error code.
    7104  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
    7105  return res;
    7106  }
    7107  }
    7108  }
    7109 }
    7110 
    7111 VkResult VmaAllocator_T::AllocateDedicatedMemory(
    7112  VkDeviceSize size,
    7113  VmaSuballocationType suballocType,
    7114  uint32_t memTypeIndex,
    7115  bool map,
    7116  bool isUserDataString,
    7117  void* pUserData,
    7118  VkBuffer dedicatedBuffer,
    7119  VkImage dedicatedImage,
    7120  VmaAllocation* pAllocation)
    7121 {
    7122  VMA_ASSERT(pAllocation);
    7123 
    7124  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
    7125  allocInfo.memoryTypeIndex = memTypeIndex;
    7126  allocInfo.allocationSize = size;
    7127 
    7128  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
    7129  if(m_UseKhrDedicatedAllocation)
    7130  {
    7131  if(dedicatedBuffer != VK_NULL_HANDLE)
    7132  {
    7133  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
    7134  dedicatedAllocInfo.buffer = dedicatedBuffer;
    7135  allocInfo.pNext = &dedicatedAllocInfo;
    7136  }
    7137  else if(dedicatedImage != VK_NULL_HANDLE)
    7138  {
    7139  dedicatedAllocInfo.image = dedicatedImage;
    7140  allocInfo.pNext = &dedicatedAllocInfo;
    7141  }
    7142  }
    7143 
    7144  // Allocate VkDeviceMemory.
    7145  VkDeviceMemory hMemory = VK_NULL_HANDLE;
    7146  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
    7147  if(res < 0)
    7148  {
    7149  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
    7150  return res;
    7151  }
    7152 
    7153  void* pMappedData = VMA_NULL;
    7154  if(map)
    7155  {
    7156  res = (*m_VulkanFunctions.vkMapMemory)(
    7157  m_hDevice,
    7158  hMemory,
    7159  0,
    7160  VK_WHOLE_SIZE,
    7161  0,
    7162  &pMappedData);
    7163  if(res < 0)
    7164  {
    7165  VMA_DEBUG_LOG(" vkMapMemory FAILED");
    7166  FreeVulkanMemory(memTypeIndex, size, hMemory);
    7167  return res;
    7168  }
    7169  }
    7170 
    7171  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
    7172  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
    7173  (*pAllocation)->SetUserData(this, pUserData);
    7174 
    7175  // Register it in m_pDedicatedAllocations.
    7176  {
    7177  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7178  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
    7179  VMA_ASSERT(pDedicatedAllocations);
    7180  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);
    7181  }
    7182 
    7183  VMA_DEBUG_LOG(" Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
    7184 
    7185  return VK_SUCCESS;
    7186 }
    7187 
    7188 void VmaAllocator_T::GetBufferMemoryRequirements(
    7189  VkBuffer hBuffer,
    7190  VkMemoryRequirements& memReq,
    7191  bool& requiresDedicatedAllocation,
    7192  bool& prefersDedicatedAllocation) const
    7193 {
    7194  if(m_UseKhrDedicatedAllocation)
    7195  {
    7196  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
    7197  memReqInfo.buffer = hBuffer;
    7198 
    7199  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
    7200 
    7201  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
    7202  memReq2.pNext = &memDedicatedReq;
    7203 
    7204  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
    7205 
    7206  memReq = memReq2.memoryRequirements;
    7207  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
    7208  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
    7209  }
    7210  else
    7211  {
    7212  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
    7213  requiresDedicatedAllocation = false;
    7214  prefersDedicatedAllocation = false;
    7215  }
    7216 }
    7217 
    7218 void VmaAllocator_T::GetImageMemoryRequirements(
    7219  VkImage hImage,
    7220  VkMemoryRequirements& memReq,
    7221  bool& requiresDedicatedAllocation,
    7222  bool& prefersDedicatedAllocation) const
    7223 {
    7224  if(m_UseKhrDedicatedAllocation)
    7225  {
    7226  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
    7227  memReqInfo.image = hImage;
    7228 
    7229  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
    7230 
    7231  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
    7232  memReq2.pNext = &memDedicatedReq;
    7233 
    7234  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
    7235 
    7236  memReq = memReq2.memoryRequirements;
    7237  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
    7238  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
    7239  }
    7240  else
    7241  {
    7242  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
    7243  requiresDedicatedAllocation = false;
    7244  prefersDedicatedAllocation = false;
    7245  }
    7246 }
    7247 
    7248 VkResult VmaAllocator_T::AllocateMemory(
    7249  const VkMemoryRequirements& vkMemReq,
    7250  bool requiresDedicatedAllocation,
    7251  bool prefersDedicatedAllocation,
    7252  VkBuffer dedicatedBuffer,
    7253  VkImage dedicatedImage,
    7254  const VmaAllocationCreateInfo& createInfo,
    7255  VmaSuballocationType suballocType,
    7256  VmaAllocation* pAllocation)
    7257 {
    7258  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
    7259  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    7260  {
    7261  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
    7262  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7263  }
    7264  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
    7265  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
    7266  {
    7267  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
    7268  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7269  }
    7270  if(requiresDedicatedAllocation)
    7271  {
    7272  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
    7273  {
    7274  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
    7275  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7276  }
    7277  if(createInfo.pool != VK_NULL_HANDLE)
    7278  {
    7279  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
    7280  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7281  }
    7282  }
    7283  if((createInfo.pool != VK_NULL_HANDLE) &&
    7284  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
    7285  {
    7286  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
    7287  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7288  }
    7289 
    7290  if(createInfo.pool != VK_NULL_HANDLE)
    7291  {
    7292  return createInfo.pool->m_BlockVector.Allocate(
    7293  createInfo.pool,
    7294  m_CurrentFrameIndex.load(),
    7295  vkMemReq,
    7296  createInfo,
    7297  suballocType,
    7298  pAllocation);
    7299  }
    7300  else
    7301  {
    7302  // Bit mask of memory Vulkan types acceptable for this allocation.
    7303  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
    7304  uint32_t memTypeIndex = UINT32_MAX;
    7305  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
    7306  if(res == VK_SUCCESS)
    7307  {
    7308  res = AllocateMemoryOfType(
    7309  vkMemReq,
    7310  requiresDedicatedAllocation || prefersDedicatedAllocation,
    7311  dedicatedBuffer,
    7312  dedicatedImage,
    7313  createInfo,
    7314  memTypeIndex,
    7315  suballocType,
    7316  pAllocation);
    7317  // Succeeded on first try.
    7318  if(res == VK_SUCCESS)
    7319  {
    7320  return res;
    7321  }
    7322  // Allocation from this memory type failed. Try other compatible memory types.
    7323  else
    7324  {
    7325  for(;;)
    7326  {
    7327  // Remove old memTypeIndex from list of possibilities.
    7328  memoryTypeBits &= ~(1u << memTypeIndex);
    7329  // Find alternative memTypeIndex.
    7330  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
    7331  if(res == VK_SUCCESS)
    7332  {
    7333  res = AllocateMemoryOfType(
    7334  vkMemReq,
    7335  requiresDedicatedAllocation || prefersDedicatedAllocation,
    7336  dedicatedBuffer,
    7337  dedicatedImage,
    7338  createInfo,
    7339  memTypeIndex,
    7340  suballocType,
    7341  pAllocation);
    7342  // Allocation from this alternative memory type succeeded.
    7343  if(res == VK_SUCCESS)
    7344  {
    7345  return res;
    7346  }
    7347  // else: Allocation from this memory type failed. Try next one - next loop iteration.
    7348  }
    7349  // No other matching memory type index could be found.
    7350  else
    7351  {
    7352  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
    7353  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7354  }
    7355  }
    7356  }
    7357  }
    7358  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
    7359  else
    7360  return res;
    7361  }
    7362 }
    7363 
    7364 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
    7365 {
    7366  VMA_ASSERT(allocation);
    7367 
    7368  if(allocation->CanBecomeLost() == false ||
    7369  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
    7370  {
    7371  switch(allocation->GetType())
    7372  {
    7373  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    7374  {
    7375  VmaBlockVector* pBlockVector = VMA_NULL;
    7376  VmaPool hPool = allocation->GetPool();
    7377  if(hPool != VK_NULL_HANDLE)
    7378  {
    7379  pBlockVector = &hPool->m_BlockVector;
    7380  }
    7381  else
    7382  {
    7383  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    7384  pBlockVector = m_pBlockVectors[memTypeIndex];
    7385  }
    7386  pBlockVector->Free(allocation);
    7387  }
    7388  break;
    7389  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
    7390  FreeDedicatedMemory(allocation);
    7391  break;
    7392  default:
    7393  VMA_ASSERT(0);
    7394  }
    7395  }
    7396 
    7397  allocation->SetUserData(this, VMA_NULL);
    7398  vma_delete(this, allocation);
    7399 }
    7400 
    7401 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
    7402 {
    7403  // Initialize.
    7404  InitStatInfo(pStats->total);
    7405  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
    7406  InitStatInfo(pStats->memoryType[i]);
    7407  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
    7408  InitStatInfo(pStats->memoryHeap[i]);
    7409 
    7410  // Process default pools.
    7411  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7412  {
    7413  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
    7414  VMA_ASSERT(pBlockVector);
    7415  pBlockVector->AddStats(pStats);
    7416  }
    7417 
    7418  // Process custom pools.
    7419  {
    7420  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7421  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
    7422  {
    7423  m_Pools[poolIndex]->GetBlockVector().AddStats(pStats);
    7424  }
    7425  }
    7426 
    7427  // Process dedicated allocations.
    7428  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7429  {
    7430  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
    7431  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7432  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
    7433  VMA_ASSERT(pDedicatedAllocVector);
    7434  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
    7435  {
    7436  VmaStatInfo allocationStatInfo;
    7437  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
    7438  VmaAddStatInfo(pStats->total, allocationStatInfo);
    7439  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
    7440  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
    7441  }
    7442  }
    7443 
    7444  // Postprocess.
    7445  VmaPostprocessCalcStatInfo(pStats->total);
    7446  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
    7447  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
    7448  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
    7449  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
    7450 }
    7451 
    7452 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
    7453 
    7454 VkResult VmaAllocator_T::Defragment(
    7455  VmaAllocation* pAllocations,
    7456  size_t allocationCount,
    7457  VkBool32* pAllocationsChanged,
    7458  const VmaDefragmentationInfo* pDefragmentationInfo,
    7459  VmaDefragmentationStats* pDefragmentationStats)
    7460 {
    7461  if(pAllocationsChanged != VMA_NULL)
    7462  {
    7463  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
    7464  }
    7465  if(pDefragmentationStats != VMA_NULL)
    7466  {
    7467  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
    7468  }
    7469 
    7470  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
    7471 
    7472  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
    7473 
    7474  const size_t poolCount = m_Pools.size();
    7475 
    7476  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
    7477  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
    7478  {
    7479  VmaAllocation hAlloc = pAllocations[allocIndex];
    7480  VMA_ASSERT(hAlloc);
    7481  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
    7482  // DedicatedAlloc cannot be defragmented.
    7483  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
    7484  // Only HOST_VISIBLE memory types can be defragmented.
    7485  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&
    7486  // Lost allocation cannot be defragmented.
    7487  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
    7488  {
    7489  VmaBlockVector* pAllocBlockVector = VMA_NULL;
    7490 
    7491  const VmaPool hAllocPool = hAlloc->GetPool();
    7492  // This allocation belongs to custom pool.
    7493  if(hAllocPool != VK_NULL_HANDLE)
    7494  {
    7495  pAllocBlockVector = &hAllocPool->GetBlockVector();
    7496  }
    7497  // This allocation belongs to general pool.
    7498  else
    7499  {
    7500  pAllocBlockVector = m_pBlockVectors[memTypeIndex];
    7501  }
    7502 
    7503  VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);
    7504 
    7505  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
    7506  &pAllocationsChanged[allocIndex] : VMA_NULL;
    7507  pDefragmentator->AddAllocation(hAlloc, pChanged);
    7508  }
    7509  }
    7510 
    7511  VkResult result = VK_SUCCESS;
    7512 
    7513  // ======== Main processing.
    7514 
    7515  VkDeviceSize maxBytesToMove = SIZE_MAX;
    7516  uint32_t maxAllocationsToMove = UINT32_MAX;
    7517  if(pDefragmentationInfo != VMA_NULL)
    7518  {
    7519  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
    7520  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
    7521  }
    7522 
    7523  // Process standard memory.
    7524  for(uint32_t memTypeIndex = 0;
    7525  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
    7526  ++memTypeIndex)
    7527  {
    7528  // Only HOST_VISIBLE memory types can be defragmented.
    7529  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    7530  {
    7531  result = m_pBlockVectors[memTypeIndex]->Defragment(
    7532  pDefragmentationStats,
    7533  maxBytesToMove,
    7534  maxAllocationsToMove);
    7535  }
    7536  }
    7537 
    7538  // Process custom pools.
    7539  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
    7540  {
    7541  result = m_Pools[poolIndex]->GetBlockVector().Defragment(
    7542  pDefragmentationStats,
    7543  maxBytesToMove,
    7544  maxAllocationsToMove);
    7545  }
    7546 
    7547  // ======== Destroy defragmentators.
    7548 
    7549  // Process custom pools.
    7550  for(size_t poolIndex = poolCount; poolIndex--; )
    7551  {
    7552  m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();
    7553  }
    7554 
    7555  // Process standard memory.
    7556  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
    7557  {
    7558  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    7559  {
    7560  m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();
    7561  }
    7562  }
    7563 
    7564  return result;
    7565 }
    7566 
    7567 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
    7568 {
    7569  if(hAllocation->CanBecomeLost())
    7570  {
    7571  /*
    7572  Warning: This is a carefully designed algorithm.
    7573  Do not modify unless you really know what you're doing :)
    7574  */
    7575  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
    7576  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
    7577  for(;;)
    7578  {
    7579  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
    7580  {
    7581  pAllocationInfo->memoryType = UINT32_MAX;
    7582  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
    7583  pAllocationInfo->offset = 0;
    7584  pAllocationInfo->size = hAllocation->GetSize();
    7585  pAllocationInfo->pMappedData = VMA_NULL;
    7586  pAllocationInfo->pUserData = hAllocation->GetUserData();
    7587  return;
    7588  }
    7589  else if(localLastUseFrameIndex == localCurrFrameIndex)
    7590  {
    7591  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
    7592  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
    7593  pAllocationInfo->offset = hAllocation->GetOffset();
    7594  pAllocationInfo->size = hAllocation->GetSize();
    7595  pAllocationInfo->pMappedData = VMA_NULL;
    7596  pAllocationInfo->pUserData = hAllocation->GetUserData();
    7597  return;
    7598  }
    7599  else // Last use time earlier than current time.
    7600  {
    7601  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
    7602  {
    7603  localLastUseFrameIndex = localCurrFrameIndex;
    7604  }
    7605  }
    7606  }
    7607  }
    7608  else
    7609  {
    7610  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
    7611  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
    7612  pAllocationInfo->offset = hAllocation->GetOffset();
    7613  pAllocationInfo->size = hAllocation->GetSize();
    7614  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
    7615  pAllocationInfo->pUserData = hAllocation->GetUserData();
    7616  }
    7617 }
    7618 
    7619 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
    7620 {
    7621  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);
    7622 
    7623  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
    7624 
    7625  if(newCreateInfo.maxBlockCount == 0)
    7626  {
    7627  newCreateInfo.maxBlockCount = SIZE_MAX;
    7628  }
    7629  if(newCreateInfo.blockSize == 0)
    7630  {
    7631  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
    7632  }
    7633 
    7634  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
    7635 
    7636  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
    7637  if(res != VK_SUCCESS)
    7638  {
    7639  vma_delete(this, *pPool);
    7640  *pPool = VMA_NULL;
    7641  return res;
    7642  }
    7643 
    7644  // Add to m_Pools.
    7645  {
    7646  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7647  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
    7648  }
    7649 
    7650  return VK_SUCCESS;
    7651 }
    7652 
    7653 void VmaAllocator_T::DestroyPool(VmaPool pool)
    7654 {
    7655  // Remove from m_Pools.
    7656  {
    7657  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7658  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
    7659  VMA_ASSERT(success && "Pool not found in Allocator.");
    7660  }
    7661 
    7662  vma_delete(this, pool);
    7663 }
    7664 
    7665 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
    7666 {
    7667  pool->m_BlockVector.GetPoolStats(pPoolStats);
    7668 }
    7669 
    7670 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
    7671 {
    7672  m_CurrentFrameIndex.store(frameIndex);
    7673 }
    7674 
    7675 void VmaAllocator_T::MakePoolAllocationsLost(
    7676  VmaPool hPool,
    7677  size_t* pLostAllocationCount)
    7678 {
    7679  hPool->m_BlockVector.MakePoolAllocationsLost(
    7680  m_CurrentFrameIndex.load(),
    7681  pLostAllocationCount);
    7682 }
    7683 
    7684 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
    7685 {
    7686  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);
    7687  (*pAllocation)->InitLost();
    7688 }
    7689 
    7690 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
    7691 {
    7692  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
    7693 
    7694  VkResult res;
    7695  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
    7696  {
    7697  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
    7698  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
    7699  {
    7700  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
    7701  if(res == VK_SUCCESS)
    7702  {
    7703  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
    7704  }
    7705  }
    7706  else
    7707  {
    7708  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
    7709  }
    7710  }
    7711  else
    7712  {
    7713  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
    7714  }
    7715 
    7716  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
    7717  {
    7718  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
    7719  }
    7720 
    7721  return res;
    7722 }
    7723 
    7724 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
    7725 {
    7726  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
    7727  {
    7728  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
    7729  }
    7730 
    7731  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
    7732 
    7733  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
    7734  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
    7735  {
    7736  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
    7737  m_HeapSizeLimit[heapIndex] += size;
    7738  }
    7739 }
    7740 
    7741 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
    7742 {
    7743  if(hAllocation->CanBecomeLost())
    7744  {
    7745  return VK_ERROR_MEMORY_MAP_FAILED;
    7746  }
    7747 
    7748  switch(hAllocation->GetType())
    7749  {
    7750  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    7751  {
    7752  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
    7753  char *pBytes = VMA_NULL;
    7754  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
    7755  if(res == VK_SUCCESS)
    7756  {
    7757  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
    7758  hAllocation->BlockAllocMap();
    7759  }
    7760  return res;
    7761  }
    7762  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
    7763  return hAllocation->DedicatedAllocMap(this, ppData);
    7764  default:
    7765  VMA_ASSERT(0);
    7766  return VK_ERROR_MEMORY_MAP_FAILED;
    7767  }
    7768 }
    7769 
    7770 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
    7771 {
    7772  switch(hAllocation->GetType())
    7773  {
    7774  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
    7775  {
    7776  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
    7777  hAllocation->BlockAllocUnmap();
    7778  pBlock->Unmap(this, 1);
    7779  }
    7780  break;
    7781  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
    7782  hAllocation->DedicatedAllocUnmap(this);
    7783  break;
    7784  default:
    7785  VMA_ASSERT(0);
    7786  }
    7787 }
    7788 
    7789 void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
    7790 {
    7791  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
    7792 
    7793  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
    7794  {
    7795  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7796  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
    7797  VMA_ASSERT(pDedicatedAllocations);
    7798  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
    7799  VMA_ASSERT(success);
    7800  }
    7801 
    7802  VkDeviceMemory hMemory = allocation->GetMemory();
    7803 
    7804  if(allocation->GetMappedData() != VMA_NULL)
    7805  {
    7806  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
    7807  }
    7808 
    7809  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
    7810 
    7811  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
    7812 }
    7813 
    7814 #if VMA_STATS_STRING_ENABLED
    7815 
    7816 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
    7817 {
    7818  bool dedicatedAllocationsStarted = false;
    7819  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7820  {
    7821  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
    7822  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
    7823  VMA_ASSERT(pDedicatedAllocVector);
    7824  if(pDedicatedAllocVector->empty() == false)
    7825  {
    7826  if(dedicatedAllocationsStarted == false)
    7827  {
    7828  dedicatedAllocationsStarted = true;
    7829  json.WriteString("DedicatedAllocations");
    7830  json.BeginObject();
    7831  }
    7832 
    7833  json.BeginString("Type ");
    7834  json.ContinueString(memTypeIndex);
    7835  json.EndString();
    7836 
    7837  json.BeginArray();
    7838 
    7839  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
    7840  {
    7841  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
    7842  json.BeginObject(true);
    7843 
    7844  json.WriteString("Type");
    7845  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[hAlloc->GetSuballocationType()]);
    7846 
    7847  json.WriteString("Size");
    7848  json.WriteNumber(hAlloc->GetSize());
    7849 
    7850  const void* pUserData = hAlloc->GetUserData();
    7851  if(pUserData != VMA_NULL)
    7852  {
    7853  json.WriteString("UserData");
    7854  if(hAlloc->IsUserDataString())
    7855  {
    7856  json.WriteString((const char*)pUserData);
    7857  }
    7858  else
    7859  {
    7860  json.BeginString();
    7861  json.ContinueString_Pointer(pUserData);
    7862  json.EndString();
    7863  }
    7864  }
    7865 
    7866  json.EndObject();
    7867  }
    7868 
    7869  json.EndArray();
    7870  }
    7871  }
    7872  if(dedicatedAllocationsStarted)
    7873  {
    7874  json.EndObject();
    7875  }
    7876 
    7877  {
    7878  bool allocationsStarted = false;
    7879  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
    7880  {
    7881  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
    7882  {
    7883  if(allocationsStarted == false)
    7884  {
    7885  allocationsStarted = true;
    7886  json.WriteString("DefaultPools");
    7887  json.BeginObject();
    7888  }
    7889 
    7890  json.BeginString("Type ");
    7891  json.ContinueString(memTypeIndex);
    7892  json.EndString();
    7893 
    7894  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
    7895  }
    7896  }
    7897  if(allocationsStarted)
    7898  {
    7899  json.EndObject();
    7900  }
    7901  }
    7902 
    7903  {
    7904  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
    7905  const size_t poolCount = m_Pools.size();
    7906  if(poolCount > 0)
    7907  {
    7908  json.WriteString("Pools");
    7909  json.BeginArray();
    7910  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
    7911  {
    7912  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
    7913  }
    7914  json.EndArray();
    7915  }
    7916  }
    7917 }
    7918 
    7919 #endif // #if VMA_STATS_STRING_ENABLED
    7920 
    7921 static VkResult AllocateMemoryForImage(
    7922  VmaAllocator allocator,
    7923  VkImage image,
    7924  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    7925  VmaSuballocationType suballocType,
    7926  VmaAllocation* pAllocation)
    7927 {
    7928  VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation);
    7929 
    7930  VkMemoryRequirements vkMemReq = {};
    7931  bool requiresDedicatedAllocation = false;
    7932  bool prefersDedicatedAllocation = false;
    7933  allocator->GetImageMemoryRequirements(image, vkMemReq,
    7934  requiresDedicatedAllocation, prefersDedicatedAllocation);
    7935 
    7936  return allocator->AllocateMemory(
    7937  vkMemReq,
    7938  requiresDedicatedAllocation,
    7939  prefersDedicatedAllocation,
    7940  VK_NULL_HANDLE, // dedicatedBuffer
    7941  image, // dedicatedImage
    7942  *pAllocationCreateInfo,
    7943  suballocType,
    7944  pAllocation);
    7945 }
    7946 
    7948 // Public interface
    7949 
    7950 VkResult vmaCreateAllocator(
    7951  const VmaAllocatorCreateInfo* pCreateInfo,
    7952  VmaAllocator* pAllocator)
    7953 {
    7954  VMA_ASSERT(pCreateInfo && pAllocator);
    7955  VMA_DEBUG_LOG("vmaCreateAllocator");
    7956  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
    7957  return VK_SUCCESS;
    7958 }
    7959 
    7960 void vmaDestroyAllocator(
    7961  VmaAllocator allocator)
    7962 {
    7963  if(allocator != VK_NULL_HANDLE)
    7964  {
    7965  VMA_DEBUG_LOG("vmaDestroyAllocator");
    7966  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
    7967  vma_delete(&allocationCallbacks, allocator);
    7968  }
    7969 }
    7970 
    7971 void vmaGetPhysicalDeviceProperties(
    7972  VmaAllocator allocator,
    7973  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
    7974 {
    7975  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
    7976  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
    7977 }
    7978 
    7979 void vmaGetMemoryProperties(
    7980  VmaAllocator allocator,
    7981  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
    7982 {
    7983  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
    7984  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
    7985 }
    7986 
    7987 void vmaGetMemoryTypeProperties(
    7988  VmaAllocator allocator,
    7989  uint32_t memoryTypeIndex,
    7990  VkMemoryPropertyFlags* pFlags)
    7991 {
    7992  VMA_ASSERT(allocator && pFlags);
    7993  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
    7994  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
    7995 }
    7996 
    7997 void vmaSetCurrentFrameIndex(
    7998  VmaAllocator allocator,
    7999  uint32_t frameIndex)
    8000 {
    8001  VMA_ASSERT(allocator);
    8002  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
    8003 
    8004  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8005 
    8006  allocator->SetCurrentFrameIndex(frameIndex);
    8007 }
    8008 
    8009 void vmaCalculateStats(
    8010  VmaAllocator allocator,
    8011  VmaStats* pStats)
    8012 {
    8013  VMA_ASSERT(allocator && pStats);
    8014  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8015  allocator->CalculateStats(pStats);
    8016 }
    8017 
    8018 #if VMA_STATS_STRING_ENABLED
    8019 
    8020 void vmaBuildStatsString(
    8021  VmaAllocator allocator,
    8022  char** ppStatsString,
    8023  VkBool32 detailedMap)
    8024 {
    8025  VMA_ASSERT(allocator && ppStatsString);
    8026  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8027 
    8028  VmaStringBuilder sb(allocator);
    8029  {
    8030  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
    8031  json.BeginObject();
    8032 
    8033  VmaStats stats;
    8034  allocator->CalculateStats(&stats);
    8035 
    8036  json.WriteString("Total");
    8037  VmaPrintStatInfo(json, stats.total);
    8038 
    8039  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
    8040  {
    8041  json.BeginString("Heap ");
    8042  json.ContinueString(heapIndex);
    8043  json.EndString();
    8044  json.BeginObject();
    8045 
    8046  json.WriteString("Size");
    8047  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
    8048 
    8049  json.WriteString("Flags");
    8050  json.BeginArray(true);
    8051  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
    8052  {
    8053  json.WriteString("DEVICE_LOCAL");
    8054  }
    8055  json.EndArray();
    8056 
    8057  if(stats.memoryHeap[heapIndex].blockCount > 0)
    8058  {
    8059  json.WriteString("Stats");
    8060  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
    8061  }
    8062 
    8063  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
    8064  {
    8065  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
    8066  {
    8067  json.BeginString("Type ");
    8068  json.ContinueString(typeIndex);
    8069  json.EndString();
    8070 
    8071  json.BeginObject();
    8072 
    8073  json.WriteString("Flags");
    8074  json.BeginArray(true);
    8075  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
    8076  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
    8077  {
    8078  json.WriteString("DEVICE_LOCAL");
    8079  }
    8080  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
    8081  {
    8082  json.WriteString("HOST_VISIBLE");
    8083  }
    8084  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
    8085  {
    8086  json.WriteString("HOST_COHERENT");
    8087  }
    8088  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
    8089  {
    8090  json.WriteString("HOST_CACHED");
    8091  }
    8092  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
    8093  {
    8094  json.WriteString("LAZILY_ALLOCATED");
    8095  }
    8096  json.EndArray();
    8097 
    8098  if(stats.memoryType[typeIndex].blockCount > 0)
    8099  {
    8100  json.WriteString("Stats");
    8101  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
    8102  }
    8103 
    8104  json.EndObject();
    8105  }
    8106  }
    8107 
    8108  json.EndObject();
    8109  }
    8110  if(detailedMap == VK_TRUE)
    8111  {
    8112  allocator->PrintDetailedMap(json);
    8113  }
    8114 
    8115  json.EndObject();
    8116  }
    8117 
    8118  const size_t len = sb.GetLength();
    8119  char* const pChars = vma_new_array(allocator, char, len + 1);
    8120  if(len > 0)
    8121  {
    8122  memcpy(pChars, sb.GetData(), len);
    8123  }
    8124  pChars[len] = '\0';
    8125  *ppStatsString = pChars;
    8126 }
    8127 
    8128 void vmaFreeStatsString(
    8129  VmaAllocator allocator,
    8130  char* pStatsString)
    8131 {
    8132  if(pStatsString != VMA_NULL)
    8133  {
    8134  VMA_ASSERT(allocator);
    8135  size_t len = strlen(pStatsString);
    8136  vma_delete_array(allocator, pStatsString, len + 1);
    8137  }
    8138 }
    8139 
    8140 #endif // #if VMA_STATS_STRING_ENABLED
    8141 
    8142 /*
    8143 This function is not protected by any mutex because it just reads immutable data.
    8144 */
    8145 VkResult vmaFindMemoryTypeIndex(
    8146  VmaAllocator allocator,
    8147  uint32_t memoryTypeBits,
    8148  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    8149  uint32_t* pMemoryTypeIndex)
    8150 {
    8151  VMA_ASSERT(allocator != VK_NULL_HANDLE);
    8152  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
    8153  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
    8154 
    8155  if(pAllocationCreateInfo->memoryTypeBits != 0)
    8156  {
    8157  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
    8158  }
    8159 
    8160  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
    8161  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
    8162 
    8163  // Convert usage to requiredFlags and preferredFlags.
    8164  switch(pAllocationCreateInfo->usage)
    8165  {
    8166  case VMA_MEMORY_USAGE_UNKNOWN:
    8167  break;
    8168  case VMA_MEMORY_USAGE_GPU_ONLY:
    8169  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    8170  break;
    8171  case VMA_MEMORY_USAGE_CPU_ONLY:
    8172  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
    8173  break;
    8174  case VMA_MEMORY_USAGE_CPU_TO_GPU:
    8175  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    8176  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    8177  break;
    8178  case VMA_MEMORY_USAGE_GPU_TO_CPU:
    8179  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    8180  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
    8181  break;
    8182  default:
    8183  break;
    8184  }
    8185 
    8186  *pMemoryTypeIndex = UINT32_MAX;
    8187  uint32_t minCost = UINT32_MAX;
    8188  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
    8189  memTypeIndex < allocator->GetMemoryTypeCount();
    8190  ++memTypeIndex, memTypeBit <<= 1)
    8191  {
    8192  // This memory type is acceptable according to memoryTypeBits bitmask.
    8193  if((memTypeBit & memoryTypeBits) != 0)
    8194  {
    8195  const VkMemoryPropertyFlags currFlags =
    8196  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
    8197  // This memory type contains requiredFlags.
    8198  if((requiredFlags & ~currFlags) == 0)
    8199  {
    8200  // Calculate cost as number of bits from preferredFlags not present in this memory type.
    8201  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
    8202  // Remember memory type with lowest cost.
    8203  if(currCost < minCost)
    8204  {
    8205  *pMemoryTypeIndex = memTypeIndex;
    8206  if(currCost == 0)
    8207  {
    8208  return VK_SUCCESS;
    8209  }
    8210  minCost = currCost;
    8211  }
    8212  }
    8213  }
    8214  }
    8215  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
    8216 }
    8217 
    8218 VkResult vmaCreatePool(
    8219  VmaAllocator allocator,
    8220  const VmaPoolCreateInfo* pCreateInfo,
    8221  VmaPool* pPool)
    8222 {
    8223  VMA_ASSERT(allocator && pCreateInfo && pPool);
    8224 
    8225  VMA_DEBUG_LOG("vmaCreatePool");
    8226 
    8227  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8228 
    8229  return allocator->CreatePool(pCreateInfo, pPool);
    8230 }
    8231 
    8232 void vmaDestroyPool(
    8233  VmaAllocator allocator,
    8234  VmaPool pool)
    8235 {
    8236  VMA_ASSERT(allocator);
    8237 
    8238  if(pool == VK_NULL_HANDLE)
    8239  {
    8240  return;
    8241  }
    8242 
    8243  VMA_DEBUG_LOG("vmaDestroyPool");
    8244 
    8245  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8246 
    8247  allocator->DestroyPool(pool);
    8248 }
    8249 
    8250 void vmaGetPoolStats(
    8251  VmaAllocator allocator,
    8252  VmaPool pool,
    8253  VmaPoolStats* pPoolStats)
    8254 {
    8255  VMA_ASSERT(allocator && pool && pPoolStats);
    8256 
    8257  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8258 
    8259  allocator->GetPoolStats(pool, pPoolStats);
    8260 }
    8261 
    8262 void vmaMakePoolAllocationsLost(
    8263  VmaAllocator allocator,
    8264  VmaPool pool,
    8265  size_t* pLostAllocationCount)
    8266 {
    8267  VMA_ASSERT(allocator && pool);
    8268 
    8269  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8270 
    8271  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
    8272 }
    8273 
    8274 VkResult vmaAllocateMemory(
    8275  VmaAllocator allocator,
    8276  const VkMemoryRequirements* pVkMemoryRequirements,
    8277  const VmaAllocationCreateInfo* pCreateInfo,
    8278  VmaAllocation* pAllocation,
    8279  VmaAllocationInfo* pAllocationInfo)
    8280 {
    8281  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
    8282 
    8283  VMA_DEBUG_LOG("vmaAllocateMemory");
    8284 
    8285  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8286 
    8287  VkResult result = allocator->AllocateMemory(
    8288  *pVkMemoryRequirements,
    8289  false, // requiresDedicatedAllocation
    8290  false, // prefersDedicatedAllocation
    8291  VK_NULL_HANDLE, // dedicatedBuffer
    8292  VK_NULL_HANDLE, // dedicatedImage
    8293  *pCreateInfo,
    8294  VMA_SUBALLOCATION_TYPE_UNKNOWN,
    8295  pAllocation);
    8296 
    8297  if(pAllocationInfo && result == VK_SUCCESS)
    8298  {
    8299  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8300  }
    8301 
    8302  return result;
    8303 }
    8304 
    8305 VkResult vmaAllocateMemoryForBuffer(
    8306  VmaAllocator allocator,
    8307  VkBuffer buffer,
    8308  const VmaAllocationCreateInfo* pCreateInfo,
    8309  VmaAllocation* pAllocation,
    8310  VmaAllocationInfo* pAllocationInfo)
    8311 {
    8312  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
    8313 
    8314  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
    8315 
    8316  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8317 
    8318  VkMemoryRequirements vkMemReq = {};
    8319  bool requiresDedicatedAllocation = false;
    8320  bool prefersDedicatedAllocation = false;
    8321  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
    8322  requiresDedicatedAllocation,
    8323  prefersDedicatedAllocation);
    8324 
    8325  VkResult result = allocator->AllocateMemory(
    8326  vkMemReq,
    8327  requiresDedicatedAllocation,
    8328  prefersDedicatedAllocation,
    8329  buffer, // dedicatedBuffer
    8330  VK_NULL_HANDLE, // dedicatedImage
    8331  *pCreateInfo,
    8332  VMA_SUBALLOCATION_TYPE_BUFFER,
    8333  pAllocation);
    8334 
    8335  if(pAllocationInfo && result == VK_SUCCESS)
    8336  {
    8337  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8338  }
    8339 
    8340  return result;
    8341 }
    8342 
    8343 VkResult vmaAllocateMemoryForImage(
    8344  VmaAllocator allocator,
    8345  VkImage image,
    8346  const VmaAllocationCreateInfo* pCreateInfo,
    8347  VmaAllocation* pAllocation,
    8348  VmaAllocationInfo* pAllocationInfo)
    8349 {
    8350  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
    8351 
    8352  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
    8353 
    8354  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8355 
    8356  VkResult result = AllocateMemoryForImage(
    8357  allocator,
    8358  image,
    8359  pCreateInfo,
    8360  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
    8361  pAllocation);
    8362 
    8363  if(pAllocationInfo && result == VK_SUCCESS)
    8364  {
    8365  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8366  }
    8367 
    8368  return result;
    8369 }
    8370 
    8371 void vmaFreeMemory(
    8372  VmaAllocator allocator,
    8373  VmaAllocation allocation)
    8374 {
    8375  VMA_ASSERT(allocator && allocation);
    8376 
    8377  VMA_DEBUG_LOG("vmaFreeMemory");
    8378 
    8379  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8380 
    8381  allocator->FreeMemory(allocation);
    8382 }
    8383 
    8384 void vmaGetAllocationInfo(
    8385  VmaAllocator allocator,
    8386  VmaAllocation allocation,
    8387  VmaAllocationInfo* pAllocationInfo)
    8388 {
    8389  VMA_ASSERT(allocator && allocation && pAllocationInfo);
    8390 
    8391  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8392 
    8393  allocator->GetAllocationInfo(allocation, pAllocationInfo);
    8394 }
    8395 
    8396 void vmaSetAllocationUserData(
    8397  VmaAllocator allocator,
    8398  VmaAllocation allocation,
    8399  void* pUserData)
    8400 {
    8401  VMA_ASSERT(allocator && allocation);
    8402 
    8403  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8404 
    8405  allocation->SetUserData(allocator, pUserData);
    8406 }
    8407 
    8408 void vmaCreateLostAllocation(
    8409  VmaAllocator allocator,
    8410  VmaAllocation* pAllocation)
    8411 {
    8412  VMA_ASSERT(allocator && pAllocation);
    8413 
    8414  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
    8415 
    8416  allocator->CreateLostAllocation(pAllocation);
    8417 }
    8418 
    8419 VkResult vmaMapMemory(
    8420  VmaAllocator allocator,
    8421  VmaAllocation allocation,
    8422  void** ppData)
    8423 {
    8424  VMA_ASSERT(allocator && allocation && ppData);
    8425 
    8426  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8427 
    8428  return allocator->Map(allocation, ppData);
    8429 }
    8430 
    8431 void vmaUnmapMemory(
    8432  VmaAllocator allocator,
    8433  VmaAllocation allocation)
    8434 {
    8435  VMA_ASSERT(allocator && allocation);
    8436 
    8437  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8438 
    8439  allocator->Unmap(allocation);
    8440 }
    8441 
    8442 VkResult vmaDefragment(
    8443  VmaAllocator allocator,
    8444  VmaAllocation* pAllocations,
    8445  size_t allocationCount,
    8446  VkBool32* pAllocationsChanged,
    8447  const VmaDefragmentationInfo *pDefragmentationInfo,
    8448  VmaDefragmentationStats* pDefragmentationStats)
    8449 {
    8450  VMA_ASSERT(allocator && pAllocations);
    8451 
    8452  VMA_DEBUG_LOG("vmaDefragment");
    8453 
    8454  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8455 
    8456  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
    8457 }
    8458 
    8459 VkResult vmaCreateBuffer(
    8460  VmaAllocator allocator,
    8461  const VkBufferCreateInfo* pBufferCreateInfo,
    8462  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    8463  VkBuffer* pBuffer,
    8464  VmaAllocation* pAllocation,
    8465  VmaAllocationInfo* pAllocationInfo)
    8466 {
    8467  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
    8468 
    8469  VMA_DEBUG_LOG("vmaCreateBuffer");
    8470 
    8471  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8472 
    8473  *pBuffer = VK_NULL_HANDLE;
    8474  *pAllocation = VK_NULL_HANDLE;
    8475 
    8476  // 1. Create VkBuffer.
    8477  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
    8478  allocator->m_hDevice,
    8479  pBufferCreateInfo,
    8480  allocator->GetAllocationCallbacks(),
    8481  pBuffer);
    8482  if(res >= 0)
    8483  {
    8484  // 2. vkGetBufferMemoryRequirements.
    8485  VkMemoryRequirements vkMemReq = {};
    8486  bool requiresDedicatedAllocation = false;
    8487  bool prefersDedicatedAllocation = false;
    8488  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
    8489  requiresDedicatedAllocation, prefersDedicatedAllocation);
    8490 
    8491  // Make sure alignment requirements for specific buffer usages reported
    8492  // in Physical Device Properties are included in alignment reported by memory requirements.
    8493  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
    8494  {
    8495  VMA_ASSERT(vkMemReq.alignment %
    8496  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
    8497  }
    8498  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
    8499  {
    8500  VMA_ASSERT(vkMemReq.alignment %
    8501  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
    8502  }
    8503  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
    8504  {
    8505  VMA_ASSERT(vkMemReq.alignment %
    8506  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
    8507  }
    8508 
    8509  // 3. Allocate memory using allocator.
    8510  res = allocator->AllocateMemory(
    8511  vkMemReq,
    8512  requiresDedicatedAllocation,
    8513  prefersDedicatedAllocation,
    8514  *pBuffer, // dedicatedBuffer
    8515  VK_NULL_HANDLE, // dedicatedImage
    8516  *pAllocationCreateInfo,
    8517  VMA_SUBALLOCATION_TYPE_BUFFER,
    8518  pAllocation);
    8519  if(res >= 0)
    8520  {
    8521  // 3. Bind buffer with memory.
    8522  res = (*allocator->GetVulkanFunctions().vkBindBufferMemory)(
    8523  allocator->m_hDevice,
    8524  *pBuffer,
    8525  (*pAllocation)->GetMemory(),
    8526  (*pAllocation)->GetOffset());
    8527  if(res >= 0)
    8528  {
    8529  // All steps succeeded.
    8530  if(pAllocationInfo != VMA_NULL)
    8531  {
    8532  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8533  }
    8534  return VK_SUCCESS;
    8535  }
    8536  allocator->FreeMemory(*pAllocation);
    8537  *pAllocation = VK_NULL_HANDLE;
    8538  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
    8539  *pBuffer = VK_NULL_HANDLE;
    8540  return res;
    8541  }
    8542  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
    8543  *pBuffer = VK_NULL_HANDLE;
    8544  return res;
    8545  }
    8546  return res;
    8547 }
    8548 
    8549 void vmaDestroyBuffer(
    8550  VmaAllocator allocator,
    8551  VkBuffer buffer,
    8552  VmaAllocation allocation)
    8553 {
    8554  if(buffer != VK_NULL_HANDLE)
    8555  {
    8556  VMA_ASSERT(allocator);
    8557 
    8558  VMA_DEBUG_LOG("vmaDestroyBuffer");
    8559 
    8560  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8561 
    8562  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
    8563 
    8564  allocator->FreeMemory(allocation);
    8565  }
    8566 }
    8567 
    8568 VkResult vmaCreateImage(
    8569  VmaAllocator allocator,
    8570  const VkImageCreateInfo* pImageCreateInfo,
    8571  const VmaAllocationCreateInfo* pAllocationCreateInfo,
    8572  VkImage* pImage,
    8573  VmaAllocation* pAllocation,
    8574  VmaAllocationInfo* pAllocationInfo)
    8575 {
    8576  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
    8577 
    8578  VMA_DEBUG_LOG("vmaCreateImage");
    8579 
    8580  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8581 
    8582  *pImage = VK_NULL_HANDLE;
    8583  *pAllocation = VK_NULL_HANDLE;
    8584 
    8585  // 1. Create VkImage.
    8586  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
    8587  allocator->m_hDevice,
    8588  pImageCreateInfo,
    8589  allocator->GetAllocationCallbacks(),
    8590  pImage);
    8591  if(res >= 0)
    8592  {
    8593  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
    8594  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
    8595  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
    8596 
    8597  // 2. Allocate memory using allocator.
    8598  res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation);
    8599  if(res >= 0)
    8600  {
    8601  // 3. Bind image with memory.
    8602  res = (*allocator->GetVulkanFunctions().vkBindImageMemory)(
    8603  allocator->m_hDevice,
    8604  *pImage,
    8605  (*pAllocation)->GetMemory(),
    8606  (*pAllocation)->GetOffset());
    8607  if(res >= 0)
    8608  {
    8609  // All steps succeeded.
    8610  if(pAllocationInfo != VMA_NULL)
    8611  {
    8612  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
    8613  }
    8614  return VK_SUCCESS;
    8615  }
    8616  allocator->FreeMemory(*pAllocation);
    8617  *pAllocation = VK_NULL_HANDLE;
    8618  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
    8619  *pImage = VK_NULL_HANDLE;
    8620  return res;
    8621  }
    8622  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
    8623  *pImage = VK_NULL_HANDLE;
    8624  return res;
    8625  }
    8626  return res;
    8627 }
    8628 
    8629 void vmaDestroyImage(
    8630  VmaAllocator allocator,
    8631  VkImage image,
    8632  VmaAllocation allocation)
    8633 {
    8634  if(image != VK_NULL_HANDLE)
    8635  {
    8636  VMA_ASSERT(allocator);
    8637 
    8638  VMA_DEBUG_LOG("vmaDestroyImage");
    8639 
    8640  VMA_DEBUG_GLOBAL_MUTEX_LOCK
    8641 
    8642  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
    8643 
    8644  allocator->FreeMemory(allocation);
    8645  }
    8646 }
    8647 
    8648 #endif // #ifdef VMA_IMPLEMENTATION
    VmaVulkanFunctions::vkGetPhysicalDeviceProperties
    PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
    Definition: vk_mem_alloc.h:793
    +
    VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
    Set this flag if the allocation should have its own memory block.
    Definition: vk_mem_alloc.h:1047
    vmaUnmapMemory
    void vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
    Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
    -
    VmaAllocatorCreateInfo::physicalDevice
    VkPhysicalDevice physicalDevice
    Vulkan physical device.
    Definition: vk_mem_alloc.h:783
    +
    VmaAllocatorCreateInfo::physicalDevice
    VkPhysicalDevice physicalDevice
    Vulkan physical device.
    Definition: vk_mem_alloc.h:818
    vmaDefragment
    VkResult vmaDefragment(VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
    Compacts memory by moving allocations.
    -
    VmaVulkanFunctions::vkCreateBuffer
    PFN_vkCreateBuffer vkCreateBuffer
    Definition: vk_mem_alloc.h:768
    +
    VmaVulkanFunctions::vkCreateBuffer
    PFN_vkCreateBuffer vkCreateBuffer
    Definition: vk_mem_alloc.h:803
    vmaFreeStatsString
    void vmaFreeStatsString(VmaAllocator allocator, char *pStatsString)
    VmaStats
    struct VmaStats VmaStats
    General statistics from current state of Allocator.
    -
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:968
    -
    VmaVulkanFunctions::vkMapMemory
    PFN_vkMapMemory vkMapMemory
    Definition: vk_mem_alloc.h:762
    -
    VmaAllocationInfo::deviceMemory
    VkDeviceMemory deviceMemory
    Handle to Vulkan memory object.
    Definition: vk_mem_alloc.h:1277
    -
    VmaAllocatorCreateInfo::flags
    VmaAllocatorCreateFlags flags
    Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
    Definition: vk_mem_alloc.h:780
    -
    VmaDefragmentationInfo::maxAllocationsToMove
    uint32_t maxAllocationsToMove
    Maximum number of allocations that can be moved to different place.
    Definition: vk_mem_alloc.h:1443
    -
    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT
    Use this flag if you always allocate only buffers and linear images or only optimal images out of thi...
    Definition: vk_mem_alloc.h:1147
    +
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:1004
    +
    VmaVulkanFunctions::vkMapMemory
    PFN_vkMapMemory vkMapMemory
    Definition: vk_mem_alloc.h:797
    +
    VmaAllocationInfo::deviceMemory
    VkDeviceMemory deviceMemory
    Handle to Vulkan memory object.
    Definition: vk_mem_alloc.h:1315
    +
    VmaAllocatorCreateInfo::flags
    VmaAllocatorCreateFlags flags
    Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
    Definition: vk_mem_alloc.h:815
    +
    VmaDefragmentationInfo::maxAllocationsToMove
    uint32_t maxAllocationsToMove
    Maximum number of allocations that can be moved to different place.
    Definition: vk_mem_alloc.h:1481
    +
    VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT
    Use this flag if you always allocate only buffers and linear images or only optimal images out of thi...
    Definition: vk_mem_alloc.h:1185
    vmaMakePoolAllocationsLost
    void vmaMakePoolAllocationsLost(VmaAllocator allocator, VmaPool pool, size_t *pLostAllocationCount)
    Marks all allocations in given pool as lost if they are not used in current frame or VmaPoolCreateInf...
    -
    VmaPoolStats::size
    VkDeviceSize size
    Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
    Definition: vk_mem_alloc.h:1201
    -
    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
    Definition: vk_mem_alloc.h:1046
    -
    VmaAllocatorCreateFlags
    VkFlags VmaAllocatorCreateFlags
    Definition: vk_mem_alloc.h:751
    -
    VmaAllocationCreateInfo::preferredFlags
    VkMemoryPropertyFlags preferredFlags
    Flags that preferably should be set in a memory type chosen for an allocation.
    Definition: vk_mem_alloc.h:1084
    -
    VMA_MEMORY_USAGE_MAX_ENUM
    Definition: vk_mem_alloc.h:993
    -
    VmaAllocatorCreateInfo::pAllocationCallbacks
    const VkAllocationCallbacks * pAllocationCallbacks
    Custom CPU memory allocation callbacks.
    Definition: vk_mem_alloc.h:792
    +
    VmaPoolStats::size
    VkDeviceSize size
    Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
    Definition: vk_mem_alloc.h:1239
    +
    VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
    Definition: vk_mem_alloc.h:1084
    +
    VmaAllocatorCreateFlags
    VkFlags VmaAllocatorCreateFlags
    Definition: vk_mem_alloc.h:786
    +
    VmaAllocationCreateInfo::preferredFlags
    VkMemoryPropertyFlags preferredFlags
    Flags that preferably should be set in a memory type chosen for an allocation.
    Definition: vk_mem_alloc.h:1122
    +
    VMA_MEMORY_USAGE_MAX_ENUM
    Definition: vk_mem_alloc.h:1031
    +
    VmaAllocatorCreateInfo::pAllocationCallbacks
    const VkAllocationCallbacks * pAllocationCallbacks
    Custom CPU memory allocation callbacks.
    Definition: vk_mem_alloc.h:827
    vmaCalculateStats
    void vmaCalculateStats(VmaAllocator allocator, VmaStats *pStats)
    Retrieves statistics from current state of the Allocator.
    -
    VmaAllocatorCreateInfo::pVulkanFunctions
    const VmaVulkanFunctions * pVulkanFunctions
    Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1...
    Definition: vk_mem_alloc.h:845
    -
    VmaAllocatorCreateInfo
    Description of a Allocator to be created.
    Definition: vk_mem_alloc.h:777
    +
    VmaAllocatorCreateInfo::pVulkanFunctions
    const VmaVulkanFunctions * pVulkanFunctions
    Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1...
    Definition: vk_mem_alloc.h:880
    +
    VmaAllocatorCreateInfo
    Description of a Allocator to be created.
    Definition: vk_mem_alloc.h:812
    vmaDestroyAllocator
    void vmaDestroyAllocator(VmaAllocator allocator)
    Destroys allocator object.
    -
    VmaAllocationCreateFlagBits
    VmaAllocationCreateFlagBits
    Flags to be passed as VmaAllocationCreateInfo::flags.
    Definition: vk_mem_alloc.h:997
    +
    VmaAllocationCreateFlagBits
    VmaAllocationCreateFlagBits
    Flags to be passed as VmaAllocationCreateInfo::flags.
    Definition: vk_mem_alloc.h:1035
    vmaGetAllocationInfo
    void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
    Returns current information about specified allocation.
    -
    VmaStatInfo::allocationSizeMax
    VkDeviceSize allocationSizeMax
    Definition: vk_mem_alloc.h:910
    -
    VmaVulkanFunctions::vkBindImageMemory
    PFN_vkBindImageMemory vkBindImageMemory
    Definition: vk_mem_alloc.h:765
    -
    VmaStatInfo::unusedBytes
    VkDeviceSize unusedBytes
    Total number of bytes occupied by unused ranges.
    Definition: vk_mem_alloc.h:909
    -
    VmaVulkanFunctions::vkGetImageMemoryRequirements2KHR
    PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR
    Definition: vk_mem_alloc.h:773
    -
    VmaDefragmentationStats
    Statistics returned by function vmaDefragment().
    Definition: vk_mem_alloc.h:1447
    +
    VmaStatInfo::allocationSizeMax
    VkDeviceSize allocationSizeMax
    Definition: vk_mem_alloc.h:945
    +
    VmaVulkanFunctions::vkBindImageMemory
    PFN_vkBindImageMemory vkBindImageMemory
    Definition: vk_mem_alloc.h:800
    +
    VmaStatInfo::unusedBytes
    VkDeviceSize unusedBytes
    Total number of bytes occupied by unused ranges.
    Definition: vk_mem_alloc.h:944
    +
    VmaVulkanFunctions::vkGetImageMemoryRequirements2KHR
    PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR
    Definition: vk_mem_alloc.h:808
    +
    VmaDefragmentationStats
    Statistics returned by function vmaDefragment().
    Definition: vk_mem_alloc.h:1485
    vmaFreeMemory
    void vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
    Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().
    -
    VmaAllocatorCreateInfo::frameInUseCount
    uint32_t frameInUseCount
    Maximum number of additional frames that are in use at the same time as current frame.
    Definition: vk_mem_alloc.h:809
    -
    VmaStats::total
    VmaStatInfo total
    Definition: vk_mem_alloc.h:919
    -
    VmaDefragmentationStats::deviceMemoryBlocksFreed
    uint32_t deviceMemoryBlocksFreed
    Number of empty VkDeviceMemory objects that have been released to the system.
    Definition: vk_mem_alloc.h:1455
    -
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:1068
    -
    VmaDefragmentationInfo::maxBytesToMove
    VkDeviceSize maxBytesToMove
    Maximum total numbers of bytes that can be copied while moving allocations to different places...
    Definition: vk_mem_alloc.h:1438
    -
    VmaVulkanFunctions::vkGetBufferMemoryRequirements
    PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
    Definition: vk_mem_alloc.h:766
    -
    PFN_vmaAllocateDeviceMemoryFunction
    void(VKAPI_PTR * PFN_vmaAllocateDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
    Callback function called after successful vkAllocateMemory.
    Definition: vk_mem_alloc.h:693
    -
    VmaAllocatorCreateInfo::device
    VkDevice device
    Vulkan device.
    Definition: vk_mem_alloc.h:786
    -
    VmaPoolCreateInfo
    Describes parameter of created VmaPool.
    Definition: vk_mem_alloc.h:1155
    -
    VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
    Definition: vk_mem_alloc.h:1149
    -
    VmaAllocationInfo::size
    VkDeviceSize size
    Size of this allocation, in bytes.
    Definition: vk_mem_alloc.h:1287
    +
    VmaAllocatorCreateInfo::frameInUseCount
    uint32_t frameInUseCount
    Maximum number of additional frames that are in use at the same time as current frame.
    Definition: vk_mem_alloc.h:844
    +
    VmaStats::total
    VmaStatInfo total
    Definition: vk_mem_alloc.h:954
    +
    VmaDefragmentationStats::deviceMemoryBlocksFreed
    uint32_t deviceMemoryBlocksFreed
    Number of empty VkDeviceMemory objects that have been released to the system.
    Definition: vk_mem_alloc.h:1493
    +
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:1106
    +
    VmaDefragmentationInfo::maxBytesToMove
    VkDeviceSize maxBytesToMove
    Maximum total numbers of bytes that can be copied while moving allocations to different places...
    Definition: vk_mem_alloc.h:1476
    +
    VmaVulkanFunctions::vkGetBufferMemoryRequirements
    PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
    Definition: vk_mem_alloc.h:801
    +
    PFN_vmaAllocateDeviceMemoryFunction
    void(VKAPI_PTR * PFN_vmaAllocateDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
    Callback function called after successful vkAllocateMemory.
    Definition: vk_mem_alloc.h:728
    +
    VmaAllocatorCreateInfo::device
    VkDevice device
    Vulkan device.
    Definition: vk_mem_alloc.h:821
    +
    VmaPoolCreateInfo
    Describes parameter of created VmaPool.
    Definition: vk_mem_alloc.h:1193
    +
    VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
    Definition: vk_mem_alloc.h:1187
    +
    VmaAllocationInfo::size
    VkDeviceSize size
    Size of this allocation, in bytes.
    Definition: vk_mem_alloc.h:1325
    vmaGetMemoryTypeProperties
    void vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
    Given Memory Type Index, returns Property Flags of this memory type.
    -
    VmaVulkanFunctions::vkUnmapMemory
    PFN_vkUnmapMemory vkUnmapMemory
    Definition: vk_mem_alloc.h:763
    -
    VmaAllocationCreateInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
    Definition: vk_mem_alloc.h:1105
    -
    VmaPoolCreateInfo::minBlockCount
    size_t minBlockCount
    Minimum number of blocks to be always allocated in this pool, even if they stay empty.
    Definition: vk_mem_alloc.h:1171
    -
    VmaPoolStats::allocationCount
    size_t allocationCount
    Number of VmaAllocation objects created from this pool that were not destroyed or lost...
    Definition: vk_mem_alloc.h:1207
    +
    VmaVulkanFunctions::vkUnmapMemory
    PFN_vkUnmapMemory vkUnmapMemory
    Definition: vk_mem_alloc.h:798
    +
    VmaAllocationCreateInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
    Definition: vk_mem_alloc.h:1143
    +
    VmaPoolCreateInfo::minBlockCount
    size_t minBlockCount
    Minimum number of blocks to be always allocated in this pool, even if they stay empty.
    Definition: vk_mem_alloc.h:1209
    +
    VmaPoolStats::allocationCount
    size_t allocationCount
    Number of VmaAllocation objects created from this pool that were not destroyed or lost...
    Definition: vk_mem_alloc.h:1245
    VmaVulkanFunctions
    struct VmaVulkanFunctions VmaVulkanFunctions
    Pointers to some Vulkan functions - a subset used by the library.
    -
    VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
    Definition: vk_mem_alloc.h:749
    -
    VmaPoolCreateInfo::memoryTypeIndex
    uint32_t memoryTypeIndex
    Vulkan memory type index to allocate this pool from.
    Definition: vk_mem_alloc.h:1158
    +
    VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
    Definition: vk_mem_alloc.h:784
    +
    VmaPoolCreateInfo::memoryTypeIndex
    uint32_t memoryTypeIndex
    Vulkan memory type index to allocate this pool from.
    Definition: vk_mem_alloc.h:1196
    vmaFindMemoryTypeIndex
    VkResult vmaFindMemoryTypeIndex(VmaAllocator allocator, uint32_t memoryTypeBits, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
    -
    VmaMemoryUsage
    VmaMemoryUsage
    Definition: vk_mem_alloc.h:947
    +
    VmaMemoryUsage
    VmaMemoryUsage
    Definition: vk_mem_alloc.h:982
    VmaAllocationInfo
    struct VmaAllocationInfo VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    -
    VmaDefragmentationInfo
    Optional configuration parameters to be passed to function vmaDefragment().
    Definition: vk_mem_alloc.h:1433
    +
    VmaDefragmentationInfo
    Optional configuration parameters to be passed to function vmaDefragment().
    Definition: vk_mem_alloc.h:1471
    VmaPoolCreateInfo
    struct VmaPoolCreateInfo VmaPoolCreateInfo
    Describes parameter of created VmaPool.
    vmaDestroyPool
    void vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
    Destroys VmaPool object and frees Vulkan device memory.
    -
    VmaDefragmentationStats::bytesFreed
    VkDeviceSize bytesFreed
    Total number of bytes that have been released to the system by freeing empty VkDeviceMemory objects...
    Definition: vk_mem_alloc.h:1451
    -
    VMA_MEMORY_USAGE_CPU_TO_GPU
    Definition: vk_mem_alloc.h:984
    -
    VmaAllocationCreateInfo::memoryTypeBits
    uint32_t memoryTypeBits
    Bitmask containing one bit set for every memory type acceptable for this allocation.
    Definition: vk_mem_alloc.h:1092
    -
    VmaVulkanFunctions::vkBindBufferMemory
    PFN_vkBindBufferMemory vkBindBufferMemory
    Definition: vk_mem_alloc.h:764
    +
    VmaDefragmentationStats::bytesFreed
    VkDeviceSize bytesFreed
    Total number of bytes that have been released to the system by freeing empty VkDeviceMemory objects...
    Definition: vk_mem_alloc.h:1489
    +
    VMA_MEMORY_USAGE_CPU_TO_GPU
    Definition: vk_mem_alloc.h:1021
    +
    VmaAllocationCreateInfo::memoryTypeBits
    uint32_t memoryTypeBits
    Bitmask containing one bit set for every memory type acceptable for this allocation.
    Definition: vk_mem_alloc.h:1130
    +
    VmaVulkanFunctions::vkBindBufferMemory
    PFN_vkBindBufferMemory vkBindBufferMemory
    Definition: vk_mem_alloc.h:799
    vmaGetPoolStats
    void vmaGetPoolStats(VmaAllocator allocator, VmaPool pool, VmaPoolStats *pPoolStats)
    Retrieves statistics of existing VmaPool object.
    VmaDefragmentationInfo
    struct VmaDefragmentationInfo VmaDefragmentationInfo
    Optional configuration parameters to be passed to function vmaDefragment().
    -
    VmaStats
    General statistics from current state of Allocator.
    Definition: vk_mem_alloc.h:915
    -
    PFN_vmaFreeDeviceMemoryFunction
    void(VKAPI_PTR * PFN_vmaFreeDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
    Callback function called before vkFreeMemory.
    Definition: vk_mem_alloc.h:699
    +
    VmaStats
    General statistics from current state of Allocator.
    Definition: vk_mem_alloc.h:950
    +
    PFN_vmaFreeDeviceMemoryFunction
    void(VKAPI_PTR * PFN_vmaFreeDeviceMemoryFunction)(VmaAllocator allocator, uint32_t memoryType, VkDeviceMemory memory, VkDeviceSize size)
    Callback function called before vkFreeMemory.
    Definition: vk_mem_alloc.h:734
    vmaSetAllocationUserData
    void vmaSetAllocationUserData(VmaAllocator allocator, VmaAllocation allocation, void *pUserData)
    Sets pUserData in given allocation to new value.
    vmaCreatePool
    VkResult vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
    Allocates Vulkan device memory and creates VmaPool object.
    -
    VmaAllocatorCreateFlagBits
    VmaAllocatorCreateFlagBits
    Flags for created VmaAllocator.
    Definition: vk_mem_alloc.h:720
    +
    VmaAllocatorCreateFlagBits
    VmaAllocatorCreateFlagBits
    Flags for created VmaAllocator.
    Definition: vk_mem_alloc.h:755
    VmaStatInfo
    struct VmaStatInfo VmaStatInfo
    Calculated statistics of memory usage in entire allocator.
    -
    VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
    Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
    Definition: vk_mem_alloc.h:725
    -
    VmaDefragmentationStats::allocationsMoved
    uint32_t allocationsMoved
    Number of allocations that have been moved to different places.
    Definition: vk_mem_alloc.h:1453
    +
    VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
    Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
    Definition: vk_mem_alloc.h:760
    +
    VmaDefragmentationStats::allocationsMoved
    uint32_t allocationsMoved
    Number of allocations that have been moved to different places.
    Definition: vk_mem_alloc.h:1491
    vmaCreateLostAllocation
    void vmaCreateLostAllocation(VmaAllocator allocator, VmaAllocation *pAllocation)
    Creates new allocation that is in lost state from the beginning.
    -
    VmaAllocationCreateInfo::requiredFlags
    VkMemoryPropertyFlags requiredFlags
    Flags that must be set in a Memory Type chosen for an allocation.
    Definition: vk_mem_alloc.h:1079
    -
    VmaPoolStats::unusedRangeSizeMax
    VkDeviceSize unusedRangeSizeMax
    Size of the largest continuous free memory region.
    Definition: vk_mem_alloc.h:1217
    +
    VmaAllocationCreateInfo::requiredFlags
    VkMemoryPropertyFlags requiredFlags
    Flags that must be set in a Memory Type chosen for an allocation.
    Definition: vk_mem_alloc.h:1117
    +
    VmaPoolStats::unusedRangeSizeMax
    VkDeviceSize unusedRangeSizeMax
    Size of the largest continuous free memory region.
    Definition: vk_mem_alloc.h:1255
    vmaBuildStatsString
    void vmaBuildStatsString(VmaAllocator allocator, char **ppStatsString, VkBool32 detailedMap)
    Builds and returns statistics as string in JSON format.
    -
    VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
    PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
    Definition: vk_mem_alloc.h:759
    -
    VmaStatInfo
    Calculated statistics of memory usage in entire allocator.
    Definition: vk_mem_alloc.h:898
    -
    VmaPoolCreateInfo::blockSize
    VkDeviceSize blockSize
    Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes.
    Definition: vk_mem_alloc.h:1166
    -
    VmaDeviceMemoryCallbacks
    Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
    Definition: vk_mem_alloc.h:712
    +
    VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
    PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
    Definition: vk_mem_alloc.h:794
    +
    VmaStatInfo
    Calculated statistics of memory usage in entire allocator.
    Definition: vk_mem_alloc.h:933
    +
    VmaPoolCreateInfo::blockSize
    VkDeviceSize blockSize
    Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes.
    Definition: vk_mem_alloc.h:1204
    +
    VmaDeviceMemoryCallbacks
    Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
    Definition: vk_mem_alloc.h:747
    vmaCreateBuffer
    VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    -
    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
    Definition: vk_mem_alloc.h:1053
    -
    VmaStatInfo::unusedRangeSizeMin
    VkDeviceSize unusedRangeSizeMin
    Definition: vk_mem_alloc.h:911
    -
    VmaDeviceMemoryCallbacks::pfnFree
    PFN_vmaFreeDeviceMemoryFunction pfnFree
    Optional, can be null.
    Definition: vk_mem_alloc.h:716
    -
    VmaPoolCreateInfo::flags
    VmaPoolCreateFlags flags
    Use combination of VmaPoolCreateFlagBits.
    Definition: vk_mem_alloc.h:1161
    -
    VMA_MEMORY_USAGE_GPU_TO_CPU
    Definition: vk_mem_alloc.h:992
    +
    VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
    Definition: vk_mem_alloc.h:1091
    +
    VmaStatInfo::unusedRangeSizeMin
    VkDeviceSize unusedRangeSizeMin
    Definition: vk_mem_alloc.h:946
    +
    VmaDeviceMemoryCallbacks::pfnFree
    PFN_vmaFreeDeviceMemoryFunction pfnFree
    Optional, can be null.
    Definition: vk_mem_alloc.h:751
    +
    VmaPoolCreateInfo::flags
    VmaPoolCreateFlags flags
    Use combination of VmaPoolCreateFlagBits.
    Definition: vk_mem_alloc.h:1199
    +
    VMA_MEMORY_USAGE_GPU_TO_CPU
    Definition: vk_mem_alloc.h:1030
    VmaPoolStats
    struct VmaPoolStats VmaPoolStats
    Describes parameter of existing VmaPool.
    vmaCreateImage
    VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    Function similar to vmaCreateBuffer().
    -
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:1074
    -
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:1065
    -
    VmaStatInfo::blockCount
    uint32_t blockCount
    Number of VkDeviceMemory Vulkan memory blocks allocated.
    Definition: vk_mem_alloc.h:901
    -
    VmaVulkanFunctions::vkFreeMemory
    PFN_vkFreeMemory vkFreeMemory
    Definition: vk_mem_alloc.h:761
    -
    VmaPoolCreateInfo::maxBlockCount
    size_t maxBlockCount
    Maximum number of blocks that can be allocated in this pool.
    Definition: vk_mem_alloc.h:1179
    -
    VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
    const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
    Informative callbacks for vkAllocateMemory, vkFreeMemory.
    Definition: vk_mem_alloc.h:795
    -
    VmaPoolStats::unusedRangeCount
    size_t unusedRangeCount
    Number of continuous memory ranges in the pool not used by any VmaAllocation.
    Definition: vk_mem_alloc.h:1210
    -
    VmaAllocationCreateFlags
    VkFlags VmaAllocationCreateFlags
    Definition: vk_mem_alloc.h:1063
    -
    VmaAllocationCreateInfo::pool
    VmaPool pool
    Pool that this allocation should be created in.
    Definition: vk_mem_alloc.h:1098
    +
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:1112
    +
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:1103
    +
    VmaStatInfo::blockCount
    uint32_t blockCount
    Number of VkDeviceMemory Vulkan memory blocks allocated.
    Definition: vk_mem_alloc.h:936
    +
    VmaVulkanFunctions::vkFreeMemory
    PFN_vkFreeMemory vkFreeMemory
    Definition: vk_mem_alloc.h:796
    +
    VmaPoolCreateInfo::maxBlockCount
    size_t maxBlockCount
    Maximum number of blocks that can be allocated in this pool.
    Definition: vk_mem_alloc.h:1217
    +
    VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
    const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
    Informative callbacks for vkAllocateMemory, vkFreeMemory.
    Definition: vk_mem_alloc.h:830
    +
    VmaPoolStats::unusedRangeCount
    size_t unusedRangeCount
    Number of continuous memory ranges in the pool not used by any VmaAllocation.
    Definition: vk_mem_alloc.h:1248
    +
    VmaAllocationCreateFlags
    VkFlags VmaAllocationCreateFlags
    Definition: vk_mem_alloc.h:1101
    +
    VmaAllocationCreateInfo::pool
    VmaPool pool
    Pool that this allocation should be created in.
    Definition: vk_mem_alloc.h:1136
    vmaGetMemoryProperties
    void vmaGetMemoryProperties(VmaAllocator allocator, const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
    -
    VmaAllocatorCreateInfo::pHeapSizeLimit
    const VkDeviceSize * pHeapSizeLimit
    Either NULL or a pointer to an array of limits on maximum number of bytes that can be allocated out o...
    Definition: vk_mem_alloc.h:833
    -
    VmaStats::memoryType
    VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
    Definition: vk_mem_alloc.h:917
    -
    VMA_ALLOCATION_CREATE_MAPPED_BIT
    Set this flag to use a memory that will be persistently mapped and retrieve pointer to it...
    Definition: vk_mem_alloc.h:1033
    -
    VmaStatInfo::allocationSizeMin
    VkDeviceSize allocationSizeMin
    Definition: vk_mem_alloc.h:910
    -
    VmaVulkanFunctions::vkCreateImage
    PFN_vkCreateImage vkCreateImage
    Definition: vk_mem_alloc.h:770
    -
    VmaDeviceMemoryCallbacks::pfnAllocate
    PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
    Optional, can be null.
    Definition: vk_mem_alloc.h:714
    -
    VmaVulkanFunctions::vkDestroyBuffer
    PFN_vkDestroyBuffer vkDestroyBuffer
    Definition: vk_mem_alloc.h:769
    +
    VmaAllocatorCreateInfo::pHeapSizeLimit
    const VkDeviceSize * pHeapSizeLimit
    Either NULL or a pointer to an array of limits on maximum number of bytes that can be allocated out o...
    Definition: vk_mem_alloc.h:868
    +
    VmaStats::memoryType
    VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
    Definition: vk_mem_alloc.h:952
    +
    VMA_ALLOCATION_CREATE_MAPPED_BIT
    Set this flag to use a memory that will be persistently mapped and retrieve pointer to it...
    Definition: vk_mem_alloc.h:1071
    +
    VmaStatInfo::allocationSizeMin
    VkDeviceSize allocationSizeMin
    Definition: vk_mem_alloc.h:945
    +
    VmaVulkanFunctions::vkCreateImage
    PFN_vkCreateImage vkCreateImage
    Definition: vk_mem_alloc.h:805
    +
    VmaDeviceMemoryCallbacks::pfnAllocate
    PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
    Optional, can be null.
    Definition: vk_mem_alloc.h:749
    +
    VmaVulkanFunctions::vkDestroyBuffer
    PFN_vkDestroyBuffer vkDestroyBuffer
    Definition: vk_mem_alloc.h:804
    vmaMapMemory
    VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
    Maps memory represented by given allocation and returns pointer to it.
    -
    VmaPoolCreateInfo::frameInUseCount
    uint32_t frameInUseCount
    Maximum number of additional frames that are in use at the same time as current frame.
    Definition: vk_mem_alloc.h:1193
    +
    VmaPoolCreateInfo::frameInUseCount
    uint32_t frameInUseCount
    Maximum number of additional frames that are in use at the same time as current frame.
    Definition: vk_mem_alloc.h:1231
    vmaAllocateMemoryForImage
    VkResult vmaAllocateMemoryForImage(VmaAllocator allocator, VkImage image, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    Function similar to vmaAllocateMemoryForBuffer().
    VmaAllocatorCreateInfo
    struct VmaAllocatorCreateInfo VmaAllocatorCreateInfo
    Description of a Allocator to be created.
    -
    VmaAllocationInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
    Definition: vk_mem_alloc.h:1301
    -
    VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
    VkDeviceSize preferredLargeHeapBlockSize
    Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB...
    Definition: vk_mem_alloc.h:789
    -
    VmaStatInfo::allocationSizeAvg
    VkDeviceSize allocationSizeAvg
    Definition: vk_mem_alloc.h:910
    -
    VmaStatInfo::usedBytes
    VkDeviceSize usedBytes
    Total number of bytes occupied by all allocations.
    Definition: vk_mem_alloc.h:907
    +
    VmaAllocationInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
    Definition: vk_mem_alloc.h:1339
    +
    VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
    VkDeviceSize preferredLargeHeapBlockSize
    Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB...
    Definition: vk_mem_alloc.h:824
    +
    VmaStatInfo::allocationSizeAvg
    VkDeviceSize allocationSizeAvg
    Definition: vk_mem_alloc.h:945
    +
    VmaStatInfo::usedBytes
    VkDeviceSize usedBytes
    Total number of bytes occupied by all allocations.
    Definition: vk_mem_alloc.h:942
    VmaDeviceMemoryCallbacks
    struct VmaDeviceMemoryCallbacks VmaDeviceMemoryCallbacks
    Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
    -
    VmaPoolStats
    Describes parameter of existing VmaPool.
    Definition: vk_mem_alloc.h:1198
    -
    VmaAllocationInfo::offset
    VkDeviceSize offset
    Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory, offset) pair is unique to this allocation.
    Definition: vk_mem_alloc.h:1282
    -
    VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
    Definition: vk_mem_alloc.h:1061
    -
    VmaDefragmentationStats::bytesMoved
    VkDeviceSize bytesMoved
    Total number of bytes that have been copied while moving allocations to different places...
    Definition: vk_mem_alloc.h:1449
    -
    VmaVulkanFunctions
    Pointers to some Vulkan functions - a subset used by the library.
    Definition: vk_mem_alloc.h:757
    +
    VmaPoolStats
    Describes parameter of existing VmaPool.
    Definition: vk_mem_alloc.h:1236
    +
    VmaAllocationInfo::offset
    VkDeviceSize offset
    Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory, offset) pair is unique to this allocation.
    Definition: vk_mem_alloc.h:1320
    +
    VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
    Definition: vk_mem_alloc.h:1099
    +
    VmaDefragmentationStats::bytesMoved
    VkDeviceSize bytesMoved
    Total number of bytes that have been copied while moving allocations to different places...
    Definition: vk_mem_alloc.h:1487
    +
    VmaVulkanFunctions
    Pointers to some Vulkan functions - a subset used by the library.
    Definition: vk_mem_alloc.h:792
    vmaCreateAllocator
    VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
    Creates Allocator object.
    -
    VmaVulkanFunctions::vkGetBufferMemoryRequirements2KHR
    PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR
    Definition: vk_mem_alloc.h:772
    -
    VmaStatInfo::unusedRangeCount
    uint32_t unusedRangeCount
    Number of free ranges of memory between allocations.
    Definition: vk_mem_alloc.h:905
    -
    VMA_MEMORY_USAGE_UNKNOWN
    Definition: vk_mem_alloc.h:952
    -
    VmaPoolCreateFlags
    VkFlags VmaPoolCreateFlags
    Definition: vk_mem_alloc.h:1151
    +
    VmaVulkanFunctions::vkGetBufferMemoryRequirements2KHR
    PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR
    Definition: vk_mem_alloc.h:807
    +
    VmaStatInfo::unusedRangeCount
    uint32_t unusedRangeCount
    Number of free ranges of memory between allocations.
    Definition: vk_mem_alloc.h:940
    +
    VMA_MEMORY_USAGE_UNKNOWN
    Definition: vk_mem_alloc.h:987
    +
    VmaPoolCreateFlags
    VkFlags VmaPoolCreateFlags
    Definition: vk_mem_alloc.h:1189
    vmaGetPhysicalDeviceProperties
    void vmaGetPhysicalDeviceProperties(VmaAllocator allocator, const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
    -
    VmaStatInfo::allocationCount
    uint32_t allocationCount
    Number of VmaAllocation allocation objects allocated.
    Definition: vk_mem_alloc.h:903
    -
    VmaVulkanFunctions::vkGetImageMemoryRequirements
    PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
    Definition: vk_mem_alloc.h:767
    -
    VmaVulkanFunctions::vkDestroyImage
    PFN_vkDestroyImage vkDestroyImage
    Definition: vk_mem_alloc.h:771
    -
    VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT
    Set this flag to only try to allocate from existing VkDeviceMemory blocks and never create new such b...
    Definition: vk_mem_alloc.h:1020
    -
    VMA_MEMORY_USAGE_CPU_ONLY
    Definition: vk_mem_alloc.h:977
    -
    VmaAllocationInfo::pMappedData
    void * pMappedData
    Pointer to the beginning of this allocation as mapped data.
    Definition: vk_mem_alloc.h:1296
    +
    VmaStatInfo::allocationCount
    uint32_t allocationCount
    Number of VmaAllocation allocation objects allocated.
    Definition: vk_mem_alloc.h:938
    +
    VmaVulkanFunctions::vkGetImageMemoryRequirements
    PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
    Definition: vk_mem_alloc.h:802
    +
    VmaVulkanFunctions::vkDestroyImage
    PFN_vkDestroyImage vkDestroyImage
    Definition: vk_mem_alloc.h:806
    +
    VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT
    Set this flag to only try to allocate from existing VkDeviceMemory blocks and never create new such b...
    Definition: vk_mem_alloc.h:1058
    +
    VMA_MEMORY_USAGE_CPU_ONLY
    Definition: vk_mem_alloc.h:1014
    +
    VmaAllocationInfo::pMappedData
    void * pMappedData
    Pointer to the beginning of this allocation as mapped data.
    Definition: vk_mem_alloc.h:1334
    vmaDestroyImage
    void vmaDestroyImage(VmaAllocator allocator, VkImage image, VmaAllocation allocation)
    Destroys Vulkan image and frees allocated memory.
    -
    VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
    Enables usage of VK_KHR_dedicated_allocation extension.
    Definition: vk_mem_alloc.h:747
    +
    VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
    Enables usage of VK_KHR_dedicated_allocation extension.
    Definition: vk_mem_alloc.h:782
    VmaDefragmentationStats
    struct VmaDefragmentationStats VmaDefragmentationStats
    Statistics returned by function vmaDefragment().
    -
    VmaVulkanFunctions::vkAllocateMemory
    PFN_vkAllocateMemory vkAllocateMemory
    Definition: vk_mem_alloc.h:760
    -
    VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    Definition: vk_mem_alloc.h:1263
    +
    VmaVulkanFunctions::vkAllocateMemory
    PFN_vkAllocateMemory vkAllocateMemory
    Definition: vk_mem_alloc.h:795
    +
    VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    Definition: vk_mem_alloc.h:1301
    vmaAllocateMemory
    VkResult vmaAllocateMemory(VmaAllocator allocator, const VkMemoryRequirements *pVkMemoryRequirements, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    General purpose memory allocation.
    vmaSetCurrentFrameIndex
    void vmaSetCurrentFrameIndex(VmaAllocator allocator, uint32_t frameIndex)
    Sets index of the current frame.
    VmaAllocationCreateInfo
    struct VmaAllocationCreateInfo VmaAllocationCreateInfo
    vmaAllocateMemoryForBuffer
    VkResult vmaAllocateMemoryForBuffer(VmaAllocator allocator, VkBuffer buffer, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    -
    VmaPoolCreateFlagBits
    VmaPoolCreateFlagBits
    Flags to be passed as VmaPoolCreateInfo::flags.
    Definition: vk_mem_alloc.h:1129
    -
    VmaStatInfo::unusedRangeSizeAvg
    VkDeviceSize unusedRangeSizeAvg
    Definition: vk_mem_alloc.h:911
    -
    VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
    Definition: vk_mem_alloc.h:1059
    -
    VmaStats::memoryHeap
    VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
    Definition: vk_mem_alloc.h:918
    +
    VmaPoolCreateFlagBits
    VmaPoolCreateFlagBits
    Flags to be passed as VmaPoolCreateInfo::flags.
    Definition: vk_mem_alloc.h:1167
    +
    VmaStatInfo::unusedRangeSizeAvg
    VkDeviceSize unusedRangeSizeAvg
    Definition: vk_mem_alloc.h:946
    +
    VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
    Definition: vk_mem_alloc.h:1097
    +
    VmaStats::memoryHeap
    VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
    Definition: vk_mem_alloc.h:953
    vmaDestroyBuffer
    void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
    Destroys Vulkan buffer and frees allocated memory.
    -
    VmaPoolStats::unusedSize
    VkDeviceSize unusedSize
    Total number of bytes in the pool not used by any VmaAllocation.
    Definition: vk_mem_alloc.h:1204
    -
    VmaStatInfo::unusedRangeSizeMax
    VkDeviceSize unusedRangeSizeMax
    Definition: vk_mem_alloc.h:911
    -
    VmaAllocationInfo::memoryType
    uint32_t memoryType
    Memory type index that this allocation was allocated from.
    Definition: vk_mem_alloc.h:1268
    +
    VmaPoolStats::unusedSize
    VkDeviceSize unusedSize
    Total number of bytes in the pool not used by any VmaAllocation.
    Definition: vk_mem_alloc.h:1242
    +
    VmaStatInfo::unusedRangeSizeMax
    VkDeviceSize unusedRangeSizeMax
    Definition: vk_mem_alloc.h:946
    +
    VmaAllocationInfo::memoryType
    uint32_t memoryType
    Memory type index that this allocation was allocated from.
    Definition: vk_mem_alloc.h:1306
    diff --git a/src/vk_mem_alloc.h b/src/vk_mem_alloc.h index a7eb730..9dc5e97 100644 --- a/src/vk_mem_alloc.h +++ b/src/vk_mem_alloc.h @@ -363,6 +363,41 @@ vmaDestroyBuffer(allocator, buf, alloc); vmaDestroyPool(allocator, pool); \endcode +\section custom_memory_pools_MemTypeIndex Choosing memory type index + +When creating a pool, you must explicitly specify memory type index. +To find the one suitable for your buffers or images, you can use code similar to the following: + +\code +VkBufferCreateInfo dummyBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; +dummyBufCreateInfo.size = 1024; // Whatever. +dummyBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; // Change if needed. + +VkBuffer dummyBuf; +vkCreateBuffer(device, &dummyBufCreateInfo, nullptr, &dummyBuf); + +VkMemoryRequirements memReq; +vkGetBufferMemoryRequirements(device, dummyBuf, &memReq); + +VmaAllocationCreateInfo allocCreateInfo = {}; +allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; // Change if needed. + +uint32_t memTypeIndex; +vmaFindMemoryTypeIndex(allocator, memReq.memoryTypeBits, &allocCreateInfo, &memTypeIndex); + +vkDestroyBuffer(device, dummyBuf, nullptr); + +VmaPoolCreateInfo poolCreateInfo = {}; +poolCreateInfo.memoryTypeIndex = memTypeIndex; +// ... +\endcode + +Dummy buffer is needed to query driver for `memReq.memoryTypeBits`. +Memory is never allocated for this buffer. +You should fill structures `dummyBufCreateInfo` and `allocCreateInfo` with the same parameters +as you are going to use for buffers created in your pool. + + \page defragmentation Defragmentation Interleaved allocations and deallocations of many objects of varying size can