From 118049cda8aa7ca9310b286ea4db7a1027208deb Mon Sep 17 00:00:00 2001 From: Adam Sawicki Date: Tue, 19 Sep 2017 11:38:01 +0200 Subject: [PATCH] Added feature: VmaAllocatorCreateInfo::pHeapSizeLimit. --- bin/VulkanSample_Release_2015.exe | Bin 99328 -> 100352 bytes docs/html/functions.html | 3 + docs/html/functions_vars.html | 3 + docs/html/index.html | 16 +- docs/html/search/all_8.js | 1 + docs/html/search/all_c.js | 2 +- docs/html/search/variables_6.js | 1 + docs/html/search/variables_a.js | 2 +- ...uct_vma_allocator_create_info-members.html | 7 +- .../struct_vma_allocator_create_info.html | 34 +++- docs/html/vk__mem__alloc_8h_source.html | 177 +++++++++--------- src/vk_mem_alloc.h | 166 ++++++++++++---- 12 files changed, 273 insertions(+), 139 deletions(-) diff --git a/bin/VulkanSample_Release_2015.exe b/bin/VulkanSample_Release_2015.exe index fda2ba19f408b26b27740d89cea228f74b0b80f1..c08cac908914f8deec21b0528dac0eafc11ecce9 100644 GIT binary patch delta 38894 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 BGoAnd delta 38445 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 diff --git a/docs/html/functions.html b/docs/html/functions.html index 0c91a0c..52a24bc 100644 --- a/docs/html/functions.html +++ b/docs/html/functions.html @@ -170,6 +170,9 @@ $(function() {
  • pfnFree : VmaDeviceMemoryCallbacks
    • +
  • pHeapSizeLimit +: VmaAllocatorCreateInfo +
  • physicalDevice : VmaAllocatorCreateInfo
    • diff --git a/docs/html/functions_vars.html b/docs/html/functions_vars.html index 5bdd9e8..445456a 100644 --- a/docs/html/functions_vars.html +++ b/docs/html/functions_vars.html @@ -170,6 +170,9 @@ $(function() {
  • pfnFree : VmaDeviceMemoryCallbacks
    • +
  • pHeapSizeLimit +: VmaAllocatorCreateInfo +
  • physicalDevice : VmaAllocatorCreateInfo
    • diff --git a/docs/html/index.html b/docs/html/index.html index 9e8b311..e6f3b54 100644 --- a/docs/html/index.html +++ b/docs/html/index.html @@ -73,7 +73,9 @@ $(function() {
  • Lost allocations
    • -
  • Configuration
    • Custom memory allocator
      • +
    • Configuration
    • Thread safety
      • @@ -295,10 +297,16 @@ void MyBuffer::EnsureBuffer()

      Configuration

      -

      Please check "CONFIGURATION SECTION" in the code to find macros that you can define before each #include of this file or change directly in this file to provide your own implementation of basic facilities like assert, min and max functions, mutex etc. C++ STL is used by default, but changing these allows you to get rid of any STL usage if you want, as many game developers tend to do.

      +

      Please check "CONFIGURATION SECTION" in the code to find macros that you can define before each #include of this file or change directly in this file to provide your own implementation of basic facilities like assert, min() and max() functions, mutex etc. C++ STL is used by default, but changing these allows you to get rid of any STL usage if you want, as many game developers tend to do.

      -Custom memory allocator

      -

      You can use custom memory allocator by filling optional member VmaAllocatorCreateInfo::pAllocationCallbacks. These functions will be passed to Vulkan, as well as used by the library itself to make any CPU-side allocations.

      +Custom host memory allocator +

      If you use custom allocator for CPU memory rather than default operator new and delete from C++, you can make this library using your allocator as well by filling optional member VmaAllocatorCreateInfo::pAllocationCallbacks. These functions will be passed to Vulkan, as well as used by the library itself to make any CPU-side allocations.

      +

      +Device memory allocation callbacks

      +

      The library makes calls to vkAllocateMemory() and vkFreeMemory() internally. You can setup callbacks to be informed about these calls, e.g. for the purpose of gathering some statistics. To do it, fill optional member VmaAllocatorCreateInfo::pDeviceMemoryCallbacks.

      +

      +Device heap memory limit

      +

      If you want to test how your program behaves with limited amount of Vulkan device memory available (without switching your graphics card to one that really has smaller VRAM), you can use a feature of this library intended for this purpose. To do it, fill optional member VmaAllocatorCreateInfo::pHeapSizeLimit.

      Thread safety

        diff --git a/docs/html/search/all_8.js b/docs/html/search/all_8.js index 48da8dd..7e837ac 100644 --- a/docs/html/search/all_8.js +++ b/docs/html/search/all_8.js @@ -6,6 +6,7 @@ var searchData= ['pfn_5fvmafreedevicememoryfunction',['PFN_vmaFreeDeviceMemoryFunction',['../group__general.html#gaef2545dc2e9dd4f29ab9ba6ac6fe2f49',1,'vk_mem_alloc.h']]], ['pfnallocate',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], ['pfnfree',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], + ['pheapsizelimit',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], ['physicaldevice',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], ['pmappeddata',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], ['pool',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], diff --git a/docs/html/search/all_c.js b/docs/html/search/all_c.js index 91686af..4c01446 100644 --- a/docs/html/search/all_c.js +++ b/docs/html/search/all_c.js @@ -1,7 +1,7 @@ var searchData= [ ['unusedbytes',['UnusedBytes',['../struct_vma_stat_info.html#a394d2aef4348cb58abf73764804b4f2d',1,'VmaStatInfo']]], - ['unusedrangecount',['UnusedRangeCount',['../struct_vma_stat_info.html#a56c4fb4dba646479180b601854cde2a6',1,'VmaStatInfo::UnusedRangeCount()'],['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()']]], + ['unusedrangecount',['unusedRangeCount',['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()'],['../struct_vma_stat_info.html#a56c4fb4dba646479180b601854cde2a6',1,'VmaStatInfo::UnusedRangeCount()']]], ['unusedrangesizeavg',['UnusedRangeSizeAvg',['../struct_vma_stat_info.html#a88ad9bdc2b3a98964a4d0c338c0c9060',1,'VmaStatInfo']]], ['unusedrangesizemax',['UnusedRangeSizeMax',['../struct_vma_stat_info.html#a10c52c0841f01ca704e8ddb1ea6a635d',1,'VmaStatInfo']]], ['unusedrangesizemin',['UnusedRangeSizeMin',['../struct_vma_stat_info.html#a07c508f42a4d3424bd0c259784a7f2d6',1,'VmaStatInfo']]], diff --git a/docs/html/search/variables_6.js b/docs/html/search/variables_6.js index 2b404e1..9113c5c 100644 --- a/docs/html/search/variables_6.js +++ b/docs/html/search/variables_6.js @@ -4,6 +4,7 @@ var searchData= ['pdevicememorycallbacks',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], ['pfnallocate',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], ['pfnfree',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], + ['pheapsizelimit',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], ['physicaldevice',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], ['pmappeddata',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], ['pool',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], diff --git a/docs/html/search/variables_a.js b/docs/html/search/variables_a.js index 91686af..4c01446 100644 --- a/docs/html/search/variables_a.js +++ b/docs/html/search/variables_a.js @@ -1,7 +1,7 @@ var searchData= [ ['unusedbytes',['UnusedBytes',['../struct_vma_stat_info.html#a394d2aef4348cb58abf73764804b4f2d',1,'VmaStatInfo']]], - ['unusedrangecount',['UnusedRangeCount',['../struct_vma_stat_info.html#a56c4fb4dba646479180b601854cde2a6',1,'VmaStatInfo::UnusedRangeCount()'],['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()']]], + ['unusedrangecount',['unusedRangeCount',['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()'],['../struct_vma_stat_info.html#a56c4fb4dba646479180b601854cde2a6',1,'VmaStatInfo::UnusedRangeCount()']]], ['unusedrangesizeavg',['UnusedRangeSizeAvg',['../struct_vma_stat_info.html#a88ad9bdc2b3a98964a4d0c338c0c9060',1,'VmaStatInfo']]], ['unusedrangesizemax',['UnusedRangeSizeMax',['../struct_vma_stat_info.html#a10c52c0841f01ca704e8ddb1ea6a635d',1,'VmaStatInfo']]], ['unusedrangesizemin',['UnusedRangeSizeMin',['../struct_vma_stat_info.html#a07c508f42a4d3424bd0c259784a7f2d6',1,'VmaStatInfo']]], diff --git a/docs/html/struct_vma_allocator_create_info-members.html b/docs/html/struct_vma_allocator_create_info-members.html index 63f4c83..629a078 100644 --- a/docs/html/struct_vma_allocator_create_info-members.html +++ b/docs/html/struct_vma_allocator_create_info-members.html @@ -70,9 +70,10 @@ $(function() { frameInUseCountVmaAllocatorCreateInfo pAllocationCallbacksVmaAllocatorCreateInfo pDeviceMemoryCallbacksVmaAllocatorCreateInfo - physicalDeviceVmaAllocatorCreateInfo - preferredLargeHeapBlockSizeVmaAllocatorCreateInfo - preferredSmallHeapBlockSizeVmaAllocatorCreateInfo + pHeapSizeLimitVmaAllocatorCreateInfo + physicalDeviceVmaAllocatorCreateInfo + preferredLargeHeapBlockSizeVmaAllocatorCreateInfo + preferredSmallHeapBlockSizeVmaAllocatorCreateInfo
        diff --git a/docs/html/struct_vma_allocator_create_info.html b/docs/html/struct_vma_allocator_create_info.html index 1f2157e..f28f821 100644 --- a/docs/html/struct_vma_allocator_create_info.html +++ b/docs/html/struct_vma_allocator_create_info.html @@ -83,10 +83,10 @@ Public Attributes  Vulkan device. More...
          VkDeviceSize preferredLargeHeapBlockSize - Size of a single memory block to allocate for resources. More...
        + Preferred size of a single VkDeviceMemory block to be allocated from large heaps. More...
          VkDeviceSize preferredSmallHeapBlockSize - Size of a single memory block to allocate for resources from a small heap <= 512 MB. More...
        + Preferred size of a single VkDeviceMemory block to be allocated from small heaps <= 512 MB. More...
          const VkAllocationCallbacks * pAllocationCallbacks  Custom CPU memory allocation callbacks. More...
        @@ -97,6 +97,9 @@ Public Attributes uint32_t frameInUseCount  Maximum number of additional frames that are in use at the same time as current frame. More...
          +const VkDeviceSize * pHeapSizeLimit + Either NULL or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap. More...
        + 

        Detailed Description

        Description of a Allocator to be created.

        @@ -185,6 +188,29 @@ Public Attributes

        Informative callbacks for vkAllocateMemory, vkFreeMemory.

        Optional, can be null.

        +
        + + +

        ◆ pHeapSizeLimit

        + +
        +
        + + + + +
        const VkDeviceSize* VmaAllocatorCreateInfo::pHeapSizeLimit
        +
        + +

        Either NULL or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap.

        +

        If not NULL, it must be a pointer to an array of VkPhysicalDeviceMemoryProperties::memoryHeapCount elements, defining limit on maximum number of bytes that can be allocated out of particular Vulkan memory heap.

        +

        Any of the elements may be equal to VK_WHOLE_SIZE, which means no limit on that heap. This is also the default in case of pHeapSizeLimit = NULL.

        +

        If there is a limit defined for a heap:

        +
          +
        • If user tries to allocate more memory from that heap using this allocator, the allocation fails with VK_ERROR_OUT_OF_DEVICE_MEMORY.
          • +
        • If the limit is smaller than heap size reported in VkMemoryHeap::size, the value of this limit will be reported instead when using vmaGetMemoryProperties().
          • +
        +
        @@ -216,7 +242,7 @@ Public Attributes
        -

        Size of a single memory block to allocate for resources.

        +

        Preferred size of a single VkDeviceMemory block to be allocated from large heaps.

        Set to 0 to use default, which is currently 256 MB.

        @@ -233,7 +259,7 @@ Public Attributes
        -

        Size of a single memory block to allocate for resources from a small heap <= 512 MB.

        +

        Preferred size of a single VkDeviceMemory block to be allocated from small heaps <= 512 MB.

        Set to 0 to use default, which is currently 64 MB.

        diff --git a/docs/html/vk__mem__alloc_8h_source.html b/docs/html/vk__mem__alloc_8h_source.html index 6c043ec..4da5b14 100644 --- a/docs/html/vk__mem__alloc_8h_source.html +++ b/docs/html/vk__mem__alloc_8h_source.html @@ -62,132 +62,133 @@ $(function() {
        vk_mem_alloc.h
        -Go to the documentation of this file.
        1 //
        2 // Copyright (c) 2017 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 
        404 #include <vulkan/vulkan.h>
        405 
        407 
        411 VK_DEFINE_HANDLE(VmaAllocator)
        412 
        413 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
        415  VmaAllocator allocator,
        416  uint32_t memoryType,
        417  VkDeviceMemory memory,
        418  VkDeviceSize size);
        420 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
        421  VmaAllocator allocator,
        422  uint32_t memoryType,
        423  VkDeviceMemory memory,
        424  VkDeviceSize size);
        425 
        431 typedef struct VmaDeviceMemoryCallbacks {
        433  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
        435  PFN_vmaFreeDeviceMemoryFunction pfnFree;
        436 } VmaDeviceMemoryCallbacks;
        437 
        439 typedef enum VmaAllocatorFlagBits {
        444  VMA_ALLOCATOR_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
        445 
        446  VMA_ALLOCATOR_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        447 } VmaAllocatorFlagBits;
        448 typedef VkFlags VmaAllocatorFlags;
        449 
        451 typedef struct VmaAllocatorCreateInfo
        452 {
        454  VmaAllocatorFlags flags;
        456 
        457  VkPhysicalDevice physicalDevice;
        459 
        460  VkDevice device;
        462 
        463  VkDeviceSize preferredLargeHeapBlockSize;
        465 
        466  VkDeviceSize preferredSmallHeapBlockSize;
        468 
        469  const VkAllocationCallbacks* pAllocationCallbacks;
        471 
        472  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
        486  uint32_t frameInUseCount;
        487 } VmaAllocatorCreateInfo;
        488 
        490 VkResult vmaCreateAllocator(
        491  const VmaAllocatorCreateInfo* pCreateInfo,
        492  VmaAllocator* pAllocator);
        493 
        495 void vmaDestroyAllocator(
        496  VmaAllocator allocator);
        497 
        502 void vmaGetPhysicalDeviceProperties(
        503  VmaAllocator allocator,
        504  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
        505 
        510 void vmaGetMemoryProperties(
        511  VmaAllocator allocator,
        512  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
        513 
        520 void vmaGetMemoryTypeProperties(
        521  VmaAllocator allocator,
        522  uint32_t memoryTypeIndex,
        523  VkMemoryPropertyFlags* pFlags);
        524 
        533 void vmaSetCurrentFrameIndex(
        534  VmaAllocator allocator,
        535  uint32_t frameIndex);
        536 
        537 typedef struct VmaStatInfo
        538 {
        540  uint32_t BlockCount;
        542  uint32_t AllocationCount;
        544  uint32_t UnusedRangeCount;
        546  VkDeviceSize UsedBytes;
        548  VkDeviceSize UnusedBytes;
        549  VkDeviceSize AllocationSizeMin, AllocationSizeAvg, AllocationSizeMax;
        550  VkDeviceSize UnusedRangeSizeMin, UnusedRangeSizeAvg, UnusedRangeSizeMax;
        551 } VmaStatInfo;
        552 
        554 struct VmaStats
        555 {
        556  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
        557  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
        558  VmaStatInfo total;
        559 };
        560 
        562 void vmaCalculateStats(
        563  VmaAllocator allocator,
        564  VmaStats* pStats);
        565 
        566 #define VMA_STATS_STRING_ENABLED 1
        567 
        568 #if VMA_STATS_STRING_ENABLED
        569 
        571 
        573 void vmaBuildStatsString(
        574  VmaAllocator allocator,
        575  char** ppStatsString,
        576  VkBool32 detailedMap);
        577 
        578 void vmaFreeStatsString(
        579  VmaAllocator allocator,
        580  char* pStatsString);
        581 
        582 #endif // #if VMA_STATS_STRING_ENABLED
        583 
        586 
        591 VK_DEFINE_HANDLE(VmaPool)
        592 
        593 typedef enum VmaMemoryUsage
        594 {
        596  VMA_MEMORY_USAGE_UNKNOWN = 0,
        598  VMA_MEMORY_USAGE_GPU_ONLY = 1,
        600 
        601  VMA_MEMORY_USAGE_CPU_ONLY = 2,
        603 
        604  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
        606 
        607  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
        608  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
        609 } VmaMemoryUsage;
        610 
        612 typedef enum VmaAllocationCreateFlagBits {
        624  VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT = 0x00000001,
        625 
        635  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
        645  VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT = 0x00000004,
        656  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
        663  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
        664 
        665  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        666 } VmaAllocationCreateFlagBits;
        667 typedef VkFlags VmaAllocationCreateFlags;
        668 
        669 typedef struct VmaAllocationCreateInfo
        670 {
        672  VmaAllocationCreateFlags flags;
        678  VmaMemoryUsage usage;
        683  VkMemoryPropertyFlags requiredFlags;
        689  VkMemoryPropertyFlags preferredFlags;
        691  void* pUserData;
        696  VmaPool pool;
        697 } VmaAllocationCreateInfo;
        698 
        713 VkResult vmaFindMemoryTypeIndex(
        714  VmaAllocator allocator,
        715  uint32_t memoryTypeBits,
        716  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        717  uint32_t* pMemoryTypeIndex);
        718 
        721 
        726 typedef enum VmaPoolCreateFlagBits {
        736  VMA_POOL_CREATE_PERSISTENT_MAP_BIT = 0x00000001,
        754  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
        755 
        756  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        757 } VmaPoolCreateFlagBits;
        758 typedef VkFlags VmaPoolCreateFlags;
        759 
        762 typedef struct VmaPoolCreateInfo {
        765  uint32_t memoryTypeIndex;
        768  VmaPoolCreateFlags flags;
        773  VkDeviceSize blockSize;
        778  size_t minBlockCount;
        786  size_t maxBlockCount;
        800  uint32_t frameInUseCount;
        801 } VmaPoolCreateInfo;
        802 
        805 typedef struct VmaPoolStats {
        808  VkDeviceSize size;
        811  VkDeviceSize unusedSize;
        814  size_t allocationCount;
        817  size_t unusedRangeCount;
        818 } VmaPoolStats;
        819 
        826 VkResult vmaCreatePool(
        827  VmaAllocator allocator,
        828  const VmaPoolCreateInfo* pCreateInfo,
        829  VmaPool* pPool);
        830 
        833 void vmaDestroyPool(
        834  VmaAllocator allocator,
        835  VmaPool pool);
        836 
        843 void vmaGetPoolStats(
        844  VmaAllocator allocator,
        845  VmaPool pool,
        846  VmaPoolStats* pPoolStats);
        847 
        854 void vmaMakePoolAllocationsLost(
        855  VmaAllocator allocator,
        856  VmaPool pool,
        857  size_t* pLostAllocationCount);
        858 
        859 VK_DEFINE_HANDLE(VmaAllocation)
        860 
        861 
        863 typedef struct VmaAllocationInfo {
        868  uint32_t memoryType;
        877  VkDeviceMemory deviceMemory;
        882  VkDeviceSize offset;
        887  VkDeviceSize size;
        893  void* pMappedData;
        898  void* pUserData;
        899 } VmaAllocationInfo;
        900 
        911 VkResult vmaAllocateMemory(
        912  VmaAllocator allocator,
        913  const VkMemoryRequirements* pVkMemoryRequirements,
        914  const VmaAllocationCreateInfo* pCreateInfo,
        915  VmaAllocation* pAllocation,
        916  VmaAllocationInfo* pAllocationInfo);
        917 
        924 VkResult vmaAllocateMemoryForBuffer(
        925  VmaAllocator allocator,
        926  VkBuffer buffer,
        927  const VmaAllocationCreateInfo* pCreateInfo,
        928  VmaAllocation* pAllocation,
        929  VmaAllocationInfo* pAllocationInfo);
        930 
        932 VkResult vmaAllocateMemoryForImage(
        933  VmaAllocator allocator,
        934  VkImage image,
        935  const VmaAllocationCreateInfo* pCreateInfo,
        936  VmaAllocation* pAllocation,
        937  VmaAllocationInfo* pAllocationInfo);
        938 
        940 void vmaFreeMemory(
        941  VmaAllocator allocator,
        942  VmaAllocation allocation);
        943 
        945 void vmaGetAllocationInfo(
        946  VmaAllocator allocator,
        947  VmaAllocation allocation,
        948  VmaAllocationInfo* pAllocationInfo);
        949 
        951 void vmaSetAllocationUserData(
        952  VmaAllocator allocator,
        953  VmaAllocation allocation,
        954  void* pUserData);
        955 
        966 void vmaCreateLostAllocation(
        967  VmaAllocator allocator,
        968  VmaAllocation* pAllocation);
        969 
        978 VkResult vmaMapMemory(
        979  VmaAllocator allocator,
        980  VmaAllocation allocation,
        981  void** ppData);
        982 
        983 void vmaUnmapMemory(
        984  VmaAllocator allocator,
        985  VmaAllocation allocation);
        986 
        1005 void vmaUnmapPersistentlyMappedMemory(VmaAllocator allocator);
        1006 
        1014 VkResult vmaMapPersistentlyMappedMemory(VmaAllocator allocator);
        1015 
        1017 typedef struct VmaDefragmentationInfo {
        1022  VkDeviceSize maxBytesToMove;
        1027  uint32_t maxAllocationsToMove;
        1028 } VmaDefragmentationInfo;
        1029 
        1031 typedef struct VmaDefragmentationStats {
        1033  VkDeviceSize bytesMoved;
        1035  VkDeviceSize bytesFreed;
        1037  uint32_t allocationsMoved;
        1039  uint32_t deviceMemoryBlocksFreed;
        1040 } VmaDefragmentationStats;
        1041 
        1112 VkResult vmaDefragment(
        1113  VmaAllocator allocator,
        1114  VmaAllocation* pAllocations,
        1115  size_t allocationCount,
        1116  VkBool32* pAllocationsChanged,
        1117  const VmaDefragmentationInfo *pDefragmentationInfo,
        1118  VmaDefragmentationStats* pDefragmentationStats);
        1119 
        1122 
        1145 VkResult vmaCreateBuffer(
        1146  VmaAllocator allocator,
        1147  const VkBufferCreateInfo* pBufferCreateInfo,
        1148  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1149  VkBuffer* pBuffer,
        1150  VmaAllocation* pAllocation,
        1151  VmaAllocationInfo* pAllocationInfo);
        1152 
        1153 void vmaDestroyBuffer(
        1154  VmaAllocator allocator,
        1155  VkBuffer buffer,
        1156  VmaAllocation allocation);
        1157 
        1159 VkResult vmaCreateImage(
        1160  VmaAllocator allocator,
        1161  const VkImageCreateInfo* pImageCreateInfo,
        1162  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1163  VkImage* pImage,
        1164  VmaAllocation* pAllocation,
        1165  VmaAllocationInfo* pAllocationInfo);
        1166 
        1167 void vmaDestroyImage(
        1168  VmaAllocator allocator,
        1169  VkImage image,
        1170  VmaAllocation allocation);
        1171 
        1174 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
        1175 
        1176 // For Visual Studio IntelliSense.
        1177 #ifdef __INTELLISENSE__
        1178 #define VMA_IMPLEMENTATION
        1179 #endif
        1180 
        1181 #ifdef VMA_IMPLEMENTATION
        1182 #undef VMA_IMPLEMENTATION
        1183 
        1184 #include <cstdint>
        1185 #include <cstdlib>
        1186 #include <cstring>
        1187 
        1188 /*******************************************************************************
        1189 CONFIGURATION SECTION
        1190 
        1191 Define some of these macros before each #include of this header or change them
        1192 here if you need other then default behavior depending on your environment.
        1193 */
        1194 
        1195 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
        1196 //#define VMA_USE_STL_CONTAINERS 1
        1197 
        1198 /* Set this macro to 1 to make the library including and using STL containers:
        1199 std::pair, std::vector, std::list, std::unordered_map.
        1200 
        1201 Set it to 0 or undefined to make the library using its own implementation of
        1202 the containers.
        1203 */
        1204 #if VMA_USE_STL_CONTAINERS
        1205  #define VMA_USE_STL_VECTOR 1
        1206  #define VMA_USE_STL_UNORDERED_MAP 1
        1207  #define VMA_USE_STL_LIST 1
        1208 #endif
        1209 
        1210 #if VMA_USE_STL_VECTOR
        1211  #include <vector>
        1212 #endif
        1213 
        1214 #if VMA_USE_STL_UNORDERED_MAP
        1215  #include <unordered_map>
        1216 #endif
        1217 
        1218 #if VMA_USE_STL_LIST
        1219  #include <list>
        1220 #endif
        1221 
        1222 /*
        1223 Following headers are used in this CONFIGURATION section only, so feel free to
        1224 remove them if not needed.
        1225 */
        1226 #include <cassert> // for assert
        1227 #include <algorithm> // for min, max
        1228 #include <mutex> // for std::mutex
        1229 #include <atomic> // for std::atomic_int64_t
        1230 
        1231 #if !defined(_WIN32)
        1232  #include <malloc.h> // for aligned_alloc()
        1233 #endif
        1234 
        1235 // Normal assert to check for programmer's errors, especially in Debug configuration.
        1236 #ifndef VMA_ASSERT
        1237  #ifdef _DEBUG
        1238  #define VMA_ASSERT(expr) assert(expr)
        1239  #else
        1240  #define VMA_ASSERT(expr)
        1241  #endif
        1242 #endif
        1243 
        1244 // Assert that will be called very often, like inside data structures e.g. operator[].
        1245 // Making it non-empty can make program slow.
        1246 #ifndef VMA_HEAVY_ASSERT
        1247  #ifdef _DEBUG
        1248  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
        1249  #else
        1250  #define VMA_HEAVY_ASSERT(expr)
        1251  #endif
        1252 #endif
        1253 
        1254 #ifndef VMA_NULL
        1255  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
        1256  #define VMA_NULL nullptr
        1257 #endif
        1258 
        1259 #ifndef VMA_ALIGN_OF
        1260  #define VMA_ALIGN_OF(type) (__alignof(type))
        1261 #endif
        1262 
        1263 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
        1264  #if defined(_WIN32)
        1265  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
        1266  #else
        1267  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
        1268  #endif
        1269 #endif
        1270 
        1271 #ifndef VMA_SYSTEM_FREE
        1272  #if defined(_WIN32)
        1273  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
        1274  #else
        1275  #define VMA_SYSTEM_FREE(ptr) free(ptr)
        1276  #endif
        1277 #endif
        1278 
        1279 #ifndef VMA_MIN
        1280  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
        1281 #endif
        1282 
        1283 #ifndef VMA_MAX
        1284  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
        1285 #endif
        1286 
        1287 #ifndef VMA_SWAP
        1288  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
        1289 #endif
        1290 
        1291 #ifndef VMA_SORT
        1292  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
        1293 #endif
        1294 
        1295 #ifndef VMA_DEBUG_LOG
        1296  #define VMA_DEBUG_LOG(format, ...)
        1297  /*
        1298  #define VMA_DEBUG_LOG(format, ...) do { \
        1299  printf(format, __VA_ARGS__); \
        1300  printf("\n"); \
        1301  } while(false)
        1302  */
        1303 #endif
        1304 
        1305 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
        1306 #if VMA_STATS_STRING_ENABLED
        1307  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
        1308  {
        1309  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
        1310  }
        1311  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
        1312  {
        1313  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
        1314  }
        1315  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
        1316  {
        1317  snprintf(outStr, strLen, "%p", ptr);
        1318  }
        1319 #endif
        1320 
        1321 #ifndef VMA_MUTEX
        1322  class VmaMutex
        1323  {
        1324  public:
        1325  VmaMutex() { }
        1326  ~VmaMutex() { }
        1327  void Lock() { m_Mutex.lock(); }
        1328  void Unlock() { m_Mutex.unlock(); }
        1329  private:
        1330  std::mutex m_Mutex;
        1331  };
        1332  #define VMA_MUTEX VmaMutex
        1333 #endif
        1334 
        1335 /*
        1336 If providing your own implementation, you need to implement a subset of std::atomic:
        1337 
        1338 - Constructor(uint32_t desired)
        1339 - uint32_t load() const
        1340 - void store(uint32_t desired)
        1341 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
        1342 */
        1343 #ifndef VMA_ATOMIC_UINT32
        1344  #define VMA_ATOMIC_UINT32 std::atomic_uint32_t
        1345 #endif
        1346 
        1347 #ifndef VMA_BEST_FIT
        1348 
        1360  #define VMA_BEST_FIT (1)
        1361 #endif
        1362 
        1363 #ifndef VMA_DEBUG_ALWAYS_OWN_MEMORY
        1364 
        1368  #define VMA_DEBUG_ALWAYS_OWN_MEMORY (0)
        1369 #endif
        1370 
        1371 #ifndef VMA_DEBUG_ALIGNMENT
        1372 
        1376  #define VMA_DEBUG_ALIGNMENT (1)
        1377 #endif
        1378 
        1379 #ifndef VMA_DEBUG_MARGIN
        1380 
        1384  #define VMA_DEBUG_MARGIN (0)
        1385 #endif
        1386 
        1387 #ifndef VMA_DEBUG_GLOBAL_MUTEX
        1388 
        1392  #define VMA_DEBUG_GLOBAL_MUTEX (0)
        1393 #endif
        1394 
        1395 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
        1396 
        1400  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
        1401 #endif
        1402 
        1403 #ifndef VMA_SMALL_HEAP_MAX_SIZE
        1404  #define VMA_SMALL_HEAP_MAX_SIZE (512 * 1024 * 1024)
        1406 #endif
        1407 
        1408 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
        1409  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256 * 1024 * 1024)
        1411 #endif
        1412 
        1413 #ifndef VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE
        1414  #define VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE (64 * 1024 * 1024)
        1416 #endif
        1417 
        1418 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
        1419 
        1420 /*******************************************************************************
        1421 END OF CONFIGURATION
        1422 */
        1423 
        1424 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
        1425  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
        1426 
        1427 // Returns number of bits set to 1 in (v).
        1428 static inline uint32_t CountBitsSet(uint32_t v)
        1429 {
        1430  uint32_t c = v - ((v >> 1) & 0x55555555);
        1431  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
        1432  c = ((c >> 4) + c) & 0x0F0F0F0F;
        1433  c = ((c >> 8) + c) & 0x00FF00FF;
        1434  c = ((c >> 16) + c) & 0x0000FFFF;
        1435  return c;
        1436 }
        1437 
        1438 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
        1439 // Use types like uint32_t, uint64_t as T.
        1440 template <typename T>
        1441 static inline T VmaAlignUp(T val, T align)
        1442 {
        1443  return (val + align - 1) / align * align;
        1444 }
        1445 
        1446 // Division with mathematical rounding to nearest number.
        1447 template <typename T>
        1448 inline T VmaRoundDiv(T x, T y)
        1449 {
        1450  return (x + (y / (T)2)) / y;
        1451 }
        1452 
        1453 #ifndef VMA_SORT
        1454 
        1455 template<typename Iterator, typename Compare>
        1456 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
        1457 {
        1458  Iterator centerValue = end; --centerValue;
        1459  Iterator insertIndex = beg;
        1460  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
        1461  {
        1462  if(cmp(*memTypeIndex, *centerValue))
        1463  {
        1464  if(insertIndex != memTypeIndex)
        1465  {
        1466  VMA_SWAP(*memTypeIndex, *insertIndex);
        1467  }
        1468  ++insertIndex;
        1469  }
        1470  }
        1471  if(insertIndex != centerValue)
        1472  {
        1473  VMA_SWAP(*insertIndex, *centerValue);
        1474  }
        1475  return insertIndex;
        1476 }
        1477 
        1478 template<typename Iterator, typename Compare>
        1479 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
        1480 {
        1481  if(beg < end)
        1482  {
        1483  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
        1484  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
        1485  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
        1486  }
        1487 }
        1488 
        1489 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
        1490 
        1491 #endif // #ifndef VMA_SORT
        1492 
        1493 /*
        1494 Returns true if two memory blocks occupy overlapping pages.
        1495 ResourceA must be in less memory offset than ResourceB.
        1496 
        1497 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
        1498 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
        1499 */
        1500 static inline bool VmaBlocksOnSamePage(
        1501  VkDeviceSize resourceAOffset,
        1502  VkDeviceSize resourceASize,
        1503  VkDeviceSize resourceBOffset,
        1504  VkDeviceSize pageSize)
        1505 {
        1506  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
        1507  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
        1508  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
        1509  VkDeviceSize resourceBStart = resourceBOffset;
        1510  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
        1511  return resourceAEndPage == resourceBStartPage;
        1512 }
        1513 
        1514 enum VmaSuballocationType
        1515 {
        1516  VMA_SUBALLOCATION_TYPE_FREE = 0,
        1517  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
        1518  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
        1519  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        1520  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        1521  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        1522  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
        1523 };
        1524 
        1525 /*
        1526 Returns true if given suballocation types could conflict and must respect
        1527 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
        1528 or linear image and another one is optimal image. If type is unknown, behave
        1529 conservatively.
        1530 */
        1531 static inline bool VmaIsBufferImageGranularityConflict(
        1532  VmaSuballocationType suballocType1,
        1533  VmaSuballocationType suballocType2)
        1534 {
        1535  if(suballocType1 > suballocType2)
        1536  {
        1537  VMA_SWAP(suballocType1, suballocType2);
        1538  }
        1539 
        1540  switch(suballocType1)
        1541  {
        1542  case VMA_SUBALLOCATION_TYPE_FREE:
        1543  return false;
        1544  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        1545  return true;
        1546  case VMA_SUBALLOCATION_TYPE_BUFFER:
        1547  return
        1548  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        1549  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        1550  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        1551  return
        1552  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        1553  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
        1554  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        1555  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        1556  return
        1557  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        1558  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        1559  return false;
        1560  default:
        1561  VMA_ASSERT(0);
        1562  return true;
        1563  }
        1564 }
        1565 
        1566 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
        1567 struct VmaMutexLock
        1568 {
        1569 public:
        1570  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
        1571  m_pMutex(useMutex ? &mutex : VMA_NULL)
        1572  {
        1573  if(m_pMutex)
        1574  {
        1575  m_pMutex->Lock();
        1576  }
        1577  }
        1578 
        1579  ~VmaMutexLock()
        1580  {
        1581  if(m_pMutex)
        1582  {
        1583  m_pMutex->Unlock();
        1584  }
        1585  }
        1586 
        1587 private:
        1588  VMA_MUTEX* m_pMutex;
        1589 };
        1590 
        1591 #if VMA_DEBUG_GLOBAL_MUTEX
        1592  static VMA_MUTEX gDebugGlobalMutex;
        1593  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
        1594 #else
        1595  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
        1596 #endif
        1597 
        1598 // Minimum size of a free suballocation to register it in the free suballocation collection.
        1599 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
        1600 
        1601 /*
        1602 Performs binary search and returns iterator to first element that is greater or
        1603 equal to (key), according to comparison (cmp).
        1604 
        1605 Cmp should return true if first argument is less than second argument.
        1606 
        1607 Returned value is the found element, if present in the collection or place where
        1608 new element with value (key) should be inserted.
        1609 */
        1610 template <typename IterT, typename KeyT, typename CmpT>
        1611 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)
        1612 {
        1613  size_t down = 0, up = (end - beg);
        1614  while(down < up)
        1615  {
        1616  const size_t mid = (down + up) / 2;
        1617  if(cmp(*(beg+mid), key))
        1618  {
        1619  down = mid + 1;
        1620  }
        1621  else
        1622  {
        1623  up = mid;
        1624  }
        1625  }
        1626  return beg + down;
        1627 }
        1628 
        1630 // Memory allocation
        1631 
        1632 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
        1633 {
        1634  if((pAllocationCallbacks != VMA_NULL) &&
        1635  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
        1636  {
        1637  return (*pAllocationCallbacks->pfnAllocation)(
        1638  pAllocationCallbacks->pUserData,
        1639  size,
        1640  alignment,
        1641  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        1642  }
        1643  else
        1644  {
        1645  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
        1646  }
        1647 }
        1648 
        1649 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
        1650 {
        1651  if((pAllocationCallbacks != VMA_NULL) &&
        1652  (pAllocationCallbacks->pfnFree != VMA_NULL))
        1653  {
        1654  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
        1655  }
        1656  else
        1657  {
        1658  VMA_SYSTEM_FREE(ptr);
        1659  }
        1660 }
        1661 
        1662 template<typename T>
        1663 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
        1664 {
        1665  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
        1666 }
        1667 
        1668 template<typename T>
        1669 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
        1670 {
        1671  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
        1672 }
        1673 
        1674 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
        1675 
        1676 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
        1677 
        1678 template<typename T>
        1679 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
        1680 {
        1681  ptr->~T();
        1682  VmaFree(pAllocationCallbacks, ptr);
        1683 }
        1684 
        1685 template<typename T>
        1686 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
        1687 {
        1688  if(ptr != VMA_NULL)
        1689  {
        1690  for(size_t i = count; i--; )
        1691  {
        1692  ptr[i].~T();
        1693  }
        1694  VmaFree(pAllocationCallbacks, ptr);
        1695  }
        1696 }
        1697 
        1698 // STL-compatible allocator.
        1699 template<typename T>
        1700 class VmaStlAllocator
        1701 {
        1702 public:
        1703  const VkAllocationCallbacks* const m_pCallbacks;
        1704  typedef T value_type;
        1705 
        1706  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
        1707  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
        1708 
        1709  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
        1710  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
        1711 
        1712  template<typename U>
        1713  bool operator==(const VmaStlAllocator<U>& rhs) const
        1714  {
        1715  return m_pCallbacks == rhs.m_pCallbacks;
        1716  }
        1717  template<typename U>
        1718  bool operator!=(const VmaStlAllocator<U>& rhs) const
        1719  {
        1720  return m_pCallbacks != rhs.m_pCallbacks;
        1721  }
        1722 
        1723  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
        1724 };
        1725 
        1726 #if VMA_USE_STL_VECTOR
        1727 
        1728 #define VmaVector std::vector
        1729 
        1730 template<typename T, typename allocatorT>
        1731 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
        1732 {
        1733  vec.insert(vec.begin() + index, item);
        1734 }
        1735 
        1736 template<typename T, typename allocatorT>
        1737 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
        1738 {
        1739  vec.erase(vec.begin() + index);
        1740 }
        1741 
        1742 #else // #if VMA_USE_STL_VECTOR
        1743 
        1744 /* Class with interface compatible with subset of std::vector.
        1745 T must be POD because constructors and destructors are not called and memcpy is
        1746 used for these objects. */
        1747 template<typename T, typename AllocatorT>
        1748 class VmaVector
        1749 {
        1750 public:
        1751  typedef T value_type;
        1752 
        1753  VmaVector(const AllocatorT& allocator) :
        1754  m_Allocator(allocator),
        1755  m_pArray(VMA_NULL),
        1756  m_Count(0),
        1757  m_Capacity(0)
        1758  {
        1759  }
        1760 
        1761  VmaVector(size_t count, const AllocatorT& allocator) :
        1762  m_Allocator(allocator),
        1763  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
        1764  m_Count(count),
        1765  m_Capacity(count)
        1766  {
        1767  }
        1768 
        1769  VmaVector(const VmaVector<T, AllocatorT>& src) :
        1770  m_Allocator(src.m_Allocator),
        1771  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
        1772  m_Count(src.m_Count),
        1773  m_Capacity(src.m_Count)
        1774  {
        1775  if(m_Count != 0)
        1776  {
        1777  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
        1778  }
        1779  }
        1780 
        1781  ~VmaVector()
        1782  {
        1783  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        1784  }
        1785 
        1786  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
        1787  {
        1788  if(&rhs != this)
        1789  {
        1790  resize(rhs.m_Count);
        1791  if(m_Count != 0)
        1792  {
        1793  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        1794  }
        1795  }
        1796  return *this;
        1797  }
        1798 
        1799  bool empty() const { return m_Count == 0; }
        1800  size_t size() const { return m_Count; }
        1801  T* data() { return m_pArray; }
        1802  const T* data() const { return m_pArray; }
        1803 
        1804  T& operator[](size_t index)
        1805  {
        1806  VMA_HEAVY_ASSERT(index < m_Count);
        1807  return m_pArray[index];
        1808  }
        1809  const T& operator[](size_t index) const
        1810  {
        1811  VMA_HEAVY_ASSERT(index < m_Count);
        1812  return m_pArray[index];
        1813  }
        1814 
        1815  T& front()
        1816  {
        1817  VMA_HEAVY_ASSERT(m_Count > 0);
        1818  return m_pArray[0];
        1819  }
        1820  const T& front() const
        1821  {
        1822  VMA_HEAVY_ASSERT(m_Count > 0);
        1823  return m_pArray[0];
        1824  }
        1825  T& back()
        1826  {
        1827  VMA_HEAVY_ASSERT(m_Count > 0);
        1828  return m_pArray[m_Count - 1];
        1829  }
        1830  const T& back() const
        1831  {
        1832  VMA_HEAVY_ASSERT(m_Count > 0);
        1833  return m_pArray[m_Count - 1];
        1834  }
        1835 
        1836  void reserve(size_t newCapacity, bool freeMemory = false)
        1837  {
        1838  newCapacity = VMA_MAX(newCapacity, m_Count);
        1839 
        1840  if((newCapacity < m_Capacity) && !freeMemory)
        1841  {
        1842  newCapacity = m_Capacity;
        1843  }
        1844 
        1845  if(newCapacity != m_Capacity)
        1846  {
        1847  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        1848  if(m_Count != 0)
        1849  {
        1850  memcpy(newArray, m_pArray, m_Count * sizeof(T));
        1851  }
        1852  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        1853  m_Capacity = newCapacity;
        1854  m_pArray = newArray;
        1855  }
        1856  }
        1857 
        1858  void resize(size_t newCount, bool freeMemory = false)
        1859  {
        1860  size_t newCapacity = m_Capacity;
        1861  if(newCount > m_Capacity)
        1862  {
        1863  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
        1864  }
        1865  else if(freeMemory)
        1866  {
        1867  newCapacity = newCount;
        1868  }
        1869 
        1870  if(newCapacity != m_Capacity)
        1871  {
        1872  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        1873  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        1874  if(elementsToCopy != 0)
        1875  {
        1876  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        1877  }
        1878  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        1879  m_Capacity = newCapacity;
        1880  m_pArray = newArray;
        1881  }
        1882 
        1883  m_Count = newCount;
        1884  }
        1885 
        1886  void clear(bool freeMemory = false)
        1887  {
        1888  resize(0, freeMemory);
        1889  }
        1890 
        1891  void insert(size_t index, const T& src)
        1892  {
        1893  VMA_HEAVY_ASSERT(index <= m_Count);
        1894  const size_t oldCount = size();
        1895  resize(oldCount + 1);
        1896  if(index < oldCount)
        1897  {
        1898  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
        1899  }
        1900  m_pArray[index] = src;
        1901  }
        1902 
        1903  void remove(size_t index)
        1904  {
        1905  VMA_HEAVY_ASSERT(index < m_Count);
        1906  const size_t oldCount = size();
        1907  if(index < oldCount - 1)
        1908  {
        1909  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
        1910  }
        1911  resize(oldCount - 1);
        1912  }
        1913 
        1914  void push_back(const T& src)
        1915  {
        1916  const size_t newIndex = size();
        1917  resize(newIndex + 1);
        1918  m_pArray[newIndex] = src;
        1919  }
        1920 
        1921  void pop_back()
        1922  {
        1923  VMA_HEAVY_ASSERT(m_Count > 0);
        1924  resize(size() - 1);
        1925  }
        1926 
        1927  void push_front(const T& src)
        1928  {
        1929  insert(0, src);
        1930  }
        1931 
        1932  void pop_front()
        1933  {
        1934  VMA_HEAVY_ASSERT(m_Count > 0);
        1935  remove(0);
        1936  }
        1937 
        1938  typedef T* iterator;
        1939 
        1940  iterator begin() { return m_pArray; }
        1941  iterator end() { return m_pArray + m_Count; }
        1942 
        1943 private:
        1944  AllocatorT m_Allocator;
        1945  T* m_pArray;
        1946  size_t m_Count;
        1947  size_t m_Capacity;
        1948 };
        1949 
        1950 template<typename T, typename allocatorT>
        1951 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
        1952 {
        1953  vec.insert(index, item);
        1954 }
        1955 
        1956 template<typename T, typename allocatorT>
        1957 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
        1958 {
        1959  vec.remove(index);
        1960 }
        1961 
        1962 #endif // #if VMA_USE_STL_VECTOR
        1963 
        1964 template<typename CmpLess, typename VectorT>
        1965 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
        1966 {
        1967  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        1968  vector.data(),
        1969  vector.data() + vector.size(),
        1970  value,
        1971  CmpLess()) - vector.data();
        1972  VmaVectorInsert(vector, indexToInsert, value);
        1973  return indexToInsert;
        1974 }
        1975 
        1976 template<typename CmpLess, typename VectorT>
        1977 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
        1978 {
        1979  CmpLess comparator;
        1980  VectorT::iterator it = VmaBinaryFindFirstNotLess(
        1981  vector.data(),
        1982  vector.data() + vector.size(),
        1983  value,
        1984  comparator);
        1985  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        1986  {
        1987  size_t indexToRemove = it - vector.begin();
        1988  VmaVectorRemove(vector, indexToRemove);
        1989  return true;
        1990  }
        1991  return false;
        1992 }
        1993 
        1994 template<typename CmpLess, typename VectorT>
        1995 size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)
        1996 {
        1997  CmpLess comparator;
        1998  VectorT::iterator it = VmaBinaryFindFirstNotLess(
        1999  vector.data(),
        2000  vector.data() + vector.size(),
        2001  value,
        2002  comparator);
        2003  if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))
        2004  {
        2005  return it - vector.begin();
        2006  }
        2007  else
        2008  {
        2009  return vector.size();
        2010  }
        2011 }
        2012 
        2014 // class VmaPoolAllocator
        2015 
        2016 /*
        2017 Allocator for objects of type T using a list of arrays (pools) to speed up
        2018 allocation. Number of elements that can be allocated is not bounded because
        2019 allocator can create multiple blocks.
        2020 */
        2021 template<typename T>
        2022 class VmaPoolAllocator
        2023 {
        2024 public:
        2025  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
        2026  ~VmaPoolAllocator();
        2027  void Clear();
        2028  T* Alloc();
        2029  void Free(T* ptr);
        2030 
        2031 private:
        2032  union Item
        2033  {
        2034  uint32_t NextFreeIndex;
        2035  T Value;
        2036  };
        2037 
        2038  struct ItemBlock
        2039  {
        2040  Item* pItems;
        2041  uint32_t FirstFreeIndex;
        2042  };
        2043 
        2044  const VkAllocationCallbacks* m_pAllocationCallbacks;
        2045  size_t m_ItemsPerBlock;
        2046  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
        2047 
        2048  ItemBlock& CreateNewBlock();
        2049 };
        2050 
        2051 template<typename T>
        2052 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
        2053  m_pAllocationCallbacks(pAllocationCallbacks),
        2054  m_ItemsPerBlock(itemsPerBlock),
        2055  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
        2056 {
        2057  VMA_ASSERT(itemsPerBlock > 0);
        2058 }
        2059 
        2060 template<typename T>
        2061 VmaPoolAllocator<T>::~VmaPoolAllocator()
        2062 {
        2063  Clear();
        2064 }
        2065 
        2066 template<typename T>
        2067 void VmaPoolAllocator<T>::Clear()
        2068 {
        2069  for(size_t i = m_ItemBlocks.size(); i--; )
        2070  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
        2071  m_ItemBlocks.clear();
        2072 }
        2073 
        2074 template<typename T>
        2075 T* VmaPoolAllocator<T>::Alloc()
        2076 {
        2077  for(size_t i = m_ItemBlocks.size(); i--; )
        2078  {
        2079  ItemBlock& block = m_ItemBlocks[i];
        2080  // This block has some free items: Use first one.
        2081  if(block.FirstFreeIndex != UINT32_MAX)
        2082  {
        2083  Item* const pItem = &block.pItems[block.FirstFreeIndex];
        2084  block.FirstFreeIndex = pItem->NextFreeIndex;
        2085  return &pItem->Value;
        2086  }
        2087  }
        2088 
        2089  // No block has free item: Create new one and use it.
        2090  ItemBlock& newBlock = CreateNewBlock();
        2091  Item* const pItem = &newBlock.pItems[0];
        2092  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
        2093  return &pItem->Value;
        2094 }
        2095 
        2096 template<typename T>
        2097 void VmaPoolAllocator<T>::Free(T* ptr)
        2098 {
        2099  // Search all memory blocks to find ptr.
        2100  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
        2101  {
        2102  ItemBlock& block = m_ItemBlocks[i];
        2103 
        2104  // Casting to union.
        2105  Item* pItemPtr;
        2106  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
        2107 
        2108  // Check if pItemPtr is in address range of this block.
        2109  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
        2110  {
        2111  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
        2112  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
        2113  block.FirstFreeIndex = index;
        2114  return;
        2115  }
        2116  }
        2117  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
        2118 }
        2119 
        2120 template<typename T>
        2121 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
        2122 {
        2123  ItemBlock newBlock = {
        2124  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
        2125 
        2126  m_ItemBlocks.push_back(newBlock);
        2127 
        2128  // Setup singly-linked list of all free items in this block.
        2129  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
        2130  newBlock.pItems[i].NextFreeIndex = i + 1;
        2131  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
        2132  return m_ItemBlocks.back();
        2133 }
        2134 
        2136 // class VmaRawList, VmaList
        2137 
        2138 #if VMA_USE_STL_LIST
        2139 
        2140 #define VmaList std::list
        2141 
        2142 #else // #if VMA_USE_STL_LIST
        2143 
        2144 template<typename T>
        2145 struct VmaListItem
        2146 {
        2147  VmaListItem* pPrev;
        2148  VmaListItem* pNext;
        2149  T Value;
        2150 };
        2151 
        2152 // Doubly linked list.
        2153 template<typename T>
        2154 class VmaRawList
        2155 {
        2156 public:
        2157  typedef VmaListItem<T> ItemType;
        2158 
        2159  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
        2160  ~VmaRawList();
        2161  void Clear();
        2162 
        2163  size_t GetCount() const { return m_Count; }
        2164  bool IsEmpty() const { return m_Count == 0; }
        2165 
        2166  ItemType* Front() { return m_pFront; }
        2167  const ItemType* Front() const { return m_pFront; }
        2168  ItemType* Back() { return m_pBack; }
        2169  const ItemType* Back() const { return m_pBack; }
        2170 
        2171  ItemType* PushBack();
        2172  ItemType* PushFront();
        2173  ItemType* PushBack(const T& value);
        2174  ItemType* PushFront(const T& value);
        2175  void PopBack();
        2176  void PopFront();
        2177 
        2178  // Item can be null - it means PushBack.
        2179  ItemType* InsertBefore(ItemType* pItem);
        2180  // Item can be null - it means PushFront.
        2181  ItemType* InsertAfter(ItemType* pItem);
        2182 
        2183  ItemType* InsertBefore(ItemType* pItem, const T& value);
        2184  ItemType* InsertAfter(ItemType* pItem, const T& value);
        2185 
        2186  void Remove(ItemType* pItem);
        2187 
        2188 private:
        2189  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        2190  VmaPoolAllocator<ItemType> m_ItemAllocator;
        2191  ItemType* m_pFront;
        2192  ItemType* m_pBack;
        2193  size_t m_Count;
        2194 
        2195  // Declared not defined, to block copy constructor and assignment operator.
        2196  VmaRawList(const VmaRawList<T>& src);
        2197  VmaRawList<T>& operator=(const VmaRawList<T>& rhs);
        2198 };
        2199 
        2200 template<typename T>
        2201 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
        2202  m_pAllocationCallbacks(pAllocationCallbacks),
        2203  m_ItemAllocator(pAllocationCallbacks, 128),
        2204  m_pFront(VMA_NULL),
        2205  m_pBack(VMA_NULL),
        2206  m_Count(0)
        2207 {
        2208 }
        2209 
        2210 template<typename T>
        2211 VmaRawList<T>::~VmaRawList()
        2212 {
        2213  // Intentionally not calling Clear, because that would be unnecessary
        2214  // computations to return all items to m_ItemAllocator as free.
        2215 }
        2216 
        2217 template<typename T>
        2218 void VmaRawList<T>::Clear()
        2219 {
        2220  if(IsEmpty() == false)
        2221  {
        2222  ItemType* pItem = m_pBack;
        2223  while(pItem != VMA_NULL)
        2224  {
        2225  ItemType* const pPrevItem = pItem->pPrev;
        2226  m_ItemAllocator.Free(pItem);
        2227  pItem = pPrevItem;
        2228  }
        2229  m_pFront = VMA_NULL;
        2230  m_pBack = VMA_NULL;
        2231  m_Count = 0;
        2232  }
        2233 }
        2234 
        2235 template<typename T>
        2236 VmaListItem<T>* VmaRawList<T>::PushBack()
        2237 {
        2238  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        2239  pNewItem->pNext = VMA_NULL;
        2240  if(IsEmpty())
        2241  {
        2242  pNewItem->pPrev = VMA_NULL;
        2243  m_pFront = pNewItem;
        2244  m_pBack = pNewItem;
        2245  m_Count = 1;
        2246  }
        2247  else
        2248  {
        2249  pNewItem->pPrev = m_pBack;
        2250  m_pBack->pNext = pNewItem;
        2251  m_pBack = pNewItem;
        2252  ++m_Count;
        2253  }
        2254  return pNewItem;
        2255 }
        2256 
        2257 template<typename T>
        2258 VmaListItem<T>* VmaRawList<T>::PushFront()
        2259 {
        2260  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        2261  pNewItem->pPrev = VMA_NULL;
        2262  if(IsEmpty())
        2263  {
        2264  pNewItem->pNext = VMA_NULL;
        2265  m_pFront = pNewItem;
        2266  m_pBack = pNewItem;
        2267  m_Count = 1;
        2268  }
        2269  else
        2270  {
        2271  pNewItem->pNext = m_pFront;
        2272  m_pFront->pPrev = pNewItem;
        2273  m_pFront = pNewItem;
        2274  ++m_Count;
        2275  }
        2276  return pNewItem;
        2277 }
        2278 
        2279 template<typename T>
        2280 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
        2281 {
        2282  ItemType* const pNewItem = PushBack();
        2283  pNewItem->Value = value;
        2284  return pNewItem;
        2285 }
        2286 
        2287 template<typename T>
        2288 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
        2289 {
        2290  ItemType* const pNewItem = PushFront();
        2291  pNewItem->Value = value;
        2292  return pNewItem;
        2293 }
        2294 
        2295 template<typename T>
        2296 void VmaRawList<T>::PopBack()
        2297 {
        2298  VMA_HEAVY_ASSERT(m_Count > 0);
        2299  ItemType* const pBackItem = m_pBack;
        2300  ItemType* const pPrevItem = pBackItem->pPrev;
        2301  if(pPrevItem != VMA_NULL)
        2302  {
        2303  pPrevItem->pNext = VMA_NULL;
        2304  }
        2305  m_pBack = pPrevItem;
        2306  m_ItemAllocator.Free(pBackItem);
        2307  --m_Count;
        2308 }
        2309 
        2310 template<typename T>
        2311 void VmaRawList<T>::PopFront()
        2312 {
        2313  VMA_HEAVY_ASSERT(m_Count > 0);
        2314  ItemType* const pFrontItem = m_pFront;
        2315  ItemType* const pNextItem = pFrontItem->pNext;
        2316  if(pNextItem != VMA_NULL)
        2317  {
        2318  pNextItem->pPrev = VMA_NULL;
        2319  }
        2320  m_pFront = pNextItem;
        2321  m_ItemAllocator.Free(pFrontItem);
        2322  --m_Count;
        2323 }
        2324 
        2325 template<typename T>
        2326 void VmaRawList<T>::Remove(ItemType* pItem)
        2327 {
        2328  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
        2329  VMA_HEAVY_ASSERT(m_Count > 0);
        2330 
        2331  if(pItem->pPrev != VMA_NULL)
        2332  {
        2333  pItem->pPrev->pNext = pItem->pNext;
        2334  }
        2335  else
        2336  {
        2337  VMA_HEAVY_ASSERT(m_pFront == pItem);
        2338  m_pFront = pItem->pNext;
        2339  }
        2340 
        2341  if(pItem->pNext != VMA_NULL)
        2342  {
        2343  pItem->pNext->pPrev = pItem->pPrev;
        2344  }
        2345  else
        2346  {
        2347  VMA_HEAVY_ASSERT(m_pBack == pItem);
        2348  m_pBack = pItem->pPrev;
        2349  }
        2350 
        2351  m_ItemAllocator.Free(pItem);
        2352  --m_Count;
        2353 }
        2354 
        2355 template<typename T>
        2356 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
        2357 {
        2358  if(pItem != VMA_NULL)
        2359  {
        2360  ItemType* const prevItem = pItem->pPrev;
        2361  ItemType* const newItem = m_ItemAllocator.Alloc();
        2362  newItem->pPrev = prevItem;
        2363  newItem->pNext = pItem;
        2364  pItem->pPrev = newItem;
        2365  if(prevItem != VMA_NULL)
        2366  {
        2367  prevItem->pNext = newItem;
        2368  }
        2369  else
        2370  {
        2371  VMA_HEAVY_ASSERT(m_pFront == pItem);
        2372  m_pFront = newItem;
        2373  }
        2374  ++m_Count;
        2375  return newItem;
        2376  }
        2377  else
        2378  return PushBack();
        2379 }
        2380 
        2381 template<typename T>
        2382 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
        2383 {
        2384  if(pItem != VMA_NULL)
        2385  {
        2386  ItemType* const nextItem = pItem->pNext;
        2387  ItemType* const newItem = m_ItemAllocator.Alloc();
        2388  newItem->pNext = nextItem;
        2389  newItem->pPrev = pItem;
        2390  pItem->pNext = newItem;
        2391  if(nextItem != VMA_NULL)
        2392  {
        2393  nextItem->pPrev = newItem;
        2394  }
        2395  else
        2396  {
        2397  VMA_HEAVY_ASSERT(m_pBack == pItem);
        2398  m_pBack = newItem;
        2399  }
        2400  ++m_Count;
        2401  return newItem;
        2402  }
        2403  else
        2404  return PushFront();
        2405 }
        2406 
        2407 template<typename T>
        2408 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
        2409 {
        2410  ItemType* const newItem = InsertBefore(pItem);
        2411  newItem->Value = value;
        2412  return newItem;
        2413 }
        2414 
        2415 template<typename T>
        2416 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
        2417 {
        2418  ItemType* const newItem = InsertAfter(pItem);
        2419  newItem->Value = value;
        2420  return newItem;
        2421 }
        2422 
        2423 template<typename T, typename AllocatorT>
        2424 class VmaList
        2425 {
        2426 public:
        2427  class iterator
        2428  {
        2429  public:
        2430  iterator() :
        2431  m_pList(VMA_NULL),
        2432  m_pItem(VMA_NULL)
        2433  {
        2434  }
        2435 
        2436  T& operator*() const
        2437  {
        2438  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2439  return m_pItem->Value;
        2440  }
        2441  T* operator->() const
        2442  {
        2443  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2444  return &m_pItem->Value;
        2445  }
        2446 
        2447  iterator& operator++()
        2448  {
        2449  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2450  m_pItem = m_pItem->pNext;
        2451  return *this;
        2452  }
        2453  iterator& operator--()
        2454  {
        2455  if(m_pItem != VMA_NULL)
        2456  {
        2457  m_pItem = m_pItem->pPrev;
        2458  }
        2459  else
        2460  {
        2461  VMA_HEAVY_ASSERT(!m_pList.IsEmpty());
        2462  m_pItem = m_pList->Back();
        2463  }
        2464  return *this;
        2465  }
        2466 
        2467  iterator operator++(int)
        2468  {
        2469  iterator result = *this;
        2470  ++*this;
        2471  return result;
        2472  }
        2473  iterator operator--(int)
        2474  {
        2475  iterator result = *this;
        2476  --*this;
        2477  return result;
        2478  }
        2479 
        2480  bool operator==(const iterator& rhs) const
        2481  {
        2482  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2483  return m_pItem == rhs.m_pItem;
        2484  }
        2485  bool operator!=(const iterator& rhs) const
        2486  {
        2487  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2488  return m_pItem != rhs.m_pItem;
        2489  }
        2490 
        2491  private:
        2492  VmaRawList<T>* m_pList;
        2493  VmaListItem<T>* m_pItem;
        2494 
        2495  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
        2496  m_pList(pList),
        2497  m_pItem(pItem)
        2498  {
        2499  }
        2500 
        2501  friend class VmaList<T, AllocatorT>;
        2502  };
        2503 
        2504  class const_iterator
        2505  {
        2506  public:
        2507  const_iterator() :
        2508  m_pList(VMA_NULL),
        2509  m_pItem(VMA_NULL)
        2510  {
        2511  }
        2512 
        2513  const_iterator(const iterator& src) :
        2514  m_pList(src.m_pList),
        2515  m_pItem(src.m_pItem)
        2516  {
        2517  }
        2518 
        2519  const T& operator*() const
        2520  {
        2521  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2522  return m_pItem->Value;
        2523  }
        2524  const T* operator->() const
        2525  {
        2526  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2527  return &m_pItem->Value;
        2528  }
        2529 
        2530  const_iterator& operator++()
        2531  {
        2532  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2533  m_pItem = m_pItem->pNext;
        2534  return *this;
        2535  }
        2536  const_iterator& operator--()
        2537  {
        2538  if(m_pItem != VMA_NULL)
        2539  {
        2540  m_pItem = m_pItem->pPrev;
        2541  }
        2542  else
        2543  {
        2544  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        2545  m_pItem = m_pList->Back();
        2546  }
        2547  return *this;
        2548  }
        2549 
        2550  const_iterator operator++(int)
        2551  {
        2552  const_iterator result = *this;
        2553  ++*this;
        2554  return result;
        2555  }
        2556  const_iterator operator--(int)
        2557  {
        2558  const_iterator result = *this;
        2559  --*this;
        2560  return result;
        2561  }
        2562 
        2563  bool operator==(const const_iterator& rhs) const
        2564  {
        2565  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2566  return m_pItem == rhs.m_pItem;
        2567  }
        2568  bool operator!=(const const_iterator& rhs) const
        2569  {
        2570  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2571  return m_pItem != rhs.m_pItem;
        2572  }
        2573 
        2574  private:
        2575  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
        2576  m_pList(pList),
        2577  m_pItem(pItem)
        2578  {
        2579  }
        2580 
        2581  const VmaRawList<T>* m_pList;
        2582  const VmaListItem<T>* m_pItem;
        2583 
        2584  friend class VmaList<T, AllocatorT>;
        2585  };
        2586 
        2587  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
        2588 
        2589  bool empty() const { return m_RawList.IsEmpty(); }
        2590  size_t size() const { return m_RawList.GetCount(); }
        2591 
        2592  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
        2593  iterator end() { return iterator(&m_RawList, VMA_NULL); }
        2594 
        2595  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
        2596  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
        2597 
        2598  void clear() { m_RawList.Clear(); }
        2599  void push_back(const T& value) { m_RawList.PushBack(value); }
        2600  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
        2601  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
        2602 
        2603 private:
        2604  VmaRawList<T> m_RawList;
        2605 };
        2606 
        2607 #endif // #if VMA_USE_STL_LIST
        2608 
        2610 // class VmaMap
        2611 
        2612 // Unused in this version.
        2613 #if 0
        2614 
        2615 #if VMA_USE_STL_UNORDERED_MAP
        2616 
        2617 #define VmaPair std::pair
        2618 
        2619 #define VMA_MAP_TYPE(KeyT, ValueT) \
        2620  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
        2621 
        2622 #else // #if VMA_USE_STL_UNORDERED_MAP
        2623 
        2624 template<typename T1, typename T2>
        2625 struct VmaPair
        2626 {
        2627  T1 first;
        2628  T2 second;
        2629 
        2630  VmaPair() : first(), second() { }
        2631  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
        2632 };
        2633 
        2634 /* Class compatible with subset of interface of std::unordered_map.
        2635 KeyT, ValueT must be POD because they will be stored in VmaVector.
        2636 */
        2637 template<typename KeyT, typename ValueT>
        2638 class VmaMap
        2639 {
        2640 public:
        2641  typedef VmaPair<KeyT, ValueT> PairType;
        2642  typedef PairType* iterator;
        2643 
        2644  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
        2645 
        2646  iterator begin() { return m_Vector.begin(); }
        2647  iterator end() { return m_Vector.end(); }
        2648 
        2649  void insert(const PairType& pair);
        2650  iterator find(const KeyT& key);
        2651  void erase(iterator it);
        2652 
        2653 private:
        2654  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
        2655 };
        2656 
        2657 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
        2658 
        2659 template<typename FirstT, typename SecondT>
        2660 struct VmaPairFirstLess
        2661 {
        2662  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
        2663  {
        2664  return lhs.first < rhs.first;
        2665  }
        2666  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
        2667  {
        2668  return lhs.first < rhsFirst;
        2669  }
        2670 };
        2671 
        2672 template<typename KeyT, typename ValueT>
        2673 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
        2674 {
        2675  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        2676  m_Vector.data(),
        2677  m_Vector.data() + m_Vector.size(),
        2678  pair,
        2679  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
        2680  VmaVectorInsert(m_Vector, indexToInsert, pair);
        2681 }
        2682 
        2683 template<typename KeyT, typename ValueT>
        2684 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
        2685 {
        2686  PairType* it = VmaBinaryFindFirstNotLess(
        2687  m_Vector.data(),
        2688  m_Vector.data() + m_Vector.size(),
        2689  key,
        2690  VmaPairFirstLess<KeyT, ValueT>());
        2691  if((it != m_Vector.end()) && (it->first == key))
        2692  {
        2693  return it;
        2694  }
        2695  else
        2696  {
        2697  return m_Vector.end();
        2698  }
        2699 }
        2700 
        2701 template<typename KeyT, typename ValueT>
        2702 void VmaMap<KeyT, ValueT>::erase(iterator it)
        2703 {
        2704  VmaVectorRemove(m_Vector, it - m_Vector.begin());
        2705 }
        2706 
        2707 #endif // #if VMA_USE_STL_UNORDERED_MAP
        2708 
        2709 #endif // #if 0
        2710 
        2712 
        2713 class VmaDeviceMemoryBlock;
        2714 
        2715 enum VMA_BLOCK_VECTOR_TYPE
        2716 {
        2717  VMA_BLOCK_VECTOR_TYPE_UNMAPPED,
        2718  VMA_BLOCK_VECTOR_TYPE_MAPPED,
        2719  VMA_BLOCK_VECTOR_TYPE_COUNT
        2720 };
        2721 
        2722 static VMA_BLOCK_VECTOR_TYPE VmaAllocationCreateFlagsToBlockVectorType(VmaAllocationCreateFlags flags)
        2723 {
        2724  return (flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0 ?
        2725  VMA_BLOCK_VECTOR_TYPE_MAPPED :
        2726  VMA_BLOCK_VECTOR_TYPE_UNMAPPED;
        2727 }
        2728 
        2729 struct VmaAllocation_T
        2730 {
        2731 public:
        2732  enum ALLOCATION_TYPE
        2733  {
        2734  ALLOCATION_TYPE_NONE,
        2735  ALLOCATION_TYPE_BLOCK,
        2736  ALLOCATION_TYPE_OWN,
        2737  };
        2738 
        2739  VmaAllocation_T(uint32_t currentFrameIndex) :
        2740  m_Alignment(1),
        2741  m_Size(0),
        2742  m_pUserData(VMA_NULL),
        2743  m_Type(ALLOCATION_TYPE_NONE),
        2744  m_SuballocationType(VMA_SUBALLOCATION_TYPE_UNKNOWN),
        2745  m_LastUseFrameIndex(currentFrameIndex)
        2746  {
        2747  }
        2748 
        2749  void InitBlockAllocation(
        2750  VmaPool hPool,
        2751  VmaDeviceMemoryBlock* block,
        2752  VkDeviceSize offset,
        2753  VkDeviceSize alignment,
        2754  VkDeviceSize size,
        2755  VmaSuballocationType suballocationType,
        2756  void* pUserData,
        2757  bool canBecomeLost)
        2758  {
        2759  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        2760  VMA_ASSERT(block != VMA_NULL);
        2761  m_Type = ALLOCATION_TYPE_BLOCK;
        2762  m_Alignment = alignment;
        2763  m_Size = size;
        2764  m_pUserData = pUserData;
        2765  m_SuballocationType = suballocationType;
        2766  m_BlockAllocation.m_hPool = hPool;
        2767  m_BlockAllocation.m_Block = block;
        2768  m_BlockAllocation.m_Offset = offset;
        2769  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
        2770  }
        2771 
        2772  void InitLost()
        2773  {
        2774  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        2775  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
        2776  m_Type = ALLOCATION_TYPE_BLOCK;
        2777  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
        2778  m_BlockAllocation.m_Block = VMA_NULL;
        2779  m_BlockAllocation.m_Offset = 0;
        2780  m_BlockAllocation.m_CanBecomeLost = true;
        2781  }
        2782 
        2783  void ChangeBlockAllocation(
        2784  VmaDeviceMemoryBlock* block,
        2785  VkDeviceSize offset)
        2786  {
        2787  VMA_ASSERT(block != VMA_NULL);
        2788  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        2789  m_BlockAllocation.m_Block = block;
        2790  m_BlockAllocation.m_Offset = offset;
        2791  }
        2792 
        2793  void InitOwnAllocation(
        2794  uint32_t memoryTypeIndex,
        2795  VkDeviceMemory hMemory,
        2796  VmaSuballocationType suballocationType,
        2797  bool persistentMap,
        2798  void* pMappedData,
        2799  VkDeviceSize size,
        2800  void* pUserData)
        2801  {
        2802  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        2803  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
        2804  m_Type = ALLOCATION_TYPE_OWN;
        2805  m_Alignment = 0;
        2806  m_Size = size;
        2807  m_pUserData = pUserData;
        2808  m_SuballocationType = suballocationType;
        2809  m_OwnAllocation.m_MemoryTypeIndex = memoryTypeIndex;
        2810  m_OwnAllocation.m_hMemory = hMemory;
        2811  m_OwnAllocation.m_PersistentMap = persistentMap;
        2812  m_OwnAllocation.m_pMappedData = pMappedData;
        2813  }
        2814 
        2815  ALLOCATION_TYPE GetType() const { return m_Type; }
        2816  VkDeviceSize GetAlignment() const { return m_Alignment; }
        2817  VkDeviceSize GetSize() const { return m_Size; }
        2818  void* GetUserData() const { return m_pUserData; }
        2819  void SetUserData(void* pUserData) { m_pUserData = pUserData; }
        2820  VmaSuballocationType GetSuballocationType() const { return m_SuballocationType; }
        2821 
        2822  VmaDeviceMemoryBlock* GetBlock() const
        2823  {
        2824  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        2825  return m_BlockAllocation.m_Block;
        2826  }
        2827  VkDeviceSize GetOffset() const;
        2828  VkDeviceMemory GetMemory() const;
        2829  uint32_t GetMemoryTypeIndex() const;
        2830  VMA_BLOCK_VECTOR_TYPE GetBlockVectorType() const;
        2831  void* GetMappedData() const;
        2832  bool CanBecomeLost() const;
        2833  VmaPool GetPool() const;
        2834 
        2835  VkResult OwnAllocMapPersistentlyMappedMemory(VkDevice hDevice)
        2836  {
        2837  VMA_ASSERT(m_Type == ALLOCATION_TYPE_OWN);
        2838  if(m_OwnAllocation.m_PersistentMap)
        2839  {
        2840  return vkMapMemory(hDevice, m_OwnAllocation.m_hMemory, 0, VK_WHOLE_SIZE, 0, &m_OwnAllocation.m_pMappedData);
        2841  }
        2842  return VK_SUCCESS;
        2843  }
        2844  void OwnAllocUnmapPersistentlyMappedMemory(VkDevice hDevice)
        2845  {
        2846  VMA_ASSERT(m_Type == ALLOCATION_TYPE_OWN);
        2847  if(m_OwnAllocation.m_pMappedData)
        2848  {
        2849  VMA_ASSERT(m_OwnAllocation.m_PersistentMap);
        2850  vkUnmapMemory(hDevice, m_OwnAllocation.m_hMemory);
        2851  m_OwnAllocation.m_pMappedData = VMA_NULL;
        2852  }
        2853  }
        2854 
        2855  uint32_t GetLastUseFrameIndex() const
        2856  {
        2857  return m_LastUseFrameIndex.load();
        2858  }
        2859  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
        2860  {
        2861  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
        2862  }
        2863  /*
        2864  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
        2865  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
        2866  - Else, returns false.
        2867 
        2868  If hAllocation is already lost, assert - you should not call it then.
        2869  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
        2870  */
        2871  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        2872 
        2873 private:
        2874  VkDeviceSize m_Alignment;
        2875  VkDeviceSize m_Size;
        2876  void* m_pUserData;
        2877  ALLOCATION_TYPE m_Type;
        2878  VmaSuballocationType m_SuballocationType;
        2879  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
        2880 
        2881  // Allocation out of VmaDeviceMemoryBlock.
        2882  struct BlockAllocation
        2883  {
        2884  VmaPool m_hPool; // Null if belongs to general memory.
        2885  VmaDeviceMemoryBlock* m_Block;
        2886  VkDeviceSize m_Offset;
        2887  bool m_CanBecomeLost;
        2888  };
        2889 
        2890  // Allocation for an object that has its own private VkDeviceMemory.
        2891  struct OwnAllocation
        2892  {
        2893  uint32_t m_MemoryTypeIndex;
        2894  VkDeviceMemory m_hMemory;
        2895  bool m_PersistentMap;
        2896  void* m_pMappedData;
        2897  };
        2898 
        2899  union
        2900  {
        2901  // Allocation out of VmaDeviceMemoryBlock.
        2902  BlockAllocation m_BlockAllocation;
        2903  // Allocation for an object that has its own private VkDeviceMemory.
        2904  OwnAllocation m_OwnAllocation;
        2905  };
        2906 };
        2907 
        2908 /*
        2909 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
        2910 allocated memory block or free.
        2911 */
        2912 struct VmaSuballocation
        2913 {
        2914  VkDeviceSize offset;
        2915  VkDeviceSize size;
        2916  VmaAllocation hAllocation;
        2917  VmaSuballocationType type;
        2918 };
        2919 
        2920 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
        2921 
        2922 // Cost of one additional allocation lost, as equivalent in bytes.
        2923 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
        2924 
        2925 /*
        2926 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
        2927 
        2928 If canMakeOtherLost was false:
        2929 - item points to a FREE suballocation.
        2930 - itemsToMakeLostCount is 0.
        2931 
        2932 If canMakeOtherLost was true:
        2933 - item points to first of sequence of suballocations, which are either FREE,
        2934  or point to VmaAllocations that can become lost.
        2935 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
        2936  the requested allocation to succeed.
        2937 */
        2938 struct VmaAllocationRequest
        2939 {
        2940  VkDeviceSize offset;
        2941  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
        2942  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
        2943  VmaSuballocationList::iterator item;
        2944  size_t itemsToMakeLostCount;
        2945 
        2946  VkDeviceSize CalcCost() const
        2947  {
        2948  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
        2949  }
        2950 };
        2951 
        2952 /*
        2953 Represents a single block of device memory (VkDeviceMemory ) with all the
        2954 data about its regions (aka suballocations, VmaAllocation), assigned and free.
        2955 
        2956 Thread-safety: This class must be externally synchronized.
        2957 */
        2958 class VmaDeviceMemoryBlock
        2959 {
        2960 public:
        2961  uint32_t m_MemoryTypeIndex;
        2962  VMA_BLOCK_VECTOR_TYPE m_BlockVectorType;
        2963  VkDeviceMemory m_hMemory;
        2964  VkDeviceSize m_Size;
        2965  bool m_PersistentMap;
        2966  void* m_pMappedData;
        2967  uint32_t m_FreeCount;
        2968  VkDeviceSize m_SumFreeSize;
        2969  VmaSuballocationList m_Suballocations;
        2970  // Suballocations that are free and have size greater than certain threshold.
        2971  // Sorted by size, ascending.
        2972  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
        2973 
        2974  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
        2975 
        2976  ~VmaDeviceMemoryBlock()
        2977  {
        2978  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        2979  }
        2980 
        2981  // Always call after construction.
        2982  void Init(
        2983  uint32_t newMemoryTypeIndex,
        2984  VMA_BLOCK_VECTOR_TYPE newBlockVectorType,
        2985  VkDeviceMemory newMemory,
        2986  VkDeviceSize newSize,
        2987  bool persistentMap,
        2988  void* pMappedData);
        2989  // Always call before destruction.
        2990  void Destroy(VmaAllocator allocator);
        2991 
        2992  // Validates all data structures inside this object. If not valid, returns false.
        2993  bool Validate() const;
        2994 
        2995  // Tries to find a place for suballocation with given parameters inside this allocation.
        2996  // If succeeded, fills pAllocationRequest and returns true.
        2997  // If failed, returns false.
        2998  bool CreateAllocationRequest(
        2999  uint32_t currentFrameIndex,
        3000  uint32_t frameInUseCount,
        3001  VkDeviceSize bufferImageGranularity,
        3002  VkDeviceSize allocSize,
        3003  VkDeviceSize allocAlignment,
        3004  VmaSuballocationType allocType,
        3005  bool canMakeOtherLost,
        3006  VmaAllocationRequest* pAllocationRequest);
        3007 
        3008  bool MakeRequestedAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount, VmaAllocationRequest* pAllocationRequest);
        3009 
        3010  uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        3011 
        3012  // Returns true if this allocation is empty - contains only single free suballocation.
        3013  bool IsEmpty() const;
        3014 
        3015  // Makes actual allocation based on request. Request must already be checked
        3016  // and valid.
        3017  void Alloc(
        3018  const VmaAllocationRequest& request,
        3019  VmaSuballocationType type,
        3020  VkDeviceSize allocSize,
        3021  VmaAllocation hAllocation);
        3022 
        3023  // Frees suballocation assigned to given memory region.
        3024  void Free(const VmaAllocation allocation);
        3025 
        3026 #if VMA_STATS_STRING_ENABLED
        3027  void PrintDetailedMap(class VmaJsonWriter& json) const;
        3028 #endif
        3029 
        3030 private:
        3031  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
        3032  // If yes, fills pOffset and returns true. If no, returns false.
        3033  bool CheckAllocation(
        3034  uint32_t currentFrameIndex,
        3035  uint32_t frameInUseCount,
        3036  VkDeviceSize bufferImageGranularity,
        3037  VkDeviceSize allocSize,
        3038  VkDeviceSize allocAlignment,
        3039  VmaSuballocationType allocType,
        3040  VmaSuballocationList::const_iterator suballocItem,
        3041  bool canMakeOtherLost,
        3042  VkDeviceSize* pOffset,
        3043  size_t* itemsToMakeLostCount,
        3044  VkDeviceSize* pSumFreeSize,
        3045  VkDeviceSize* pSumItemSize) const;
        3046 
        3047  // Given free suballocation, it merges it with following one, which must also be free.
        3048  void MergeFreeWithNext(VmaSuballocationList::iterator item);
        3049  // Releases given suballocation, making it free.
        3050  // Merges it with adjacent free suballocations if applicable.
        3051  // Returns iterator to new free suballocation at this place.
        3052  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
        3053  // Given free suballocation, it inserts it into sorted list of
        3054  // m_FreeSuballocationsBySize if it's suitable.
        3055  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
        3056  // Given free suballocation, it removes it from sorted list of
        3057  // m_FreeSuballocationsBySize if it's suitable.
        3058  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
        3059 
        3060  bool ValidateFreeSuballocationList() const;
        3061 };
        3062 
        3063 struct VmaPointerLess
        3064 {
        3065  bool operator()(const void* lhs, const void* rhs) const
        3066  {
        3067  return lhs < rhs;
        3068  }
        3069 };
        3070 
        3071 class VmaDefragmentator;
        3072 
        3073 /*
        3074 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
        3075 Vulkan memory type.
        3076 
        3077 Synchronized internally with a mutex.
        3078 */
        3079 struct VmaBlockVector
        3080 {
        3081  VmaBlockVector(
        3082  VmaAllocator hAllocator,
        3083  uint32_t memoryTypeIndex,
        3084  VMA_BLOCK_VECTOR_TYPE blockVectorType,
        3085  VkDeviceSize preferredBlockSize,
        3086  size_t minBlockCount,
        3087  size_t maxBlockCount,
        3088  VkDeviceSize bufferImageGranularity,
        3089  uint32_t frameInUseCount,
        3090  bool isCustomPool);
        3091  ~VmaBlockVector();
        3092 
        3093  VkResult CreateMinBlocks();
        3094 
        3095  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        3096  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
        3097  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
        3098  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
        3099  VMA_BLOCK_VECTOR_TYPE GetBlockVectorType() const { return m_BlockVectorType; }
        3100 
        3101  void GetPoolStats(VmaPoolStats* pStats);
        3102 
        3103  bool IsEmpty() const { return m_Blocks.empty(); }
        3104 
        3105  VkResult Allocate(
        3106  VmaPool hCurrentPool,
        3107  uint32_t currentFrameIndex,
        3108  const VkMemoryRequirements& vkMemReq,
        3109  const VmaAllocationCreateInfo& createInfo,
        3110  VmaSuballocationType suballocType,
        3111  VmaAllocation* pAllocation);
        3112 
        3113  void Free(
        3114  VmaAllocation hAllocation);
        3115 
        3116  // Adds statistics of this BlockVector to pStats.
        3117  void AddStats(VmaStats* pStats, uint32_t memTypeIndex, uint32_t memHeapIndex);
        3118 
        3119 #if VMA_STATS_STRING_ENABLED
        3120  void PrintDetailedMap(class VmaJsonWriter& json);
        3121 #endif
        3122 
        3123  void UnmapPersistentlyMappedMemory();
        3124  VkResult MapPersistentlyMappedMemory();
        3125 
        3126  void MakePoolAllocationsLost(
        3127  uint32_t currentFrameIndex,
        3128  size_t* pLostAllocationCount);
        3129 
        3130  VmaDefragmentator* EnsureDefragmentator(
        3131  VkDevice hDevice,
        3132  const VkAllocationCallbacks* pAllocationCallbacks,
        3133  uint32_t currentFrameIndex);
        3134 
        3135  VkResult Defragment(
        3136  VmaDefragmentationStats* pDefragmentationStats,
        3137  VkDeviceSize& maxBytesToMove,
        3138  uint32_t& maxAllocationsToMove);
        3139 
        3140  void DestroyDefragmentator();
        3141 
        3142 private:
        3143  friend class VmaDefragmentator;
        3144 
        3145  const VmaAllocator m_hAllocator;
        3146  const uint32_t m_MemoryTypeIndex;
        3147  const VMA_BLOCK_VECTOR_TYPE m_BlockVectorType;
        3148  const VkDeviceSize m_PreferredBlockSize;
        3149  const size_t m_MinBlockCount;
        3150  const size_t m_MaxBlockCount;
        3151  const VkDeviceSize m_BufferImageGranularity;
        3152  const uint32_t m_FrameInUseCount;
        3153  const bool m_IsCustomPool;
        3154  VMA_MUTEX m_Mutex;
        3155  // Incrementally sorted by sumFreeSize, ascending.
        3156  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
        3157  /* There can be at most one allocation that is completely empty - a
        3158  hysteresis to avoid pessimistic case of alternating creation and destruction
        3159  of a VkDeviceMemory. */
        3160  bool m_HasEmptyBlock;
        3161  VmaDefragmentator* m_pDefragmentator;
        3162 
        3163  // Finds and removes given block from vector.
        3164  void Remove(VmaDeviceMemoryBlock* pBlock);
        3165 
        3166  // Performs single step in sorting m_Blocks. They may not be fully sorted
        3167  // after this call.
        3168  void IncrementallySortBlocks();
        3169 
        3170  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
        3171 };
        3172 
        3173 struct VmaPool_T
        3174 {
        3175 public:
        3176  VmaBlockVector m_BlockVector;
        3177 
        3178  // Takes ownership.
        3179  VmaPool_T(
        3180  VmaAllocator hAllocator,
        3181  const VmaPoolCreateInfo& createInfo);
        3182  ~VmaPool_T();
        3183 
        3184  VmaBlockVector& GetBlockVector() { return m_BlockVector; }
        3185 
        3186 #if VMA_STATS_STRING_ENABLED
        3187  //void PrintDetailedMap(class VmaStringBuilder& sb);
        3188 #endif
        3189 };
        3190 
        3191 class VmaDefragmentator
        3192 {
        3193  const VkDevice m_hDevice;
        3194  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        3195  VmaBlockVector* const m_pBlockVector;
        3196  uint32_t m_CurrentFrameIndex;
        3197  VMA_BLOCK_VECTOR_TYPE m_BlockVectorType;
        3198  VkDeviceSize m_BytesMoved;
        3199  uint32_t m_AllocationsMoved;
        3200 
        3201  struct AllocationInfo
        3202  {
        3203  VmaAllocation m_hAllocation;
        3204  VkBool32* m_pChanged;
        3205 
        3206  AllocationInfo() :
        3207  m_hAllocation(VK_NULL_HANDLE),
        3208  m_pChanged(VMA_NULL)
        3209  {
        3210  }
        3211  };
        3212 
        3213  struct AllocationInfoSizeGreater
        3214  {
        3215  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        3216  {
        3217  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
        3218  }
        3219  };
        3220 
        3221  // Used between AddAllocation and Defragment.
        3222  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        3223 
        3224  struct BlockInfo
        3225  {
        3226  VmaDeviceMemoryBlock* m_pBlock;
        3227  bool m_HasNonMovableAllocations;
        3228  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        3229 
        3230  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
        3231  m_pBlock(VMA_NULL),
        3232  m_HasNonMovableAllocations(true),
        3233  m_Allocations(pAllocationCallbacks),
        3234  m_pMappedDataForDefragmentation(VMA_NULL)
        3235  {
        3236  }
        3237 
        3238  void CalcHasNonMovableAllocations()
        3239  {
        3240  const size_t blockAllocCount =
        3241  m_pBlock->m_Suballocations.size() - m_pBlock->m_FreeCount;
        3242  const size_t defragmentAllocCount = m_Allocations.size();
        3243  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
        3244  }
        3245 
        3246  void SortAllocationsBySizeDescecnding()
        3247  {
        3248  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
        3249  }
        3250 
        3251  VkResult EnsureMapping(VkDevice hDevice, void** ppMappedData)
        3252  {
        3253  // It has already been mapped for defragmentation.
        3254  if(m_pMappedDataForDefragmentation)
        3255  {
        3256  *ppMappedData = m_pMappedDataForDefragmentation;
        3257  return VK_SUCCESS;
        3258  }
        3259 
        3260  // It is persistently mapped.
        3261  if(m_pBlock->m_PersistentMap)
        3262  {
        3263  VMA_ASSERT(m_pBlock->m_pMappedData != VMA_NULL);
        3264  *ppMappedData = m_pBlock->m_pMappedData;
        3265  return VK_SUCCESS;
        3266  }
        3267 
        3268  // Map on first usage.
        3269  VkResult res = vkMapMemory(hDevice, m_pBlock->m_hMemory, 0, VK_WHOLE_SIZE, 0, &m_pMappedDataForDefragmentation);
        3270  *ppMappedData = m_pMappedDataForDefragmentation;
        3271  return res;
        3272  }
        3273 
        3274  void Unmap(VkDevice hDevice)
        3275  {
        3276  if(m_pMappedDataForDefragmentation != VMA_NULL)
        3277  {
        3278  vkUnmapMemory(hDevice, m_pBlock->m_hMemory);
        3279  }
        3280  }
        3281 
        3282  private:
        3283  // Not null if mapped for defragmentation only, not persistently mapped.
        3284  void* m_pMappedDataForDefragmentation;
        3285  };
        3286 
        3287  struct BlockPointerLess
        3288  {
        3289  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
        3290  {
        3291  return pLhsBlockInfo->m_pBlock < pRhsBlock;
        3292  }
        3293  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        3294  {
        3295  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
        3296  }
        3297  };
        3298 
        3299  // 1. Blocks with some non-movable allocations go first.
        3300  // 2. Blocks with smaller sumFreeSize go first.
        3301  struct BlockInfoCompareMoveDestination
        3302  {
        3303  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        3304  {
        3305  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
        3306  {
        3307  return true;
        3308  }
        3309  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
        3310  {
        3311  return false;
        3312  }
        3313  if(pLhsBlockInfo->m_pBlock->m_SumFreeSize < pRhsBlockInfo->m_pBlock->m_SumFreeSize)
        3314  {
        3315  return true;
        3316  }
        3317  return false;
        3318  }
        3319  };
        3320 
        3321  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
        3322  BlockInfoVector m_Blocks;
        3323 
        3324  VkResult DefragmentRound(
        3325  VkDeviceSize maxBytesToMove,
        3326  uint32_t maxAllocationsToMove);
        3327 
        3328  static bool MoveMakesSense(
        3329  size_t dstBlockIndex, VkDeviceSize dstOffset,
        3330  size_t srcBlockIndex, VkDeviceSize srcOffset);
        3331 
        3332 public:
        3333  VmaDefragmentator(
        3334  VkDevice hDevice,
        3335  const VkAllocationCallbacks* pAllocationCallbacks,
        3336  VmaBlockVector* pBlockVector,
        3337  uint32_t currentFrameIndex);
        3338 
        3339  ~VmaDefragmentator();
        3340 
        3341  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        3342  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        3343 
        3344  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        3345 
        3346  VkResult Defragment(
        3347  VkDeviceSize maxBytesToMove,
        3348  uint32_t maxAllocationsToMove);
        3349 };
        3350 
        3351 // Main allocator object.
        3352 struct VmaAllocator_T
        3353 {
        3354  bool m_UseMutex;
        3355  VkDevice m_hDevice;
        3356  bool m_AllocationCallbacksSpecified;
        3357  VkAllocationCallbacks m_AllocationCallbacks;
        3358  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
        3359  // Non-zero when we are inside UnmapPersistentlyMappedMemory...MapPersistentlyMappedMemory.
        3360  // Counter to allow nested calls to these functions.
        3361  uint32_t m_UnmapPersistentlyMappedMemoryCounter;
        3362 
        3363  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
        3364  VkPhysicalDeviceMemoryProperties m_MemProps;
        3365 
        3366  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES][VMA_BLOCK_VECTOR_TYPE_COUNT];
        3367 
        3368  // Each vector is sorted by memory (handle value).
        3369  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
        3370  AllocationVectorType* m_pOwnAllocations[VK_MAX_MEMORY_TYPES][VMA_BLOCK_VECTOR_TYPE_COUNT];
        3371  VMA_MUTEX m_OwnAllocationsMutex[VK_MAX_MEMORY_TYPES];
        3372 
        3373  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
        3374  ~VmaAllocator_T();
        3375 
        3376  const VkAllocationCallbacks* GetAllocationCallbacks() const
        3377  {
        3378  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        3379  }
        3380 
        3381  VkDeviceSize GetBufferImageGranularity() const
        3382  {
        3383  return VMA_MAX(
        3384  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
        3385  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        3386  }
        3387 
        3388  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
        3389  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
        3390 
        3391  // Main allocation function.
        3392  VkResult AllocateMemory(
        3393  const VkMemoryRequirements& vkMemReq,
        3394  const VmaAllocationCreateInfo& createInfo,
        3395  VmaSuballocationType suballocType,
        3396  VmaAllocation* pAllocation);
        3397 
        3398  // Main deallocation function.
        3399  void FreeMemory(const VmaAllocation allocation);
        3400 
        3401  void CalculateStats(VmaStats* pStats);
        3402 
        3403 #if VMA_STATS_STRING_ENABLED
        3404  void PrintDetailedMap(class VmaJsonWriter& json);
        3405 #endif
        3406 
        3407  void UnmapPersistentlyMappedMemory();
        3408  VkResult MapPersistentlyMappedMemory();
        3409 
        3410  VkResult Defragment(
        3411  VmaAllocation* pAllocations,
        3412  size_t allocationCount,
        3413  VkBool32* pAllocationsChanged,
        3414  const VmaDefragmentationInfo* pDefragmentationInfo,
        3415  VmaDefragmentationStats* pDefragmentationStats);
        3416 
        3417  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
        3418 
        3419  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
        3420  void DestroyPool(VmaPool pool);
        3421  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
        3422 
        3423  void SetCurrentFrameIndex(uint32_t frameIndex);
        3424 
        3425  void MakePoolAllocationsLost(
        3426  VmaPool hPool,
        3427  size_t* pLostAllocationCount);
        3428 
        3429  void CreateLostAllocation(VmaAllocation* pAllocation);
        3430 
        3431 private:
        3432  VkDeviceSize m_PreferredLargeHeapBlockSize;
        3433  VkDeviceSize m_PreferredSmallHeapBlockSize;
        3434 
        3435  VkPhysicalDevice m_PhysicalDevice;
        3436  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
        3437 
        3438  VMA_MUTEX m_PoolsMutex;
        3439  // Protected by m_PoolsMutex. Sorted by pointer value.
        3440  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
        3441 
        3442  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
        3443 
        3444  VkResult AllocateMemoryOfType(
        3445  const VkMemoryRequirements& vkMemReq,
        3446  const VmaAllocationCreateInfo& createInfo,
        3447  uint32_t memTypeIndex,
        3448  VmaSuballocationType suballocType,
        3449  VmaAllocation* pAllocation);
        3450 
        3451  // Allocates and registers new VkDeviceMemory specifically for single allocation.
        3452  VkResult AllocateOwnMemory(
        3453  VkDeviceSize size,
        3454  VmaSuballocationType suballocType,
        3455  uint32_t memTypeIndex,
        3456  bool map,
        3457  void* pUserData,
        3458  VmaAllocation* pAllocation);
        3459 
        3460  // Tries to free pMemory as Own Memory. Returns true if found and freed.
        3461  void FreeOwnMemory(VmaAllocation allocation);
        3462 };
        3463 
        3465 // Memory allocation #2 after VmaAllocator_T definition
        3466 
        3467 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
        3468 {
        3469  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
        3470 }
        3471 
        3472 static void VmaFree(VmaAllocator hAllocator, void* ptr)
        3473 {
        3474  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
        3475 }
        3476 
        3477 template<typename T>
        3478 static T* VmaAllocate(VmaAllocator hAllocator)
        3479 {
        3480  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
        3481 }
        3482 
        3483 template<typename T>
        3484 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
        3485 {
        3486  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
        3487 }
        3488 
        3489 template<typename T>
        3490 static void vma_delete(VmaAllocator hAllocator, T* ptr)
        3491 {
        3492  if(ptr != VMA_NULL)
        3493  {
        3494  ptr->~T();
        3495  VmaFree(hAllocator, ptr);
        3496  }
        3497 }
        3498 
        3499 template<typename T>
        3500 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
        3501 {
        3502  if(ptr != VMA_NULL)
        3503  {
        3504  for(size_t i = count; i--; )
        3505  ptr[i].~T();
        3506  VmaFree(hAllocator, ptr);
        3507  }
        3508 }
        3509 
        3511 // VmaStringBuilder
        3512 
        3513 #if VMA_STATS_STRING_ENABLED
        3514 
        3515 class VmaStringBuilder
        3516 {
        3517 public:
        3518  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
        3519  size_t GetLength() const { return m_Data.size(); }
        3520  const char* GetData() const { return m_Data.data(); }
        3521 
        3522  void Add(char ch) { m_Data.push_back(ch); }
        3523  void Add(const char* pStr);
        3524  void AddNewLine() { Add('\n'); }
        3525  void AddNumber(uint32_t num);
        3526  void AddNumber(uint64_t num);
        3527  void AddPointer(const void* ptr);
        3528 
        3529 private:
        3530  VmaVector< char, VmaStlAllocator<char> > m_Data;
        3531 };
        3532 
        3533 void VmaStringBuilder::Add(const char* pStr)
        3534 {
        3535  const size_t strLen = strlen(pStr);
        3536  if(strLen > 0)
        3537  {
        3538  const size_t oldCount = m_Data.size();
        3539  m_Data.resize(oldCount + strLen);
        3540  memcpy(m_Data.data() + oldCount, pStr, strLen);
        3541  }
        3542 }
        3543 
        3544 void VmaStringBuilder::AddNumber(uint32_t num)
        3545 {
        3546  char buf[11];
        3547  VmaUint32ToStr(buf, sizeof(buf), num);
        3548  Add(buf);
        3549 }
        3550 
        3551 void VmaStringBuilder::AddNumber(uint64_t num)
        3552 {
        3553  char buf[21];
        3554  VmaUint64ToStr(buf, sizeof(buf), num);
        3555  Add(buf);
        3556 }
        3557 
        3558 void VmaStringBuilder::AddPointer(const void* ptr)
        3559 {
        3560  char buf[21];
        3561  VmaPtrToStr(buf, sizeof(buf), ptr);
        3562  Add(buf);
        3563 }
        3564 
        3565 #endif // #if VMA_STATS_STRING_ENABLED
        3566 
        3568 // VmaJsonWriter
        3569 
        3570 #if VMA_STATS_STRING_ENABLED
        3571 
        3572 class VmaJsonWriter
        3573 {
        3574 public:
        3575  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
        3576  ~VmaJsonWriter();
        3577 
        3578  void BeginObject(bool singleLine = false);
        3579  void EndObject();
        3580 
        3581  void BeginArray(bool singleLine = false);
        3582  void EndArray();
        3583 
        3584  void WriteString(const char* pStr);
        3585  void BeginString(const char* pStr = VMA_NULL);
        3586  void ContinueString(const char* pStr);
        3587  void ContinueString(uint32_t n);
        3588  void ContinueString(uint64_t n);
        3589  void EndString(const char* pStr = VMA_NULL);
        3590 
        3591  void WriteNumber(uint32_t n);
        3592  void WriteNumber(uint64_t n);
        3593  void WriteBool(bool b);
        3594  void WriteNull();
        3595 
        3596 private:
        3597  static const char* const INDENT;
        3598 
        3599  enum COLLECTION_TYPE
        3600  {
        3601  COLLECTION_TYPE_OBJECT,
        3602  COLLECTION_TYPE_ARRAY,
        3603  };
        3604  struct StackItem
        3605  {
        3606  COLLECTION_TYPE type;
        3607  uint32_t valueCount;
        3608  bool singleLineMode;
        3609  };
        3610 
        3611  VmaStringBuilder& m_SB;
        3612  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
        3613  bool m_InsideString;
        3614 
        3615  void BeginValue(bool isString);
        3616  void WriteIndent(bool oneLess = false);
        3617 };
        3618 
        3619 const char* const VmaJsonWriter::INDENT = " ";
        3620 
        3621 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
        3622  m_SB(sb),
        3623  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
        3624  m_InsideString(false)
        3625 {
        3626 }
        3627 
        3628 VmaJsonWriter::~VmaJsonWriter()
        3629 {
        3630  VMA_ASSERT(!m_InsideString);
        3631  VMA_ASSERT(m_Stack.empty());
        3632 }
        3633 
        3634 void VmaJsonWriter::BeginObject(bool singleLine)
        3635 {
        3636  VMA_ASSERT(!m_InsideString);
        3637 
        3638  BeginValue(false);
        3639  m_SB.Add('{');
        3640 
        3641  StackItem item;
        3642  item.type = COLLECTION_TYPE_OBJECT;
        3643  item.valueCount = 0;
        3644  item.singleLineMode = singleLine;
        3645  m_Stack.push_back(item);
        3646 }
        3647 
        3648 void VmaJsonWriter::EndObject()
        3649 {
        3650  VMA_ASSERT(!m_InsideString);
        3651 
        3652  WriteIndent(true);
        3653  m_SB.Add('}');
        3654 
        3655  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
        3656  m_Stack.pop_back();
        3657 }
        3658 
        3659 void VmaJsonWriter::BeginArray(bool singleLine)
        3660 {
        3661  VMA_ASSERT(!m_InsideString);
        3662 
        3663  BeginValue(false);
        3664  m_SB.Add('[');
        3665 
        3666  StackItem item;
        3667  item.type = COLLECTION_TYPE_ARRAY;
        3668  item.valueCount = 0;
        3669  item.singleLineMode = singleLine;
        3670  m_Stack.push_back(item);
        3671 }
        3672 
        3673 void VmaJsonWriter::EndArray()
        3674 {
        3675  VMA_ASSERT(!m_InsideString);
        3676 
        3677  WriteIndent(true);
        3678  m_SB.Add(']');
        3679 
        3680  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
        3681  m_Stack.pop_back();
        3682 }
        3683 
        3684 void VmaJsonWriter::WriteString(const char* pStr)
        3685 {
        3686  BeginString(pStr);
        3687  EndString();
        3688 }
        3689 
        3690 void VmaJsonWriter::BeginString(const char* pStr)
        3691 {
        3692  VMA_ASSERT(!m_InsideString);
        3693 
        3694  BeginValue(true);
        3695  m_SB.Add('"');
        3696  m_InsideString = true;
        3697  if(pStr != VMA_NULL && pStr[0] != '\0')
        3698  {
        3699  ContinueString(pStr);
        3700  }
        3701 }
        3702 
        3703 void VmaJsonWriter::ContinueString(const char* pStr)
        3704 {
        3705  VMA_ASSERT(m_InsideString);
        3706 
        3707  const size_t strLen = strlen(pStr);
        3708  for(size_t i = 0; i < strLen; ++i)
        3709  {
        3710  char ch = pStr[i];
        3711  if(ch == '\'')
        3712  {
        3713  m_SB.Add("\\\\");
        3714  }
        3715  else if(ch == '"')
        3716  {
        3717  m_SB.Add("\\\"");
        3718  }
        3719  else if(ch >= 32)
        3720  {
        3721  m_SB.Add(ch);
        3722  }
        3723  else switch(ch)
        3724  {
        3725  case '\n':
        3726  m_SB.Add("\\n");
        3727  break;
        3728  case '\r':
        3729  m_SB.Add("\\r");
        3730  break;
        3731  case '\t':
        3732  m_SB.Add("\\t");
        3733  break;
        3734  default:
        3735  VMA_ASSERT(0 && "Character not currently supported.");
        3736  break;
        3737  }
        3738  }
        3739 }
        3740 
        3741 void VmaJsonWriter::ContinueString(uint32_t n)
        3742 {
        3743  VMA_ASSERT(m_InsideString);
        3744  m_SB.AddNumber(n);
        3745 }
        3746 
        3747 void VmaJsonWriter::ContinueString(uint64_t n)
        3748 {
        3749  VMA_ASSERT(m_InsideString);
        3750  m_SB.AddNumber(n);
        3751 }
        3752 
        3753 void VmaJsonWriter::EndString(const char* pStr)
        3754 {
        3755  VMA_ASSERT(m_InsideString);
        3756  if(pStr != VMA_NULL && pStr[0] != '\0')
        3757  {
        3758  ContinueString(pStr);
        3759  }
        3760  m_SB.Add('"');
        3761  m_InsideString = false;
        3762 }
        3763 
        3764 void VmaJsonWriter::WriteNumber(uint32_t n)
        3765 {
        3766  VMA_ASSERT(!m_InsideString);
        3767  BeginValue(false);
        3768  m_SB.AddNumber(n);
        3769 }
        3770 
        3771 void VmaJsonWriter::WriteNumber(uint64_t n)
        3772 {
        3773  VMA_ASSERT(!m_InsideString);
        3774  BeginValue(false);
        3775  m_SB.AddNumber(n);
        3776 }
        3777 
        3778 void VmaJsonWriter::WriteBool(bool b)
        3779 {
        3780  VMA_ASSERT(!m_InsideString);
        3781  BeginValue(false);
        3782  m_SB.Add(b ? "true" : "false");
        3783 }
        3784 
        3785 void VmaJsonWriter::WriteNull()
        3786 {
        3787  VMA_ASSERT(!m_InsideString);
        3788  BeginValue(false);
        3789  m_SB.Add("null");
        3790 }
        3791 
        3792 void VmaJsonWriter::BeginValue(bool isString)
        3793 {
        3794  if(!m_Stack.empty())
        3795  {
        3796  StackItem& currItem = m_Stack.back();
        3797  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        3798  currItem.valueCount % 2 == 0)
        3799  {
        3800  VMA_ASSERT(isString);
        3801  }
        3802 
        3803  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        3804  currItem.valueCount % 2 != 0)
        3805  {
        3806  m_SB.Add(": ");
        3807  }
        3808  else if(currItem.valueCount > 0)
        3809  {
        3810  m_SB.Add(", ");
        3811  WriteIndent();
        3812  }
        3813  else
        3814  {
        3815  WriteIndent();
        3816  }
        3817  ++currItem.valueCount;
        3818  }
        3819 }
        3820 
        3821 void VmaJsonWriter::WriteIndent(bool oneLess)
        3822 {
        3823  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
        3824  {
        3825  m_SB.AddNewLine();
        3826 
        3827  size_t count = m_Stack.size();
        3828  if(count > 0 && oneLess)
        3829  {
        3830  --count;
        3831  }
        3832  for(size_t i = 0; i < count; ++i)
        3833  {
        3834  m_SB.Add(INDENT);
        3835  }
        3836  }
        3837 }
        3838 
        3839 #endif // #if VMA_STATS_STRING_ENABLED
        3840 
        3842 
        3843 VkDeviceSize VmaAllocation_T::GetOffset() const
        3844 {
        3845  switch(m_Type)
        3846  {
        3847  case ALLOCATION_TYPE_BLOCK:
        3848  return m_BlockAllocation.m_Offset;
        3849  case ALLOCATION_TYPE_OWN:
        3850  return 0;
        3851  default:
        3852  VMA_ASSERT(0);
        3853  return 0;
        3854  }
        3855 }
        3856 
        3857 VkDeviceMemory VmaAllocation_T::GetMemory() const
        3858 {
        3859  switch(m_Type)
        3860  {
        3861  case ALLOCATION_TYPE_BLOCK:
        3862  return m_BlockAllocation.m_Block->m_hMemory;
        3863  case ALLOCATION_TYPE_OWN:
        3864  return m_OwnAllocation.m_hMemory;
        3865  default:
        3866  VMA_ASSERT(0);
        3867  return VK_NULL_HANDLE;
        3868  }
        3869 }
        3870 
        3871 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
        3872 {
        3873  switch(m_Type)
        3874  {
        3875  case ALLOCATION_TYPE_BLOCK:
        3876  return m_BlockAllocation.m_Block->m_MemoryTypeIndex;
        3877  case ALLOCATION_TYPE_OWN:
        3878  return m_OwnAllocation.m_MemoryTypeIndex;
        3879  default:
        3880  VMA_ASSERT(0);
        3881  return UINT32_MAX;
        3882  }
        3883 }
        3884 
        3885 VMA_BLOCK_VECTOR_TYPE VmaAllocation_T::GetBlockVectorType() const
        3886 {
        3887  switch(m_Type)
        3888  {
        3889  case ALLOCATION_TYPE_BLOCK:
        3890  return m_BlockAllocation.m_Block->m_BlockVectorType;
        3891  case ALLOCATION_TYPE_OWN:
        3892  return (m_OwnAllocation.m_PersistentMap ? VMA_BLOCK_VECTOR_TYPE_MAPPED : VMA_BLOCK_VECTOR_TYPE_UNMAPPED);
        3893  default:
        3894  VMA_ASSERT(0);
        3895  return VMA_BLOCK_VECTOR_TYPE_COUNT;
        3896  }
        3897 }
        3898 
        3899 void* VmaAllocation_T::GetMappedData() const
        3900 {
        3901  switch(m_Type)
        3902  {
        3903  case ALLOCATION_TYPE_BLOCK:
        3904  if(m_BlockAllocation.m_Block->m_pMappedData != VMA_NULL)
        3905  {
        3906  return (char*)m_BlockAllocation.m_Block->m_pMappedData + m_BlockAllocation.m_Offset;
        3907  }
        3908  else
        3909  {
        3910  return VMA_NULL;
        3911  }
        3912  break;
        3913  case ALLOCATION_TYPE_OWN:
        3914  return m_OwnAllocation.m_pMappedData;
        3915  default:
        3916  VMA_ASSERT(0);
        3917  return VMA_NULL;
        3918  }
        3919 }
        3920 
        3921 bool VmaAllocation_T::CanBecomeLost() const
        3922 {
        3923  switch(m_Type)
        3924  {
        3925  case ALLOCATION_TYPE_BLOCK:
        3926  return m_BlockAllocation.m_CanBecomeLost;
        3927  case ALLOCATION_TYPE_OWN:
        3928  return false;
        3929  default:
        3930  VMA_ASSERT(0);
        3931  return false;
        3932  }
        3933 }
        3934 
        3935 VmaPool VmaAllocation_T::GetPool() const
        3936 {
        3937  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        3938  return m_BlockAllocation.m_hPool;
        3939 }
        3940 
        3941 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        3942 {
        3943  VMA_ASSERT(CanBecomeLost());
        3944 
        3945  /*
        3946  Warning: This is a carefully designed algorithm.
        3947  Do not modify unless you really know what you're doing :)
        3948  */
        3949  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
        3950  for(;;)
        3951  {
        3952  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        3953  {
        3954  VMA_ASSERT(0);
        3955  return false;
        3956  }
        3957  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
        3958  {
        3959  return false;
        3960  }
        3961  else // Last use time earlier than current time.
        3962  {
        3963  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
        3964  {
        3965  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
        3966  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
        3967  return true;
        3968  }
        3969  }
        3970  }
        3971 }
        3972 
        3973 #if VMA_STATS_STRING_ENABLED
        3974 
        3975 // Correspond to values of enum VmaSuballocationType.
        3976 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
        3977  "FREE",
        3978  "UNKNOWN",
        3979  "BUFFER",
        3980  "IMAGE_UNKNOWN",
        3981  "IMAGE_LINEAR",
        3982  "IMAGE_OPTIMAL",
        3983 };
        3984 
        3985 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
        3986 {
        3987  json.BeginObject();
        3988 
        3989  json.WriteString("Blocks");
        3990  json.WriteNumber(stat.BlockCount);
        3991 
        3992  json.WriteString("Allocations");
        3993  json.WriteNumber(stat.AllocationCount);
        3994 
        3995  json.WriteString("UnusedRanges");
        3996  json.WriteNumber(stat.UnusedRangeCount);
        3997 
        3998  json.WriteString("UsedBytes");
        3999  json.WriteNumber(stat.UsedBytes);
        4000 
        4001  json.WriteString("UnusedBytes");
        4002  json.WriteNumber(stat.UnusedBytes);
        4003 
        4004  json.WriteString("AllocationSize");
        4005  json.BeginObject(true);
        4006  json.WriteString("Min");
        4007  json.WriteNumber(stat.AllocationSizeMin);
        4008  json.WriteString("Avg");
        4009  json.WriteNumber(stat.AllocationSizeAvg);
        4010  json.WriteString("Max");
        4011  json.WriteNumber(stat.AllocationSizeMax);
        4012  json.EndObject();
        4013 
        4014  json.WriteString("UnusedRangeSize");
        4015  json.BeginObject(true);
        4016  json.WriteString("Min");
        4017  json.WriteNumber(stat.UnusedRangeSizeMin);
        4018  json.WriteString("Avg");
        4019  json.WriteNumber(stat.UnusedRangeSizeAvg);
        4020  json.WriteString("Max");
        4021  json.WriteNumber(stat.UnusedRangeSizeMax);
        4022  json.EndObject();
        4023 
        4024  json.EndObject();
        4025 }
        4026 
        4027 #endif // #if VMA_STATS_STRING_ENABLED
        4028 
        4029 struct VmaSuballocationItemSizeLess
        4030 {
        4031  bool operator()(
        4032  const VmaSuballocationList::iterator lhs,
        4033  const VmaSuballocationList::iterator rhs) const
        4034  {
        4035  return lhs->size < rhs->size;
        4036  }
        4037  bool operator()(
        4038  const VmaSuballocationList::iterator lhs,
        4039  VkDeviceSize rhsSize) const
        4040  {
        4041  return lhs->size < rhsSize;
        4042  }
        4043 };
        4044 
        4045 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
        4046  m_MemoryTypeIndex(UINT32_MAX),
        4047  m_BlockVectorType(VMA_BLOCK_VECTOR_TYPE_COUNT),
        4048  m_hMemory(VK_NULL_HANDLE),
        4049  m_Size(0),
        4050  m_PersistentMap(false),
        4051  m_pMappedData(VMA_NULL),
        4052  m_FreeCount(0),
        4053  m_SumFreeSize(0),
        4054  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        4055  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
        4056 {
        4057 }
        4058 
        4059 void VmaDeviceMemoryBlock::Init(
        4060  uint32_t newMemoryTypeIndex,
        4061  VMA_BLOCK_VECTOR_TYPE newBlockVectorType,
        4062  VkDeviceMemory newMemory,
        4063  VkDeviceSize newSize,
        4064  bool persistentMap,
        4065  void* pMappedData)
        4066 {
        4067  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        4068 
        4069  m_MemoryTypeIndex = newMemoryTypeIndex;
        4070  m_BlockVectorType = newBlockVectorType;
        4071  m_hMemory = newMemory;
        4072  m_Size = newSize;
        4073  m_PersistentMap = persistentMap;
        4074  m_pMappedData = pMappedData;
        4075  m_FreeCount = 1;
        4076  m_SumFreeSize = newSize;
        4077 
        4078  m_Suballocations.clear();
        4079  m_FreeSuballocationsBySize.clear();
        4080 
        4081  VmaSuballocation suballoc = {};
        4082  suballoc.offset = 0;
        4083  suballoc.size = newSize;
        4084  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4085  suballoc.hAllocation = VK_NULL_HANDLE;
        4086 
        4087  m_Suballocations.push_back(suballoc);
        4088  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
        4089  --suballocItem;
        4090  m_FreeSuballocationsBySize.push_back(suballocItem);
        4091 }
        4092 
        4093 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
        4094 {
        4095  // This is the most important assert in the entire library.
        4096  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
        4097  VMA_ASSERT(IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
        4098 
        4099  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
        4100  if(m_pMappedData != VMA_NULL)
        4101  {
        4102  vkUnmapMemory(allocator->m_hDevice, m_hMemory);
        4103  m_pMappedData = VMA_NULL;
        4104  }
        4105 
        4106  // Callback.
        4107  if(allocator->m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        4108  {
        4109  (*allocator->m_DeviceMemoryCallbacks.pfnFree)(allocator, m_MemoryTypeIndex, m_hMemory, m_Size);
        4110  }
        4111 
        4112  vkFreeMemory(allocator->m_hDevice, m_hMemory, allocator->GetAllocationCallbacks());
        4113  m_hMemory = VK_NULL_HANDLE;
        4114 }
        4115 
        4116 bool VmaDeviceMemoryBlock::Validate() const
        4117 {
        4118  if((m_hMemory == VK_NULL_HANDLE) ||
        4119  (m_Size == 0) ||
        4120  m_Suballocations.empty())
        4121  {
        4122  return false;
        4123  }
        4124 
        4125  // Expected offset of new suballocation as calculates from previous ones.
        4126  VkDeviceSize calculatedOffset = 0;
        4127  // Expected number of free suballocations as calculated from traversing their list.
        4128  uint32_t calculatedFreeCount = 0;
        4129  // Expected sum size of free suballocations as calculated from traversing their list.
        4130  VkDeviceSize calculatedSumFreeSize = 0;
        4131  // Expected number of free suballocations that should be registered in
        4132  // m_FreeSuballocationsBySize calculated from traversing their list.
        4133  size_t freeSuballocationsToRegister = 0;
        4134  // True if previous visisted suballocation was free.
        4135  bool prevFree = false;
        4136 
        4137  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        4138  suballocItem != m_Suballocations.cend();
        4139  ++suballocItem)
        4140  {
        4141  const VmaSuballocation& subAlloc = *suballocItem;
        4142 
        4143  // Actual offset of this suballocation doesn't match expected one.
        4144  if(subAlloc.offset != calculatedOffset)
        4145  {
        4146  return false;
        4147  }
        4148 
        4149  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        4150  // Two adjacent free suballocations are invalid. They should be merged.
        4151  if(prevFree && currFree)
        4152  {
        4153  return false;
        4154  }
        4155  prevFree = currFree;
        4156 
        4157  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
        4158  {
        4159  return false;
        4160  }
        4161 
        4162  if(currFree)
        4163  {
        4164  calculatedSumFreeSize += subAlloc.size;
        4165  ++calculatedFreeCount;
        4166  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4167  {
        4168  ++freeSuballocationsToRegister;
        4169  }
        4170  }
        4171 
        4172  calculatedOffset += subAlloc.size;
        4173  }
        4174 
        4175  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
        4176  // match expected one.
        4177  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
        4178  {
        4179  return false;
        4180  }
        4181 
        4182  VkDeviceSize lastSize = 0;
        4183  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
        4184  {
        4185  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
        4186 
        4187  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        4188  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
        4189  {
        4190  return false;
        4191  }
        4192  // They must be sorted by size ascending.
        4193  if(suballocItem->size < lastSize)
        4194  {
        4195  return false;
        4196  }
        4197 
        4198  lastSize = suballocItem->size;
        4199  }
        4200 
        4201  // Check if totals match calculacted values.
        4202  return
        4203  (calculatedOffset == m_Size) &&
        4204  (calculatedSumFreeSize == m_SumFreeSize) &&
        4205  (calculatedFreeCount == m_FreeCount);
        4206 }
        4207 
        4208 /*
        4209 How many suitable free suballocations to analyze before choosing best one.
        4210 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
        4211  be chosen.
        4212 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
        4213  suballocations will be analized and best one will be chosen.
        4214 - Any other value is also acceptable.
        4215 */
        4216 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
        4217 
        4218 bool VmaDeviceMemoryBlock::CreateAllocationRequest(
        4219  uint32_t currentFrameIndex,
        4220  uint32_t frameInUseCount,
        4221  VkDeviceSize bufferImageGranularity,
        4222  VkDeviceSize allocSize,
        4223  VkDeviceSize allocAlignment,
        4224  VmaSuballocationType allocType,
        4225  bool canMakeOtherLost,
        4226  VmaAllocationRequest* pAllocationRequest)
        4227 {
        4228  VMA_ASSERT(allocSize > 0);
        4229  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        4230  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        4231  VMA_HEAVY_ASSERT(Validate());
        4232 
        4233  // There is not enough total free space in this block to fullfill the request: Early return.
        4234  if(canMakeOtherLost == false && m_SumFreeSize < allocSize)
        4235  {
        4236  return false;
        4237  }
        4238 
        4239  // New algorithm, efficiently searching freeSuballocationsBySize.
        4240  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
        4241  if(freeSuballocCount > 0)
        4242  {
        4243  if(VMA_BEST_FIT)
        4244  {
        4245  // Find first free suballocation with size not less than allocSize.
        4246  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        4247  m_FreeSuballocationsBySize.data(),
        4248  m_FreeSuballocationsBySize.data() + freeSuballocCount,
        4249  allocSize,
        4250  VmaSuballocationItemSizeLess());
        4251  size_t index = it - m_FreeSuballocationsBySize.data();
        4252  for(; index < freeSuballocCount; ++index)
        4253  {
        4254  if(CheckAllocation(
        4255  currentFrameIndex,
        4256  frameInUseCount,
        4257  bufferImageGranularity,
        4258  allocSize,
        4259  allocAlignment,
        4260  allocType,
        4261  m_FreeSuballocationsBySize[index],
        4262  false, // canMakeOtherLost
        4263  &pAllocationRequest->offset,
        4264  &pAllocationRequest->itemsToMakeLostCount,
        4265  &pAllocationRequest->sumFreeSize,
        4266  &pAllocationRequest->sumItemSize))
        4267  {
        4268  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        4269  return true;
        4270  }
        4271  }
        4272  }
        4273  else
        4274  {
        4275  // Search staring from biggest suballocations.
        4276  for(size_t index = freeSuballocCount; index--; )
        4277  {
        4278  if(CheckAllocation(
        4279  currentFrameIndex,
        4280  frameInUseCount,
        4281  bufferImageGranularity,
        4282  allocSize,
        4283  allocAlignment,
        4284  allocType,
        4285  m_FreeSuballocationsBySize[index],
        4286  false, // canMakeOtherLost
        4287  &pAllocationRequest->offset,
        4288  &pAllocationRequest->itemsToMakeLostCount,
        4289  &pAllocationRequest->sumFreeSize,
        4290  &pAllocationRequest->sumItemSize))
        4291  {
        4292  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        4293  return true;
        4294  }
        4295  }
        4296  }
        4297  }
        4298 
        4299  if(canMakeOtherLost)
        4300  {
        4301  // Brute-force algorithm. TODO: Come up with something better.
        4302 
        4303  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
        4304  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
        4305 
        4306  VmaAllocationRequest tmpAllocRequest = {};
        4307  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
        4308  suballocIt != m_Suballocations.end();
        4309  ++suballocIt)
        4310  {
        4311  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
        4312  suballocIt->hAllocation->CanBecomeLost())
        4313  {
        4314  if(CheckAllocation(
        4315  currentFrameIndex,
        4316  frameInUseCount,
        4317  bufferImageGranularity,
        4318  allocSize,
        4319  allocAlignment,
        4320  allocType,
        4321  suballocIt,
        4322  canMakeOtherLost,
        4323  &tmpAllocRequest.offset,
        4324  &tmpAllocRequest.itemsToMakeLostCount,
        4325  &tmpAllocRequest.sumFreeSize,
        4326  &tmpAllocRequest.sumItemSize))
        4327  {
        4328  tmpAllocRequest.item = suballocIt;
        4329 
        4330  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
        4331  {
        4332  *pAllocationRequest = tmpAllocRequest;
        4333  }
        4334  }
        4335  }
        4336  }
        4337 
        4338  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
        4339  {
        4340  return true;
        4341  }
        4342  }
        4343 
        4344  return false;
        4345 }
        4346 
        4347 bool VmaDeviceMemoryBlock::MakeRequestedAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount, VmaAllocationRequest* pAllocationRequest)
        4348 {
        4349  while(pAllocationRequest->itemsToMakeLostCount > 0)
        4350  {
        4351  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
        4352  {
        4353  ++pAllocationRequest->item;
        4354  }
        4355  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        4356  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
        4357  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
        4358  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        4359  {
        4360  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
        4361  --pAllocationRequest->itemsToMakeLostCount;
        4362  }
        4363  else
        4364  {
        4365  return false;
        4366  }
        4367  }
        4368 
        4369  VMA_HEAVY_ASSERT(Validate());
        4370  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        4371  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4372 
        4373  return true;
        4374 }
        4375 
        4376 uint32_t VmaDeviceMemoryBlock::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        4377 {
        4378  uint32_t lostAllocationCount = 0;
        4379  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        4380  it != m_Suballocations.end();
        4381  ++it)
        4382  {
        4383  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
        4384  it->hAllocation->CanBecomeLost() &&
        4385  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        4386  {
        4387  it = FreeSuballocation(it);
        4388  ++lostAllocationCount;
        4389  }
        4390  }
        4391  return lostAllocationCount;
        4392 }
        4393 
        4394 bool VmaDeviceMemoryBlock::CheckAllocation(
        4395  uint32_t currentFrameIndex,
        4396  uint32_t frameInUseCount,
        4397  VkDeviceSize bufferImageGranularity,
        4398  VkDeviceSize allocSize,
        4399  VkDeviceSize allocAlignment,
        4400  VmaSuballocationType allocType,
        4401  VmaSuballocationList::const_iterator suballocItem,
        4402  bool canMakeOtherLost,
        4403  VkDeviceSize* pOffset,
        4404  size_t* itemsToMakeLostCount,
        4405  VkDeviceSize* pSumFreeSize,
        4406  VkDeviceSize* pSumItemSize) const
        4407 {
        4408  VMA_ASSERT(allocSize > 0);
        4409  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        4410  VMA_ASSERT(suballocItem != m_Suballocations.cend());
        4411  VMA_ASSERT(pOffset != VMA_NULL);
        4412 
        4413  *itemsToMakeLostCount = 0;
        4414  *pSumFreeSize = 0;
        4415  *pSumItemSize = 0;
        4416 
        4417  if(canMakeOtherLost)
        4418  {
        4419  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        4420  {
        4421  *pSumFreeSize = suballocItem->size;
        4422  }
        4423  else
        4424  {
        4425  if(suballocItem->hAllocation->CanBecomeLost() &&
        4426  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        4427  {
        4428  ++*itemsToMakeLostCount;
        4429  *pSumItemSize = suballocItem->size;
        4430  }
        4431  else
        4432  {
        4433  return false;
        4434  }
        4435  }
        4436 
        4437  // Remaining size is too small for this request: Early return.
        4438  if(m_Size - suballocItem->offset < allocSize)
        4439  {
        4440  return false;
        4441  }
        4442 
        4443  // Start from offset equal to beginning of this suballocation.
        4444  *pOffset = suballocItem->offset;
        4445 
        4446  // Apply VMA_DEBUG_MARGIN at the beginning.
        4447  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
        4448  {
        4449  *pOffset += VMA_DEBUG_MARGIN;
        4450  }
        4451 
        4452  // Apply alignment.
        4453  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
        4454  *pOffset = VmaAlignUp(*pOffset, alignment);
        4455 
        4456  // Check previous suballocations for BufferImageGranularity conflicts.
        4457  // Make bigger alignment if necessary.
        4458  if(bufferImageGranularity > 1)
        4459  {
        4460  bool bufferImageGranularityConflict = false;
        4461  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        4462  while(prevSuballocItem != m_Suballocations.cbegin())
        4463  {
        4464  --prevSuballocItem;
        4465  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        4466  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        4467  {
        4468  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        4469  {
        4470  bufferImageGranularityConflict = true;
        4471  break;
        4472  }
        4473  }
        4474  else
        4475  // Already on previous page.
        4476  break;
        4477  }
        4478  if(bufferImageGranularityConflict)
        4479  {
        4480  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        4481  }
        4482  }
        4483 
        4484  // Now that we have final *pOffset, check if we are past suballocItem.
        4485  // If yes, return false - this function should be called for another suballocItem as starting point.
        4486  if(*pOffset >= suballocItem->offset + suballocItem->size)
        4487  {
        4488  return false;
        4489  }
        4490 
        4491  // Calculate padding at the beginning based on current offset.
        4492  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
        4493 
        4494  // Calculate required margin at the end if this is not last suballocation.
        4495  VmaSuballocationList::const_iterator next = suballocItem;
        4496  ++next;
        4497  const VkDeviceSize requiredEndMargin =
        4498  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
        4499 
        4500  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
        4501  // Another early return check.
        4502  if(suballocItem->offset + totalSize > m_Size)
        4503  {
        4504  return false;
        4505  }
        4506 
        4507  // Advance lastSuballocItem until desired size is reached.
        4508  // Update itemsToMakeLostCount.
        4509  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
        4510  if(totalSize > suballocItem->size)
        4511  {
        4512  VkDeviceSize remainingSize = totalSize - suballocItem->size;
        4513  while(remainingSize > 0)
        4514  {
        4515  ++lastSuballocItem;
        4516  if(lastSuballocItem == m_Suballocations.cend())
        4517  {
        4518  return false;
        4519  }
        4520  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        4521  {
        4522  *pSumFreeSize += lastSuballocItem->size;
        4523  }
        4524  else
        4525  {
        4526  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
        4527  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
        4528  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        4529  {
        4530  ++*itemsToMakeLostCount;
        4531  *pSumItemSize += lastSuballocItem->size;
        4532  }
        4533  else
        4534  {
        4535  return false;
        4536  }
        4537  }
        4538  remainingSize = (lastSuballocItem->size < remainingSize) ?
        4539  remainingSize - lastSuballocItem->size : 0;
        4540  }
        4541  }
        4542 
        4543  // Check next suballocations for BufferImageGranularity conflicts.
        4544  // If conflict exists, we must mark more allocations lost or fail.
        4545  if(bufferImageGranularity > 1)
        4546  {
        4547  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
        4548  ++nextSuballocItem;
        4549  while(nextSuballocItem != m_Suballocations.cend())
        4550  {
        4551  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        4552  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        4553  {
        4554  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        4555  {
        4556  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
        4557  if(nextSuballoc.hAllocation->CanBecomeLost() &&
        4558  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        4559  {
        4560  ++*itemsToMakeLostCount;
        4561  }
        4562  else
        4563  {
        4564  return false;
        4565  }
        4566  }
        4567  }
        4568  else
        4569  {
        4570  // Already on next page.
        4571  break;
        4572  }
        4573  ++nextSuballocItem;
        4574  }
        4575  }
        4576  }
        4577  else
        4578  {
        4579  const VmaSuballocation& suballoc = *suballocItem;
        4580  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        4581 
        4582  *pSumFreeSize = suballoc.size;
        4583 
        4584  // Size of this suballocation is too small for this request: Early return.
        4585  if(suballoc.size < allocSize)
        4586  {
        4587  return false;
        4588  }
        4589 
        4590  // Start from offset equal to beginning of this suballocation.
        4591  *pOffset = suballoc.offset;
        4592 
        4593  // Apply VMA_DEBUG_MARGIN at the beginning.
        4594  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
        4595  {
        4596  *pOffset += VMA_DEBUG_MARGIN;
        4597  }
        4598 
        4599  // Apply alignment.
        4600  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
        4601  *pOffset = VmaAlignUp(*pOffset, alignment);
        4602 
        4603  // Check previous suballocations for BufferImageGranularity conflicts.
        4604  // Make bigger alignment if necessary.
        4605  if(bufferImageGranularity > 1)
        4606  {
        4607  bool bufferImageGranularityConflict = false;
        4608  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        4609  while(prevSuballocItem != m_Suballocations.cbegin())
        4610  {
        4611  --prevSuballocItem;
        4612  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        4613  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        4614  {
        4615  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        4616  {
        4617  bufferImageGranularityConflict = true;
        4618  break;
        4619  }
        4620  }
        4621  else
        4622  // Already on previous page.
        4623  break;
        4624  }
        4625  if(bufferImageGranularityConflict)
        4626  {
        4627  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        4628  }
        4629  }
        4630 
        4631  // Calculate padding at the beginning based on current offset.
        4632  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
        4633 
        4634  // Calculate required margin at the end if this is not last suballocation.
        4635  VmaSuballocationList::const_iterator next = suballocItem;
        4636  ++next;
        4637  const VkDeviceSize requiredEndMargin =
        4638  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
        4639 
        4640  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
        4641  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
        4642  {
        4643  return false;
        4644  }
        4645 
        4646  // Check next suballocations for BufferImageGranularity conflicts.
        4647  // If conflict exists, allocation cannot be made here.
        4648  if(bufferImageGranularity > 1)
        4649  {
        4650  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        4651  ++nextSuballocItem;
        4652  while(nextSuballocItem != m_Suballocations.cend())
        4653  {
        4654  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        4655  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        4656  {
        4657  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        4658  {
        4659  return false;
        4660  }
        4661  }
        4662  else
        4663  {
        4664  // Already on next page.
        4665  break;
        4666  }
        4667  ++nextSuballocItem;
        4668  }
        4669  }
        4670  }
        4671 
        4672  // All tests passed: Success. pOffset is already filled.
        4673  return true;
        4674 }
        4675 
        4676 bool VmaDeviceMemoryBlock::IsEmpty() const
        4677 {
        4678  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
        4679 }
        4680 
        4681 void VmaDeviceMemoryBlock::Alloc(
        4682  const VmaAllocationRequest& request,
        4683  VmaSuballocationType type,
        4684  VkDeviceSize allocSize,
        4685  VmaAllocation hAllocation)
        4686 {
        4687  VMA_ASSERT(request.item != m_Suballocations.end());
        4688  VmaSuballocation& suballoc = *request.item;
        4689  // Given suballocation is a free block.
        4690  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        4691  // Given offset is inside this suballocation.
        4692  VMA_ASSERT(request.offset >= suballoc.offset);
        4693  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
        4694  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
        4695  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
        4696 
        4697  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
        4698  // it to become used.
        4699  UnregisterFreeSuballocation(request.item);
        4700 
        4701  suballoc.offset = request.offset;
        4702  suballoc.size = allocSize;
        4703  suballoc.type = type;
        4704  suballoc.hAllocation = hAllocation;
        4705 
        4706  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
        4707  if(paddingEnd)
        4708  {
        4709  VmaSuballocation paddingSuballoc = {};
        4710  paddingSuballoc.offset = request.offset + allocSize;
        4711  paddingSuballoc.size = paddingEnd;
        4712  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4713  VmaSuballocationList::iterator next = request.item;
        4714  ++next;
        4715  const VmaSuballocationList::iterator paddingEndItem =
        4716  m_Suballocations.insert(next, paddingSuballoc);
        4717  RegisterFreeSuballocation(paddingEndItem);
        4718  }
        4719 
        4720  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
        4721  if(paddingBegin)
        4722  {
        4723  VmaSuballocation paddingSuballoc = {};
        4724  paddingSuballoc.offset = request.offset - paddingBegin;
        4725  paddingSuballoc.size = paddingBegin;
        4726  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4727  const VmaSuballocationList::iterator paddingBeginItem =
        4728  m_Suballocations.insert(request.item, paddingSuballoc);
        4729  RegisterFreeSuballocation(paddingBeginItem);
        4730  }
        4731 
        4732  // Update totals.
        4733  m_FreeCount = m_FreeCount - 1;
        4734  if(paddingBegin > 0)
        4735  {
        4736  ++m_FreeCount;
        4737  }
        4738  if(paddingEnd > 0)
        4739  {
        4740  ++m_FreeCount;
        4741  }
        4742  m_SumFreeSize -= allocSize;
        4743 }
        4744 
        4745 VmaSuballocationList::iterator VmaDeviceMemoryBlock::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
        4746 {
        4747  // Change this suballocation to be marked as free.
        4748  VmaSuballocation& suballoc = *suballocItem;
        4749  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4750  suballoc.hAllocation = VK_NULL_HANDLE;
        4751 
        4752  // Update totals.
        4753  ++m_FreeCount;
        4754  m_SumFreeSize += suballoc.size;
        4755 
        4756  // Merge with previous and/or next suballocation if it's also free.
        4757  bool mergeWithNext = false;
        4758  bool mergeWithPrev = false;
        4759 
        4760  VmaSuballocationList::iterator nextItem = suballocItem;
        4761  ++nextItem;
        4762  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
        4763  {
        4764  mergeWithNext = true;
        4765  }
        4766 
        4767  VmaSuballocationList::iterator prevItem = suballocItem;
        4768  if(suballocItem != m_Suballocations.begin())
        4769  {
        4770  --prevItem;
        4771  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        4772  {
        4773  mergeWithPrev = true;
        4774  }
        4775  }
        4776 
        4777  if(mergeWithNext)
        4778  {
        4779  UnregisterFreeSuballocation(nextItem);
        4780  MergeFreeWithNext(suballocItem);
        4781  }
        4782 
        4783  if(mergeWithPrev)
        4784  {
        4785  UnregisterFreeSuballocation(prevItem);
        4786  MergeFreeWithNext(prevItem);
        4787  RegisterFreeSuballocation(prevItem);
        4788  return prevItem;
        4789  }
        4790  else
        4791  {
        4792  RegisterFreeSuballocation(suballocItem);
        4793  return suballocItem;
        4794  }
        4795 }
        4796 
        4797 void VmaDeviceMemoryBlock::Free(const VmaAllocation allocation)
        4798 {
        4799  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        4800  suballocItem != m_Suballocations.end();
        4801  ++suballocItem)
        4802  {
        4803  VmaSuballocation& suballoc = *suballocItem;
        4804  if(suballoc.hAllocation == allocation)
        4805  {
        4806  FreeSuballocation(suballocItem);
        4807  VMA_HEAVY_ASSERT(Validate());
        4808  return;
        4809  }
        4810  }
        4811  VMA_ASSERT(0 && "Not found!");
        4812 }
        4813 
        4814 #if VMA_STATS_STRING_ENABLED
        4815 
        4816 void VmaDeviceMemoryBlock::PrintDetailedMap(class VmaJsonWriter& json) const
        4817 {
        4818  json.BeginObject();
        4819 
        4820  json.WriteString("TotalBytes");
        4821  json.WriteNumber(m_Size);
        4822 
        4823  json.WriteString("UnusedBytes");
        4824  json.WriteNumber(m_SumFreeSize);
        4825 
        4826  json.WriteString("Allocations");
        4827  json.WriteNumber(m_Suballocations.size() - m_FreeCount);
        4828 
        4829  json.WriteString("UnusedRanges");
        4830  json.WriteNumber(m_FreeCount);
        4831 
        4832  json.WriteString("Suballocations");
        4833  json.BeginArray();
        4834  size_t i = 0;
        4835  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        4836  suballocItem != m_Suballocations.cend();
        4837  ++suballocItem, ++i)
        4838  {
        4839  json.BeginObject(true);
        4840 
        4841  json.WriteString("Type");
        4842  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[suballocItem->type]);
        4843 
        4844  json.WriteString("Size");
        4845  json.WriteNumber(suballocItem->size);
        4846 
        4847  json.WriteString("Offset");
        4848  json.WriteNumber(suballocItem->offset);
        4849 
        4850  json.EndObject();
        4851  }
        4852  json.EndArray();
        4853 
        4854  json.EndObject();
        4855 }
        4856 
        4857 #endif // #if VMA_STATS_STRING_ENABLED
        4858 
        4859 void VmaDeviceMemoryBlock::MergeFreeWithNext(VmaSuballocationList::iterator item)
        4860 {
        4861  VMA_ASSERT(item != m_Suballocations.end());
        4862  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4863 
        4864  VmaSuballocationList::iterator nextItem = item;
        4865  ++nextItem;
        4866  VMA_ASSERT(nextItem != m_Suballocations.end());
        4867  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        4868 
        4869  item->size += nextItem->size;
        4870  --m_FreeCount;
        4871  m_Suballocations.erase(nextItem);
        4872 }
        4873 
        4874 void VmaDeviceMemoryBlock::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
        4875 {
        4876  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4877  VMA_ASSERT(item->size > 0);
        4878 
        4879  // You may want to enable this validation at the beginning or at the end of
        4880  // this function, depending on what do you want to check.
        4881  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4882 
        4883  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4884  {
        4885  if(m_FreeSuballocationsBySize.empty())
        4886  {
        4887  m_FreeSuballocationsBySize.push_back(item);
        4888  }
        4889  else
        4890  {
        4891  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
        4892  }
        4893  }
        4894 
        4895  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4896 }
        4897 
        4898 
        4899 void VmaDeviceMemoryBlock::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
        4900 {
        4901  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4902  VMA_ASSERT(item->size > 0);
        4903 
        4904  // You may want to enable this validation at the beginning or at the end of
        4905  // this function, depending on what do you want to check.
        4906  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4907 
        4908  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4909  {
        4910  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        4911  m_FreeSuballocationsBySize.data(),
        4912  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        4913  item,
        4914  VmaSuballocationItemSizeLess());
        4915  for(size_t index = it - m_FreeSuballocationsBySize.data();
        4916  index < m_FreeSuballocationsBySize.size();
        4917  ++index)
        4918  {
        4919  if(m_FreeSuballocationsBySize[index] == item)
        4920  {
        4921  VmaVectorRemove(m_FreeSuballocationsBySize, index);
        4922  return;
        4923  }
        4924  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
        4925  }
        4926  VMA_ASSERT(0 && "Not found.");
        4927  }
        4928 
        4929  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4930 }
        4931 
        4932 bool VmaDeviceMemoryBlock::ValidateFreeSuballocationList() const
        4933 {
        4934  VkDeviceSize lastSize = 0;
        4935  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
        4936  {
        4937  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
        4938 
        4939  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        4940  {
        4941  VMA_ASSERT(0);
        4942  return false;
        4943  }
        4944  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4945  {
        4946  VMA_ASSERT(0);
        4947  return false;
        4948  }
        4949  if(it->size < lastSize)
        4950  {
        4951  VMA_ASSERT(0);
        4952  return false;
        4953  }
        4954 
        4955  lastSize = it->size;
        4956  }
        4957  return true;
        4958 }
        4959 
        4960 static void InitStatInfo(VmaStatInfo& outInfo)
        4961 {
        4962  memset(&outInfo, 0, sizeof(outInfo));
        4963  outInfo.AllocationSizeMin = UINT64_MAX;
        4964  outInfo.UnusedRangeSizeMin = UINT64_MAX;
        4965 }
        4966 
        4967 static void CalcAllocationStatInfo(VmaStatInfo& outInfo, const VmaDeviceMemoryBlock& alloc)
        4968 {
        4969  outInfo.BlockCount = 1;
        4970 
        4971  const uint32_t rangeCount = (uint32_t)alloc.m_Suballocations.size();
        4972  outInfo.AllocationCount = rangeCount - alloc.m_FreeCount;
        4973  outInfo.UnusedRangeCount = alloc.m_FreeCount;
        4974 
        4975  outInfo.UnusedBytes = alloc.m_SumFreeSize;
        4976  outInfo.UsedBytes = alloc.m_Size - outInfo.UnusedBytes;
        4977 
        4978  outInfo.AllocationSizeMin = UINT64_MAX;
        4979  outInfo.AllocationSizeMax = 0;
        4980  outInfo.UnusedRangeSizeMin = UINT64_MAX;
        4981  outInfo.UnusedRangeSizeMax = 0;
        4982 
        4983  for(VmaSuballocationList::const_iterator suballocItem = alloc.m_Suballocations.cbegin();
        4984  suballocItem != alloc.m_Suballocations.cend();
        4985  ++suballocItem)
        4986  {
        4987  const VmaSuballocation& suballoc = *suballocItem;
        4988  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        4989  {
        4990  outInfo.AllocationSizeMin = VMA_MIN(outInfo.AllocationSizeMin, suballoc.size);
        4991  outInfo.AllocationSizeMax = VMA_MAX(outInfo.AllocationSizeMax, suballoc.size);
        4992  }
        4993  else
        4994  {
        4995  outInfo.UnusedRangeSizeMin = VMA_MIN(outInfo.UnusedRangeSizeMin, suballoc.size);
        4996  outInfo.UnusedRangeSizeMax = VMA_MAX(outInfo.UnusedRangeSizeMax, suballoc.size);
        4997  }
        4998  }
        4999 }
        5000 
        5001 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
        5002 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
        5003 {
        5004  inoutInfo.BlockCount += srcInfo.BlockCount;
        5005  inoutInfo.AllocationCount += srcInfo.AllocationCount;
        5006  inoutInfo.UnusedRangeCount += srcInfo.UnusedRangeCount;
        5007  inoutInfo.UsedBytes += srcInfo.UsedBytes;
        5008  inoutInfo.UnusedBytes += srcInfo.UnusedBytes;
        5009  inoutInfo.AllocationSizeMin = VMA_MIN(inoutInfo.AllocationSizeMin, srcInfo.AllocationSizeMin);
        5010  inoutInfo.AllocationSizeMax = VMA_MAX(inoutInfo.AllocationSizeMax, srcInfo.AllocationSizeMax);
        5011  inoutInfo.UnusedRangeSizeMin = VMA_MIN(inoutInfo.UnusedRangeSizeMin, srcInfo.UnusedRangeSizeMin);
        5012  inoutInfo.UnusedRangeSizeMax = VMA_MAX(inoutInfo.UnusedRangeSizeMax, srcInfo.UnusedRangeSizeMax);
        5013 }
        5014 
        5015 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
        5016 {
        5017  inoutInfo.AllocationSizeAvg = (inoutInfo.AllocationCount > 0) ?
        5018  VmaRoundDiv<VkDeviceSize>(inoutInfo.UsedBytes, inoutInfo.AllocationCount) : 0;
        5019  inoutInfo.UnusedRangeSizeAvg = (inoutInfo.UnusedRangeCount > 0) ?
        5020  VmaRoundDiv<VkDeviceSize>(inoutInfo.UnusedBytes, inoutInfo.UnusedRangeCount) : 0;
        5021 }
        5022 
        5023 VmaPool_T::VmaPool_T(
        5024  VmaAllocator hAllocator,
        5025  const VmaPoolCreateInfo& createInfo) :
        5026  m_BlockVector(
        5027  hAllocator,
        5028  createInfo.memoryTypeIndex,
        5029  (createInfo.flags & VMA_POOL_CREATE_PERSISTENT_MAP_BIT) != 0 ?
        5030  VMA_BLOCK_VECTOR_TYPE_MAPPED : VMA_BLOCK_VECTOR_TYPE_UNMAPPED,
        5031  createInfo.blockSize,
        5032  createInfo.minBlockCount,
        5033  createInfo.maxBlockCount,
        5034  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        5035  createInfo.frameInUseCount,
        5036  true) // isCustomPool
        5037 {
        5038 }
        5039 
        5040 VmaPool_T::~VmaPool_T()
        5041 {
        5042 }
        5043 
        5044 #if VMA_STATS_STRING_ENABLED
        5045 
        5046 /*
        5047 void VmaPool_T::PrintDetailedMap(class VmaStringBuilder& sb)
        5048 {
        5049  sb.Add("\n{\n\"This\": \"");
        5050  sb.AddPointer(this);
        5051  sb.Add("\",\n\"Flags\": ");
        5052  sb.AddNumber(m_Flags);
        5053  sb.Add(",\n\"FrameInUseCount\": ");
        5054  sb.AddNumber(m_FrameInUseCount);
        5055  sb.Add(",\n\"DeviceMemoryBlock\": ");
        5056  m_pDeviceMemoryBlock->PrintDetailedMap(sb);
        5057  sb.Add("\n}");
        5058 }
        5059 */
        5060 
        5061 #endif // #if VMA_STATS_STRING_ENABLED
        5062 
        5063 VmaBlockVector::VmaBlockVector(
        5064  VmaAllocator hAllocator,
        5065  uint32_t memoryTypeIndex,
        5066  VMA_BLOCK_VECTOR_TYPE blockVectorType,
        5067  VkDeviceSize preferredBlockSize,
        5068  size_t minBlockCount,
        5069  size_t maxBlockCount,
        5070  VkDeviceSize bufferImageGranularity,
        5071  uint32_t frameInUseCount,
        5072  bool isCustomPool) :
        5073  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
        5074  m_hAllocator(hAllocator),
        5075  m_MemoryTypeIndex(memoryTypeIndex),
        5076  m_BlockVectorType(blockVectorType),
        5077  m_PreferredBlockSize(preferredBlockSize),
        5078  m_MinBlockCount(minBlockCount),
        5079  m_MaxBlockCount(maxBlockCount),
        5080  m_BufferImageGranularity(bufferImageGranularity),
        5081  m_FrameInUseCount(frameInUseCount),
        5082  m_IsCustomPool(isCustomPool),
        5083  m_HasEmptyBlock(false),
        5084  m_pDefragmentator(VMA_NULL)
        5085 {
        5086 }
        5087 
        5088 VmaBlockVector::~VmaBlockVector()
        5089 {
        5090  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
        5091 
        5092  for(size_t i = m_Blocks.size(); i--; )
        5093  {
        5094  m_Blocks[i]->Destroy(m_hAllocator);
        5095  vma_delete(m_hAllocator, m_Blocks[i]);
        5096  }
        5097 }
        5098 
        5099 VkResult VmaBlockVector::CreateMinBlocks()
        5100 {
        5101  for(size_t i = 0; i < m_MinBlockCount; ++i)
        5102  {
        5103  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        5104  if(res != VK_SUCCESS)
        5105  {
        5106  return res;
        5107  }
        5108  }
        5109  return VK_SUCCESS;
        5110 }
        5111 
        5112 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
        5113 {
        5114  pStats->size = 0;
        5115  pStats->unusedSize = 0;
        5116  pStats->allocationCount = 0;
        5117  pStats->unusedRangeCount = 0;
        5118 
        5119  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5120 
        5121  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5122  {
        5123  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        5124  VMA_ASSERT(pBlock);
        5125  VMA_HEAVY_ASSERT(pBlock->Validate());
        5126 
        5127  const uint32_t rangeCount = (uint32_t)pBlock->m_Suballocations.size();
        5128 
        5129  pStats->size += pBlock->m_Size;
        5130  pStats->unusedSize += pBlock->m_SumFreeSize;
        5131  pStats->allocationCount += rangeCount - pBlock->m_FreeCount;
        5132  pStats->unusedRangeCount += pBlock->m_FreeCount;
        5133  }
        5134 }
        5135 
        5136 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
        5137 
        5138 VkResult VmaBlockVector::Allocate(
        5139  VmaPool hCurrentPool,
        5140  uint32_t currentFrameIndex,
        5141  const VkMemoryRequirements& vkMemReq,
        5142  const VmaAllocationCreateInfo& createInfo,
        5143  VmaSuballocationType suballocType,
        5144  VmaAllocation* pAllocation)
        5145 {
        5146  // Validate flags.
        5147  if(((createInfo.flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0) !=
        5148  (m_BlockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED))
        5149  {
        5150  VMA_ASSERT(0 && "Usage of VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT must match VMA_POOL_CREATE_PERSISTENT_MAP_BIT.");
        5151  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        5152  }
        5153 
        5154  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5155 
        5156  // 1. Search existing allocations. Try to allocate without making other allocations lost.
        5157  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        5158  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        5159  {
        5160  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        5161  VMA_ASSERT(pCurrBlock);
        5162  VmaAllocationRequest currRequest = {};
        5163  if(pCurrBlock->CreateAllocationRequest(
        5164  currentFrameIndex,
        5165  m_FrameInUseCount,
        5166  m_BufferImageGranularity,
        5167  vkMemReq.size,
        5168  vkMemReq.alignment,
        5169  suballocType,
        5170  false, // canMakeOtherLost
        5171  &currRequest))
        5172  {
        5173  // Allocate from pCurrBlock.
        5174  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
        5175 
        5176  // We no longer have an empty Allocation.
        5177  if(pCurrBlock->IsEmpty())
        5178  {
        5179  m_HasEmptyBlock = false;
        5180  }
        5181 
        5182  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex);
        5183  pCurrBlock->Alloc(currRequest, suballocType, vkMemReq.size, *pAllocation);
        5184  (*pAllocation)->InitBlockAllocation(
        5185  hCurrentPool,
        5186  pCurrBlock,
        5187  currRequest.offset,
        5188  vkMemReq.alignment,
        5189  vkMemReq.size,
        5190  suballocType,
        5191  createInfo.pUserData,
        5192  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        5193  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
        5194  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        5195  return VK_SUCCESS;
        5196  }
        5197  }
        5198 
        5199  const bool canCreateNewBlock =
        5200  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        5201  (m_Blocks.size() < m_MaxBlockCount);
        5202 
        5203  // 2. Try to create new block.
        5204  if(canCreateNewBlock)
        5205  {
        5206  // 2.1. Start with full preferredBlockSize.
        5207  VkDeviceSize blockSize = m_PreferredBlockSize;
        5208  size_t newBlockIndex = 0;
        5209  VkResult res = CreateBlock(blockSize, &newBlockIndex);
        5210  // Allocating blocks of other sizes is allowed only in default pools.
        5211  // In custom pools block size is fixed.
        5212  if(res < 0 && m_IsCustomPool == false)
        5213  {
        5214  // 2.2. Try half the size.
        5215  blockSize /= 2;
        5216  if(blockSize >= vkMemReq.size)
        5217  {
        5218  res = CreateBlock(blockSize, &newBlockIndex);
        5219  if(res < 0)
        5220  {
        5221  // 2.3. Try quarter the size.
        5222  blockSize /= 2;
        5223  if(blockSize >= vkMemReq.size)
        5224  {
        5225  res = CreateBlock(blockSize, &newBlockIndex);
        5226  }
        5227  }
        5228  }
        5229  }
        5230  if(res == VK_SUCCESS)
        5231  {
        5232  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
        5233  VMA_ASSERT(pBlock->m_Size >= vkMemReq.size);
        5234 
        5235  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
        5236  VmaAllocationRequest allocRequest = {};
        5237  allocRequest.item = pBlock->m_Suballocations.begin();
        5238  allocRequest.offset = 0;
        5239  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex);
        5240  pBlock->Alloc(allocRequest, suballocType, vkMemReq.size, *pAllocation);
        5241  (*pAllocation)->InitBlockAllocation(
        5242  hCurrentPool,
        5243  pBlock,
        5244  allocRequest.offset,
        5245  vkMemReq.alignment,
        5246  vkMemReq.size,
        5247  suballocType,
        5248  createInfo.pUserData,
        5249  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        5250  VMA_HEAVY_ASSERT(pBlock->Validate());
        5251  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
        5252 
        5253  return VK_SUCCESS;
        5254  }
        5255  }
        5256 
        5257  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
        5258 
        5259  // 3. Try to allocate from existing blocks with making other allocations lost.
        5260  if(canMakeOtherLost)
        5261  {
        5262  uint32_t tryIndex = 0;
        5263  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
        5264  {
        5265  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
        5266  VmaAllocationRequest bestRequest = {};
        5267  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
        5268 
        5269  // 1. Search existing allocations.
        5270  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        5271  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        5272  {
        5273  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        5274  VMA_ASSERT(pCurrBlock);
        5275  VmaAllocationRequest currRequest = {};
        5276  if(pCurrBlock->CreateAllocationRequest(
        5277  currentFrameIndex,
        5278  m_FrameInUseCount,
        5279  m_BufferImageGranularity,
        5280  vkMemReq.size,
        5281  vkMemReq.alignment,
        5282  suballocType,
        5283  canMakeOtherLost,
        5284  &currRequest))
        5285  {
        5286  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        5287  if(pBestRequestBlock == VMA_NULL ||
        5288  currRequestCost < bestRequestCost)
        5289  {
        5290  pBestRequestBlock = pCurrBlock;
        5291  bestRequest = currRequest;
        5292  bestRequestCost = currRequestCost;
        5293 
        5294  if(bestRequestCost == 0)
        5295  {
        5296  break;
        5297  }
        5298  }
        5299  }
        5300  }
        5301 
        5302  if(pBestRequestBlock != VMA_NULL)
        5303  {
        5304  if(pBestRequestBlock->MakeRequestedAllocationsLost(
        5305  currentFrameIndex,
        5306  m_FrameInUseCount,
        5307  &bestRequest))
        5308  {
        5309  // We no longer have an empty Allocation.
        5310  if(pBestRequestBlock->IsEmpty())
        5311  {
        5312  m_HasEmptyBlock = false;
        5313  }
        5314  // Allocate from this pBlock.
        5315  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex);
        5316  pBestRequestBlock->Alloc(bestRequest, suballocType, vkMemReq.size, *pAllocation);
        5317  (*pAllocation)->InitBlockAllocation(
        5318  hCurrentPool,
        5319  pBestRequestBlock,
        5320  bestRequest.offset,
        5321  vkMemReq.alignment,
        5322  vkMemReq.size,
        5323  suballocType,
        5324  createInfo.pUserData,
        5325  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        5326  VMA_HEAVY_ASSERT(pBlock->Validate());
        5327  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        5328  return VK_SUCCESS;
        5329  }
        5330  // else: Some allocations must have been touched while we are here. Next try.
        5331  }
        5332  else
        5333  {
        5334  // Could not find place in any of the blocks - break outer loop.
        5335  break;
        5336  }
        5337  }
        5338  /* Maximum number of tries exceeded - a very unlike event when many other
        5339  threads are simultaneously touching allocations making it impossible to make
        5340  lost at the same time as we try to allocate. */
        5341  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
        5342  {
        5343  return VK_ERROR_TOO_MANY_OBJECTS;
        5344  }
        5345  }
        5346 
        5347  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        5348 }
        5349 
        5350 void VmaBlockVector::Free(
        5351  VmaAllocation hAllocation)
        5352 {
        5353  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
        5354 
        5355  // Scope for lock.
        5356  {
        5357  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5358 
        5359  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        5360 
        5361  pBlock->Free(hAllocation);
        5362  VMA_HEAVY_ASSERT(pBlock->Validate());
        5363 
        5364  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
        5365 
        5366  // pBlock became empty after this deallocation.
        5367  if(pBlock->IsEmpty())
        5368  {
        5369  // Already has empty Allocation. We don't want to have two, so delete this one.
        5370  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
        5371  {
        5372  pBlockToDelete = pBlock;
        5373  Remove(pBlock);
        5374  }
        5375  // We now have first empty Allocation.
        5376  else
        5377  {
        5378  m_HasEmptyBlock = true;
        5379  }
        5380  }
        5381  // Must be called after srcBlockIndex is used, because later it may become invalid!
        5382  IncrementallySortBlocks();
        5383  }
        5384 
        5385  // Destruction of a free Allocation. Deferred until this point, outside of mutex
        5386  // lock, for performance reason.
        5387  if(pBlockToDelete != VMA_NULL)
        5388  {
        5389  VMA_DEBUG_LOG(" Deleted empty allocation");
        5390  pBlockToDelete->Destroy(m_hAllocator);
        5391  vma_delete(m_hAllocator, pBlockToDelete);
        5392  }
        5393 }
        5394 
        5395 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
        5396 {
        5397  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5398  {
        5399  if(m_Blocks[blockIndex] == pBlock)
        5400  {
        5401  VmaVectorRemove(m_Blocks, blockIndex);
        5402  return;
        5403  }
        5404  }
        5405  VMA_ASSERT(0);
        5406 }
        5407 
        5408 void VmaBlockVector::IncrementallySortBlocks()
        5409 {
        5410  // Bubble sort only until first swap.
        5411  for(size_t i = 1; i < m_Blocks.size(); ++i)
        5412  {
        5413  if(m_Blocks[i - 1]->m_SumFreeSize > m_Blocks[i]->m_SumFreeSize)
        5414  {
        5415  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
        5416  return;
        5417  }
        5418  }
        5419 }
        5420 
        5421 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
        5422 {
        5423  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        5424  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
        5425  allocInfo.allocationSize = blockSize;
        5426  const VkDevice hDevice = m_hAllocator->m_hDevice;
        5427  VkDeviceMemory mem = VK_NULL_HANDLE;
        5428  VkResult res = vkAllocateMemory(hDevice, &allocInfo, m_hAllocator->GetAllocationCallbacks(), &mem);
        5429  if(res < 0)
        5430  {
        5431  return res;
        5432  }
        5433 
        5434  // New VkDeviceMemory successfully created.
        5435 
        5436  // Map memory if needed.
        5437  void* pMappedData = VMA_NULL;
        5438  const bool persistentMap = (m_BlockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED);
        5439  if(persistentMap && m_hAllocator->m_UnmapPersistentlyMappedMemoryCounter == 0)
        5440  {
        5441  res = vkMapMemory(hDevice, mem, 0, VK_WHOLE_SIZE, 0, &pMappedData);
        5442  if(res < 0)
        5443  {
        5444  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        5445  vkFreeMemory(hDevice, mem, m_hAllocator->GetAllocationCallbacks());
        5446  return res;
        5447  }
        5448  }
        5449 
        5450  // Callback.
        5451  if(m_hAllocator->m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        5452  {
        5453  (*m_hAllocator->m_DeviceMemoryCallbacks.pfnAllocate)(m_hAllocator, m_MemoryTypeIndex, mem, allocInfo.allocationSize);
        5454  }
        5455 
        5456  // Create new Allocation for it.
        5457  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
        5458  pBlock->Init(
        5459  m_MemoryTypeIndex,
        5460  (VMA_BLOCK_VECTOR_TYPE)m_BlockVectorType,
        5461  mem,
        5462  allocInfo.allocationSize,
        5463  persistentMap,
        5464  pMappedData);
        5465 
        5466  m_Blocks.push_back(pBlock);
        5467  if(pNewBlockIndex != VMA_NULL)
        5468  {
        5469  *pNewBlockIndex = m_Blocks.size() - 1;
        5470  }
        5471 
        5472  return VK_SUCCESS;
        5473 }
        5474 
        5475 #if VMA_STATS_STRING_ENABLED
        5476 
        5477 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
        5478 {
        5479  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5480  json.BeginArray();
        5481  for(size_t i = 0; i < m_Blocks.size(); ++i)
        5482  {
        5483  m_Blocks[i]->PrintDetailedMap(json);
        5484  }
        5485  json.EndArray();
        5486 }
        5487 
        5488 #endif // #if VMA_STATS_STRING_ENABLED
        5489 
        5490 void VmaBlockVector::UnmapPersistentlyMappedMemory()
        5491 {
        5492  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5493 
        5494  for(size_t i = m_Blocks.size(); i--; )
        5495  {
        5496  VmaDeviceMemoryBlock* pBlock = m_Blocks[i];
        5497  if(pBlock->m_pMappedData != VMA_NULL)
        5498  {
        5499  VMA_ASSERT(pBlock->m_PersistentMap != false);
        5500  vkUnmapMemory(m_hAllocator->m_hDevice, pBlock->m_hMemory);
        5501  pBlock->m_pMappedData = VMA_NULL;
        5502  }
        5503  }
        5504 }
        5505 
        5506 VkResult VmaBlockVector::MapPersistentlyMappedMemory()
        5507 {
        5508  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5509 
        5510  VkResult finalResult = VK_SUCCESS;
        5511  for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
        5512  {
        5513  VmaDeviceMemoryBlock* pBlock = m_Blocks[i];
        5514  if(pBlock->m_PersistentMap)
        5515  {
        5516  VMA_ASSERT(pBlock->m_pMappedData == nullptr);
        5517  VkResult localResult = vkMapMemory(m_hAllocator->m_hDevice, pBlock->m_hMemory, 0, VK_WHOLE_SIZE, 0, &pBlock->m_pMappedData);
        5518  if(localResult != VK_SUCCESS)
        5519  {
        5520  finalResult = localResult;
        5521  }
        5522  }
        5523  }
        5524  return finalResult;
        5525 }
        5526 
        5527 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
        5528  VkDevice hDevice,
        5529  const VkAllocationCallbacks* pAllocationCallbacks,
        5530  uint32_t currentFrameIndex)
        5531 {
        5532  if(m_pDefragmentator == VMA_NULL)
        5533  {
        5534  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
        5535  hDevice,
        5536  pAllocationCallbacks,
        5537  this,
        5538  currentFrameIndex);
        5539  }
        5540 
        5541  return m_pDefragmentator;
        5542 }
        5543 
        5544 VkResult VmaBlockVector::Defragment(
        5545  VmaDefragmentationStats* pDefragmentationStats,
        5546  VkDeviceSize& maxBytesToMove,
        5547  uint32_t& maxAllocationsToMove)
        5548 {
        5549  if(m_pDefragmentator == VMA_NULL)
        5550  {
        5551  return VK_SUCCESS;
        5552  }
        5553 
        5554  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5555 
        5556  // Defragment.
        5557  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
        5558 
        5559  // Accumulate statistics.
        5560  if(pDefragmentationStats != VMA_NULL)
        5561  {
        5562  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
        5563  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
        5564  pDefragmentationStats->bytesMoved += bytesMoved;
        5565  pDefragmentationStats->allocationsMoved += allocationsMoved;
        5566  VMA_ASSERT(bytesMoved <= maxBytesToMove);
        5567  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
        5568  maxBytesToMove -= bytesMoved;
        5569  maxAllocationsToMove -= allocationsMoved;
        5570  }
        5571 
        5572  // Free empty blocks.
        5573  m_HasEmptyBlock = false;
        5574  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        5575  {
        5576  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        5577  if(pBlock->IsEmpty())
        5578  {
        5579  if(m_Blocks.size() > m_MinBlockCount)
        5580  {
        5581  if(pDefragmentationStats != VMA_NULL)
        5582  {
        5583  ++pDefragmentationStats->deviceMemoryBlocksFreed;
        5584  pDefragmentationStats->bytesFreed += pBlock->m_Size;
        5585  }
        5586 
        5587  VmaVectorRemove(m_Blocks, blockIndex);
        5588  pBlock->Destroy(m_hAllocator);
        5589  vma_delete(m_hAllocator, pBlock);
        5590  }
        5591  else
        5592  {
        5593  m_HasEmptyBlock = true;
        5594  }
        5595  }
        5596  }
        5597 
        5598  return result;
        5599 }
        5600 
        5601 void VmaBlockVector::DestroyDefragmentator()
        5602 {
        5603  if(m_pDefragmentator != VMA_NULL)
        5604  {
        5605  vma_delete(m_hAllocator, m_pDefragmentator);
        5606  m_pDefragmentator = VMA_NULL;
        5607  }
        5608 }
        5609 
        5610 void VmaBlockVector::MakePoolAllocationsLost(
        5611  uint32_t currentFrameIndex,
        5612  size_t* pLostAllocationCount)
        5613 {
        5614  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5615 
        5616  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5617  {
        5618  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        5619  VMA_ASSERT(pBlock);
        5620  pBlock->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
        5621  }
        5622 }
        5623 
        5624 void VmaBlockVector::AddStats(VmaStats* pStats, uint32_t memTypeIndex, uint32_t memHeapIndex)
        5625 {
        5626  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5627 
        5628  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5629  {
        5630  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        5631  VMA_ASSERT(pBlock);
        5632  VMA_HEAVY_ASSERT(pBlock->Validate());
        5633  VmaStatInfo allocationStatInfo;
        5634  CalcAllocationStatInfo(allocationStatInfo, *pBlock);
        5635  VmaAddStatInfo(pStats->total, allocationStatInfo);
        5636  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        5637  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        5638  }
        5639 }
        5640 
        5642 // VmaDefragmentator members definition
        5643 
        5644 VmaDefragmentator::VmaDefragmentator(
        5645  VkDevice hDevice,
        5646  const VkAllocationCallbacks* pAllocationCallbacks,
        5647  VmaBlockVector* pBlockVector,
        5648  uint32_t currentFrameIndex) :
        5649  m_hDevice(hDevice),
        5650  m_pAllocationCallbacks(pAllocationCallbacks),
        5651  m_pBlockVector(pBlockVector),
        5652  m_CurrentFrameIndex(currentFrameIndex),
        5653  m_BytesMoved(0),
        5654  m_AllocationsMoved(0),
        5655  m_Allocations(VmaStlAllocator<AllocationInfo>(pAllocationCallbacks)),
        5656  m_Blocks(VmaStlAllocator<BlockInfo*>(pAllocationCallbacks))
        5657 {
        5658 }
        5659 
        5660 VmaDefragmentator::~VmaDefragmentator()
        5661 {
        5662  for(size_t i = m_Blocks.size(); i--; )
        5663  {
        5664  vma_delete(m_pAllocationCallbacks, m_Blocks[i]);
        5665  }
        5666 }
        5667 
        5668 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        5669 {
        5670  AllocationInfo allocInfo;
        5671  allocInfo.m_hAllocation = hAlloc;
        5672  allocInfo.m_pChanged = pChanged;
        5673  m_Allocations.push_back(allocInfo);
        5674 }
        5675 
        5676 VkResult VmaDefragmentator::DefragmentRound(
        5677  VkDeviceSize maxBytesToMove,
        5678  uint32_t maxAllocationsToMove)
        5679 {
        5680  if(m_Blocks.empty())
        5681  {
        5682  return VK_SUCCESS;
        5683  }
        5684 
        5685  size_t srcBlockIndex = m_Blocks.size() - 1;
        5686  size_t srcAllocIndex = SIZE_MAX;
        5687  for(;;)
        5688  {
        5689  // 1. Find next allocation to move.
        5690  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
        5691  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
        5692  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
        5693  {
        5694  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
        5695  {
        5696  // Finished: no more allocations to process.
        5697  if(srcBlockIndex == 0)
        5698  {
        5699  return VK_SUCCESS;
        5700  }
        5701  else
        5702  {
        5703  --srcBlockIndex;
        5704  srcAllocIndex = SIZE_MAX;
        5705  }
        5706  }
        5707  else
        5708  {
        5709  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
        5710  }
        5711  }
        5712 
        5713  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
        5714  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
        5715 
        5716  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
        5717  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
        5718  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
        5719  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
        5720 
        5721  // 2. Try to find new place for this allocation in preceding or current block.
        5722  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
        5723  {
        5724  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
        5725  VmaAllocationRequest dstAllocRequest;
        5726  if(pDstBlockInfo->m_pBlock->CreateAllocationRequest(
        5727  m_CurrentFrameIndex,
        5728  m_pBlockVector->GetFrameInUseCount(),
        5729  m_pBlockVector->GetBufferImageGranularity(),
        5730  size,
        5731  alignment,
        5732  suballocType,
        5733  false, // canMakeOtherLost
        5734  &dstAllocRequest) &&
        5735  MoveMakesSense(
        5736  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
        5737  {
        5738  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
        5739 
        5740  // Reached limit on number of allocations or bytes to move.
        5741  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
        5742  (m_BytesMoved + size > maxBytesToMove))
        5743  {
        5744  return VK_INCOMPLETE;
        5745  }
        5746 
        5747  void* pDstMappedData = VMA_NULL;
        5748  VkResult res = pDstBlockInfo->EnsureMapping(m_hDevice, &pDstMappedData);
        5749  if(res != VK_SUCCESS)
        5750  {
        5751  return res;
        5752  }
        5753 
        5754  void* pSrcMappedData = VMA_NULL;
        5755  res = pSrcBlockInfo->EnsureMapping(m_hDevice, &pSrcMappedData);
        5756  if(res != VK_SUCCESS)
        5757  {
        5758  return res;
        5759  }
        5760 
        5761  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
        5762  memcpy(
        5763  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
        5764  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
        5765  size);
        5766 
        5767  pDstBlockInfo->m_pBlock->Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);
        5768  pSrcBlockInfo->m_pBlock->Free(allocInfo.m_hAllocation);
        5769 
        5770  allocInfo.m_hAllocation->ChangeBlockAllocation(pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
        5771 
        5772  if(allocInfo.m_pChanged != VMA_NULL)
        5773  {
        5774  *allocInfo.m_pChanged = VK_TRUE;
        5775  }
        5776 
        5777  ++m_AllocationsMoved;
        5778  m_BytesMoved += size;
        5779 
        5780  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
        5781 
        5782  break;
        5783  }
        5784  }
        5785 
        5786  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
        5787 
        5788  if(srcAllocIndex > 0)
        5789  {
        5790  --srcAllocIndex;
        5791  }
        5792  else
        5793  {
        5794  if(srcBlockIndex > 0)
        5795  {
        5796  --srcBlockIndex;
        5797  srcAllocIndex = SIZE_MAX;
        5798  }
        5799  else
        5800  {
        5801  return VK_SUCCESS;
        5802  }
        5803  }
        5804  }
        5805 }
        5806 
        5807 VkResult VmaDefragmentator::Defragment(
        5808  VkDeviceSize maxBytesToMove,
        5809  uint32_t maxAllocationsToMove)
        5810 {
        5811  if(m_Allocations.empty())
        5812  {
        5813  return VK_SUCCESS;
        5814  }
        5815 
        5816  // Create block info for each block.
        5817  const size_t blockCount = m_pBlockVector->m_Blocks.size();
        5818  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        5819  {
        5820  BlockInfo* pBlockInfo = vma_new(m_pAllocationCallbacks, BlockInfo)(m_pAllocationCallbacks);
        5821  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
        5822  m_Blocks.push_back(pBlockInfo);
        5823  }
        5824 
        5825  // Sort them by m_pBlock pointer value.
        5826  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
        5827 
        5828  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
        5829  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
        5830  {
        5831  AllocationInfo& allocInfo = m_Allocations[blockIndex];
        5832  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
        5833  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        5834  {
        5835  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
        5836  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
        5837  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
        5838  {
        5839  (*it)->m_Allocations.push_back(allocInfo);
        5840  }
        5841  else
        5842  {
        5843  VMA_ASSERT(0);
        5844  }
        5845  }
        5846  }
        5847  m_Allocations.clear();
        5848 
        5849  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        5850  {
        5851  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
        5852  pBlockInfo->CalcHasNonMovableAllocations();
        5853  pBlockInfo->SortAllocationsBySizeDescecnding();
        5854  }
        5855 
        5856  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
        5857  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
        5858 
        5859  // Execute defragmentation rounds (the main part).
        5860  VkResult result = VK_SUCCESS;
        5861  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
        5862  {
        5863  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
        5864  }
        5865 
        5866  // Unmap blocks that were mapped for defragmentation.
        5867  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        5868  {
        5869  m_Blocks[blockIndex]->Unmap(m_hDevice);
        5870  }
        5871 
        5872  return result;
        5873 }
        5874 
        5875 bool VmaDefragmentator::MoveMakesSense(
        5876  size_t dstBlockIndex, VkDeviceSize dstOffset,
        5877  size_t srcBlockIndex, VkDeviceSize srcOffset)
        5878 {
        5879  if(dstBlockIndex < srcBlockIndex)
        5880  {
        5881  return true;
        5882  }
        5883  if(dstBlockIndex > srcBlockIndex)
        5884  {
        5885  return false;
        5886  }
        5887  if(dstOffset < srcOffset)
        5888  {
        5889  return true;
        5890  }
        5891  return false;
        5892 }
        5893 
        5895 // VmaAllocator_T
        5896 
        5897 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
        5898  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        5899  m_PhysicalDevice(pCreateInfo->physicalDevice),
        5900  m_hDevice(pCreateInfo->device),
        5901  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
        5902  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        5903  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
        5904  m_UnmapPersistentlyMappedMemoryCounter(0),
        5905  m_PreferredLargeHeapBlockSize(0),
        5906  m_PreferredSmallHeapBlockSize(0),
        5907  m_CurrentFrameIndex(0),
        5908  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks()))
        5909 {
        5910  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
        5911 
        5912  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
        5913  memset(&m_MemProps, 0, sizeof(m_MemProps));
        5914  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        5915 
        5916  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
        5917  memset(&m_pOwnAllocations, 0, sizeof(m_pOwnAllocations));
        5918 
        5919  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
        5920  {
        5921  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        5922  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        5923  }
        5924 
        5925  vkGetPhysicalDeviceProperties(m_PhysicalDevice, &m_PhysicalDeviceProperties);
        5926  vkGetPhysicalDeviceMemoryProperties(m_PhysicalDevice, &m_MemProps);
        5927 
        5928  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        5929  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        5930  m_PreferredSmallHeapBlockSize = (pCreateInfo->preferredSmallHeapBlockSize != 0) ?
        5931  pCreateInfo->preferredSmallHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE);
        5932 
        5933  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        5934  {
        5935  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
        5936 
        5937  for(size_t blockVectorTypeIndex = 0; blockVectorTypeIndex < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorTypeIndex)
        5938  {
        5939  m_pBlockVectors[memTypeIndex][blockVectorTypeIndex] = vma_new(this, VmaBlockVector)(
        5940  this,
        5941  memTypeIndex,
        5942  static_cast<VMA_BLOCK_VECTOR_TYPE>(blockVectorTypeIndex),
        5943  preferredBlockSize,
        5944  0,
        5945  SIZE_MAX,
        5946  GetBufferImageGranularity(),
        5947  pCreateInfo->frameInUseCount,
        5948  false); // isCustomPool
        5949  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
        5950  // becase minBlockCount is 0.
        5951  m_pOwnAllocations[memTypeIndex][blockVectorTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
        5952  }
        5953  }
        5954 }
        5955 
        5956 VmaAllocator_T::~VmaAllocator_T()
        5957 {
        5958  VMA_ASSERT(m_Pools.empty());
        5959 
        5960  for(size_t i = GetMemoryTypeCount(); i--; )
        5961  {
        5962  for(size_t j = VMA_BLOCK_VECTOR_TYPE_COUNT; j--; )
        5963  {
        5964  vma_delete(this, m_pOwnAllocations[i][j]);
        5965  vma_delete(this, m_pBlockVectors[i][j]);
        5966  }
        5967  }
        5968 }
        5969 
        5970 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
        5971 {
        5972  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[m_MemProps.memoryTypes[memTypeIndex].heapIndex].size;
        5973  return (heapSize <= VMA_SMALL_HEAP_MAX_SIZE) ?
        5974  m_PreferredSmallHeapBlockSize : m_PreferredLargeHeapBlockSize;
        5975 }
        5976 
        5977 VkResult VmaAllocator_T::AllocateMemoryOfType(
        5978  const VkMemoryRequirements& vkMemReq,
        5979  const VmaAllocationCreateInfo& createInfo,
        5980  uint32_t memTypeIndex,
        5981  VmaSuballocationType suballocType,
        5982  VmaAllocation* pAllocation)
        5983 {
        5984  VMA_ASSERT(pAllocation != VMA_NULL);
        5985  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
        5986 
        5987  uint32_t blockVectorType = VmaAllocationCreateFlagsToBlockVectorType(createInfo.flags);
        5988  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex][blockVectorType];
        5989  VMA_ASSERT(blockVector);
        5990 
        5991  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        5992  // Heuristics: Allocate own memory if requested size if greater than half of preferred block size.
        5993  const bool ownMemory =
        5994  (createInfo.flags & VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT) != 0 ||
        5995  VMA_DEBUG_ALWAYS_OWN_MEMORY ||
        5996  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
        5997  vkMemReq.size > preferredBlockSize / 2);
        5998 
        5999  if(ownMemory)
        6000  {
        6001  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        6002  {
        6003  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6004  }
        6005  else
        6006  {
        6007  return AllocateOwnMemory(
        6008  vkMemReq.size,
        6009  suballocType,
        6010  memTypeIndex,
        6011  (createInfo.flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0,
        6012  createInfo.pUserData,
        6013  pAllocation);
        6014  }
        6015  }
        6016  else
        6017  {
        6018  VkResult res = blockVector->Allocate(
        6019  VK_NULL_HANDLE, // hCurrentPool
        6020  m_CurrentFrameIndex.load(),
        6021  vkMemReq,
        6022  createInfo,
        6023  suballocType,
        6024  pAllocation);
        6025  if(res == VK_SUCCESS)
        6026  {
        6027  return res;
        6028  }
        6029 
        6030  // 5. Try own memory.
        6031  res = AllocateOwnMemory(
        6032  vkMemReq.size,
        6033  suballocType,
        6034  memTypeIndex,
        6035  (createInfo.flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0,
        6036  createInfo.pUserData,
        6037  pAllocation);
        6038  if(res == VK_SUCCESS)
        6039  {
        6040  // Succeeded: AllocateOwnMemory function already filld pMemory, nothing more to do here.
        6041  VMA_DEBUG_LOG(" Allocated as OwnMemory");
        6042  return VK_SUCCESS;
        6043  }
        6044  else
        6045  {
        6046  // Everything failed: Return error code.
        6047  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        6048  return res;
        6049  }
        6050  }
        6051 }
        6052 
        6053 VkResult VmaAllocator_T::AllocateOwnMemory(
        6054  VkDeviceSize size,
        6055  VmaSuballocationType suballocType,
        6056  uint32_t memTypeIndex,
        6057  bool map,
        6058  void* pUserData,
        6059  VmaAllocation* pAllocation)
        6060 {
        6061  VMA_ASSERT(pAllocation);
        6062 
        6063  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        6064  allocInfo.memoryTypeIndex = memTypeIndex;
        6065  allocInfo.allocationSize = size;
        6066 
        6067  // Allocate VkDeviceMemory.
        6068  VkDeviceMemory hMemory = VK_NULL_HANDLE;
        6069  VkResult res = vkAllocateMemory(m_hDevice, &allocInfo, GetAllocationCallbacks(), &hMemory);
        6070  if(res < 0)
        6071  {
        6072  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        6073  return res;
        6074  }
        6075 
        6076  void* pMappedData = nullptr;
        6077  if(map)
        6078  {
        6079  if(m_UnmapPersistentlyMappedMemoryCounter == 0)
        6080  {
        6081  res = vkMapMemory(m_hDevice, hMemory, 0, VK_WHOLE_SIZE, 0, &pMappedData);
        6082  if(res < 0)
        6083  {
        6084  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        6085  vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks());
        6086  return res;
        6087  }
        6088  }
        6089  }
        6090 
        6091  // Callback.
        6092  if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        6093  {
        6094  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, memTypeIndex, hMemory, size);
        6095  }
        6096 
        6097  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load());
        6098  (*pAllocation)->InitOwnAllocation(memTypeIndex, hMemory, suballocType, map, pMappedData, size, pUserData);
        6099 
        6100  // Register it in m_pOwnAllocations.
        6101  {
        6102  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6103  AllocationVectorType* pOwnAllocations = m_pOwnAllocations[memTypeIndex][map ? VMA_BLOCK_VECTOR_TYPE_MAPPED : VMA_BLOCK_VECTOR_TYPE_UNMAPPED];
        6104  VMA_ASSERT(pOwnAllocations);
        6105  VmaVectorInsertSorted<VmaPointerLess>(*pOwnAllocations, *pAllocation);
        6106  }
        6107 
        6108  VMA_DEBUG_LOG(" Allocated OwnMemory MemoryTypeIndex=#%u", memTypeIndex);
        6109 
        6110  return VK_SUCCESS;
        6111 }
        6112 
        6113 VkResult VmaAllocator_T::AllocateMemory(
        6114  const VkMemoryRequirements& vkMemReq,
        6115  const VmaAllocationCreateInfo& createInfo,
        6116  VmaSuballocationType suballocType,
        6117  VmaAllocation* pAllocation)
        6118 {
        6119  if((createInfo.flags & VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT) != 0 &&
        6120  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        6121  {
        6122  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        6123  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6124  }
        6125  if((createInfo.pool != VK_NULL_HANDLE) &&
        6126  ((createInfo.flags & (VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT)) != 0))
        6127  {
        6128  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT when pool != null is invalid.");
        6129  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6130  }
        6131 
        6132  if(createInfo.pool != VK_NULL_HANDLE)
        6133  {
        6134  return createInfo.pool->m_BlockVector.Allocate(
        6135  createInfo.pool,
        6136  m_CurrentFrameIndex.load(),
        6137  vkMemReq,
        6138  createInfo,
        6139  suballocType,
        6140  pAllocation);
        6141  }
        6142  else
        6143  {
        6144  // Bit mask of memory Vulkan types acceptable for this allocation.
        6145  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        6146  uint32_t memTypeIndex = UINT32_MAX;
        6147  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        6148  if(res == VK_SUCCESS)
        6149  {
        6150  res = AllocateMemoryOfType(vkMemReq, createInfo, memTypeIndex, suballocType, pAllocation);
        6151  // Succeeded on first try.
        6152  if(res == VK_SUCCESS)
        6153  {
        6154  return res;
        6155  }
        6156  // Allocation from this memory type failed. Try other compatible memory types.
        6157  else
        6158  {
        6159  for(;;)
        6160  {
        6161  // Remove old memTypeIndex from list of possibilities.
        6162  memoryTypeBits &= ~(1u << memTypeIndex);
        6163  // Find alternative memTypeIndex.
        6164  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        6165  if(res == VK_SUCCESS)
        6166  {
        6167  res = AllocateMemoryOfType(vkMemReq, createInfo, memTypeIndex, suballocType, pAllocation);
        6168  // Allocation from this alternative memory type succeeded.
        6169  if(res == VK_SUCCESS)
        6170  {
        6171  return res;
        6172  }
        6173  // else: Allocation from this memory type failed. Try next one - next loop iteration.
        6174  }
        6175  // No other matching memory type index could be found.
        6176  else
        6177  {
        6178  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        6179  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6180  }
        6181  }
        6182  }
        6183  }
        6184  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        6185  else
        6186  return res;
        6187  }
        6188 }
        6189 
        6190 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
        6191 {
        6192  VMA_ASSERT(allocation);
        6193 
        6194  if(allocation->CanBecomeLost() == false ||
        6195  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        6196  {
        6197  switch(allocation->GetType())
        6198  {
        6199  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        6200  {
        6201  VmaBlockVector* pBlockVector = VMA_NULL;
        6202  VmaPool hPool = allocation->GetPool();
        6203  if(hPool != VK_NULL_HANDLE)
        6204  {
        6205  pBlockVector = &hPool->m_BlockVector;
        6206  }
        6207  else
        6208  {
        6209  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        6210  const VMA_BLOCK_VECTOR_TYPE blockVectorType = allocation->GetBlockVectorType();
        6211  pBlockVector = m_pBlockVectors[memTypeIndex][blockVectorType];
        6212  }
        6213  pBlockVector->Free(allocation);
        6214  }
        6215  break;
        6216  case VmaAllocation_T::ALLOCATION_TYPE_OWN:
        6217  FreeOwnMemory(allocation);
        6218  break;
        6219  default:
        6220  VMA_ASSERT(0);
        6221  }
        6222  }
        6223 
        6224  vma_delete(this, allocation);
        6225 }
        6226 
        6227 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
        6228 {
        6229  InitStatInfo(pStats->total);
        6230  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        6231  InitStatInfo(pStats->memoryType[i]);
        6232  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        6233  InitStatInfo(pStats->memoryHeap[i]);
        6234 
        6235  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6236  {
        6237  const uint32_t heapIndex = m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        6238  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6239  {
        6240  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex][blockVectorType];
        6241  VMA_ASSERT(pBlockVector);
        6242  pBlockVector->AddStats(pStats, memTypeIndex, heapIndex);
        6243  }
        6244  }
        6245 
        6246  VmaPostprocessCalcStatInfo(pStats->total);
        6247  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
        6248  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
        6249  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
        6250  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
        6251 }
        6252 
        6253 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
        6254 
        6255 void VmaAllocator_T::UnmapPersistentlyMappedMemory()
        6256 {
        6257  if(m_UnmapPersistentlyMappedMemoryCounter++ == 0)
        6258  {
        6259  if(m_PhysicalDeviceProperties.vendorID == VMA_VENDOR_ID_AMD)
        6260  {
        6261  for(size_t memTypeIndex = m_MemProps.memoryTypeCount; memTypeIndex--; )
        6262  {
        6263  const VkMemoryPropertyFlags memFlags = m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        6264  if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0 &&
        6265  (memFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        6266  {
        6267  // Process OwnAllocations.
        6268  {
        6269  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6270  AllocationVectorType* pOwnAllocationsVector = m_pOwnAllocations[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6271  for(size_t ownAllocIndex = pOwnAllocationsVector->size(); ownAllocIndex--; )
        6272  {
        6273  VmaAllocation hAlloc = (*pOwnAllocationsVector)[ownAllocIndex];
        6274  hAlloc->OwnAllocUnmapPersistentlyMappedMemory(m_hDevice);
        6275  }
        6276  }
        6277 
        6278  // Process normal Allocations.
        6279  {
        6280  VmaBlockVector* pBlockVector = m_pBlockVectors[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6281  pBlockVector->UnmapPersistentlyMappedMemory();
        6282  }
        6283  }
        6284  }
        6285 
        6286  // Process custom pools.
        6287  {
        6288  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6289  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        6290  {
        6291  m_Pools[poolIndex]->GetBlockVector().UnmapPersistentlyMappedMemory();
        6292  }
        6293  }
        6294  }
        6295  }
        6296 }
        6297 
        6298 VkResult VmaAllocator_T::MapPersistentlyMappedMemory()
        6299 {
        6300  VMA_ASSERT(m_UnmapPersistentlyMappedMemoryCounter > 0);
        6301  if(--m_UnmapPersistentlyMappedMemoryCounter == 0)
        6302  {
        6303  VkResult finalResult = VK_SUCCESS;
        6304  if(m_PhysicalDeviceProperties.vendorID == VMA_VENDOR_ID_AMD)
        6305  {
        6306  // Process custom pools.
        6307  {
        6308  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6309  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        6310  {
        6311  m_Pools[poolIndex]->GetBlockVector().MapPersistentlyMappedMemory();
        6312  }
        6313  }
        6314 
        6315  for(size_t memTypeIndex = 0; memTypeIndex < m_MemProps.memoryTypeCount; ++memTypeIndex)
        6316  {
        6317  const VkMemoryPropertyFlags memFlags = m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        6318  if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0 &&
        6319  (memFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        6320  {
        6321  // Process OwnAllocations.
        6322  {
        6323  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6324  AllocationVectorType* pAllocationsVector = m_pOwnAllocations[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6325  for(size_t ownAllocIndex = 0, ownAllocCount = pAllocationsVector->size(); ownAllocIndex < ownAllocCount; ++ownAllocIndex)
        6326  {
        6327  VmaAllocation hAlloc = (*pAllocationsVector)[ownAllocIndex];
        6328  hAlloc->OwnAllocMapPersistentlyMappedMemory(m_hDevice);
        6329  }
        6330  }
        6331 
        6332  // Process normal Allocations.
        6333  {
        6334  VmaBlockVector* pBlockVector = m_pBlockVectors[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6335  VkResult localResult = pBlockVector->MapPersistentlyMappedMemory();
        6336  if(localResult != VK_SUCCESS)
        6337  {
        6338  finalResult = localResult;
        6339  }
        6340  }
        6341  }
        6342  }
        6343  }
        6344  return finalResult;
        6345  }
        6346  else
        6347  return VK_SUCCESS;
        6348 }
        6349 
        6350 VkResult VmaAllocator_T::Defragment(
        6351  VmaAllocation* pAllocations,
        6352  size_t allocationCount,
        6353  VkBool32* pAllocationsChanged,
        6354  const VmaDefragmentationInfo* pDefragmentationInfo,
        6355  VmaDefragmentationStats* pDefragmentationStats)
        6356 {
        6357  if(pAllocationsChanged != VMA_NULL)
        6358  {
        6359  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
        6360  }
        6361  if(pDefragmentationStats != VMA_NULL)
        6362  {
        6363  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
        6364  }
        6365 
        6366  if(m_UnmapPersistentlyMappedMemoryCounter > 0)
        6367  {
        6368  VMA_DEBUG_LOG("ERROR: Cannot defragment when inside vmaUnmapPersistentlyMappedMemory.");
        6369  return VK_ERROR_MEMORY_MAP_FAILED;
        6370  }
        6371 
        6372  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
        6373 
        6374  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
        6375 
        6376  const size_t poolCount = m_Pools.size();
        6377 
        6378  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
        6379  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        6380  {
        6381  VmaAllocation hAlloc = pAllocations[allocIndex];
        6382  VMA_ASSERT(hAlloc);
        6383  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
        6384  // OwnAlloc cannot be defragmented.
        6385  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
        6386  // Only HOST_VISIBLE memory types can be defragmented.
        6387  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&
        6388  // Lost allocation cannot be defragmented.
        6389  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
        6390  {
        6391  VmaBlockVector* pAllocBlockVector = nullptr;
        6392 
        6393  const VmaPool hAllocPool = hAlloc->GetPool();
        6394  // This allocation belongs to custom pool.
        6395  if(hAllocPool != VK_NULL_HANDLE)
        6396  {
        6397  pAllocBlockVector = &hAllocPool->GetBlockVector();
        6398  }
        6399  // This allocation belongs to general pool.
        6400  else
        6401  {
        6402  pAllocBlockVector = m_pBlockVectors[memTypeIndex][hAlloc->GetBlockVectorType()];
        6403  }
        6404 
        6405  VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(
        6406  m_hDevice,
        6407  GetAllocationCallbacks(),
        6408  currentFrameIndex);
        6409 
        6410  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
        6411  &pAllocationsChanged[allocIndex] : VMA_NULL;
        6412  pDefragmentator->AddAllocation(hAlloc, pChanged);
        6413  }
        6414  }
        6415 
        6416  VkResult result = VK_SUCCESS;
        6417 
        6418  // ======== Main processing.
        6419 
        6420  VkDeviceSize maxBytesToMove = SIZE_MAX;
        6421  uint32_t maxAllocationsToMove = UINT32_MAX;
        6422  if(pDefragmentationInfo != VMA_NULL)
        6423  {
        6424  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
        6425  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
        6426  }
        6427 
        6428  // Process standard memory.
        6429  for(uint32_t memTypeIndex = 0;
        6430  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
        6431  ++memTypeIndex)
        6432  {
        6433  // Only HOST_VISIBLE memory types can be defragmented.
        6434  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        6435  {
        6436  for(uint32_t blockVectorType = 0;
        6437  (blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT) && (result == VK_SUCCESS);
        6438  ++blockVectorType)
        6439  {
        6440  result = m_pBlockVectors[memTypeIndex][blockVectorType]->Defragment(
        6441  pDefragmentationStats,
        6442  maxBytesToMove,
        6443  maxAllocationsToMove);
        6444  }
        6445  }
        6446  }
        6447 
        6448  // Process custom pools.
        6449  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
        6450  {
        6451  result = m_Pools[poolIndex]->GetBlockVector().Defragment(
        6452  pDefragmentationStats,
        6453  maxBytesToMove,
        6454  maxAllocationsToMove);
        6455  }
        6456 
        6457  // ======== Destroy defragmentators.
        6458 
        6459  // Process custom pools.
        6460  for(size_t poolIndex = poolCount; poolIndex--; )
        6461  {
        6462  m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();
        6463  }
        6464 
        6465  // Process standard memory.
        6466  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
        6467  {
        6468  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        6469  {
        6470  for(size_t blockVectorType = VMA_BLOCK_VECTOR_TYPE_COUNT; blockVectorType--; )
        6471  {
        6472  m_pBlockVectors[memTypeIndex][blockVectorType]->DestroyDefragmentator();
        6473  }
        6474  }
        6475  }
        6476 
        6477  return result;
        6478 }
        6479 
        6480 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
        6481 {
        6482  if(hAllocation->CanBecomeLost())
        6483  {
        6484  /*
        6485  Warning: This is a carefully designed algorithm.
        6486  Do not modify unless you really know what you're doing :)
        6487  */
        6488  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        6489  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        6490  for(;;)
        6491  {
        6492  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        6493  {
        6494  pAllocationInfo->memoryType = UINT32_MAX;
        6495  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
        6496  pAllocationInfo->offset = 0;
        6497  pAllocationInfo->size = hAllocation->GetSize();
        6498  pAllocationInfo->pMappedData = VMA_NULL;
        6499  pAllocationInfo->pUserData = hAllocation->GetUserData();
        6500  return;
        6501  }
        6502  else if(localLastUseFrameIndex == localCurrFrameIndex)
        6503  {
        6504  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        6505  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        6506  pAllocationInfo->offset = hAllocation->GetOffset();
        6507  pAllocationInfo->size = hAllocation->GetSize();
        6508  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        6509  pAllocationInfo->pUserData = hAllocation->GetUserData();
        6510  return;
        6511  }
        6512  else // Last use time earlier than current time.
        6513  {
        6514  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        6515  {
        6516  localLastUseFrameIndex = localCurrFrameIndex;
        6517  }
        6518  }
        6519  }
        6520  }
        6521  // We could use the same code here, but for performance reasons we don't need to use the hAllocation.LastUseFrameIndex atomic.
        6522  else
        6523  {
        6524  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        6525  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        6526  pAllocationInfo->offset = hAllocation->GetOffset();
        6527  pAllocationInfo->size = hAllocation->GetSize();
        6528  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        6529  pAllocationInfo->pUserData = hAllocation->GetUserData();
        6530  }
        6531 }
        6532 
        6533 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
        6534 {
        6535  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);
        6536 
        6537  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
        6538 
        6539  if(newCreateInfo.maxBlockCount == 0)
        6540  {
        6541  newCreateInfo.maxBlockCount = SIZE_MAX;
        6542  }
        6543  if(newCreateInfo.blockSize == 0)
        6544  {
        6545  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
        6546  }
        6547 
        6548  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
        6549 
        6550  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
        6551  if(res != VK_SUCCESS)
        6552  {
        6553  vma_delete(this, *pPool);
        6554  *pPool = VMA_NULL;
        6555  return res;
        6556  }
        6557 
        6558  // Add to m_Pools.
        6559  {
        6560  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6561  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
        6562  }
        6563 
        6564  return VK_SUCCESS;
        6565 }
        6566 
        6567 void VmaAllocator_T::DestroyPool(VmaPool pool)
        6568 {
        6569  // Remove from m_Pools.
        6570  {
        6571  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6572  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
        6573  VMA_ASSERT(success && "Pool not found in Allocator.");
        6574  }
        6575 
        6576  vma_delete(this, pool);
        6577 }
        6578 
        6579 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
        6580 {
        6581  pool->m_BlockVector.GetPoolStats(pPoolStats);
        6582 }
        6583 
        6584 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
        6585 {
        6586  m_CurrentFrameIndex.store(frameIndex);
        6587 }
        6588 
        6589 void VmaAllocator_T::MakePoolAllocationsLost(
        6590  VmaPool hPool,
        6591  size_t* pLostAllocationCount)
        6592 {
        6593  hPool->m_BlockVector.MakePoolAllocationsLost(
        6594  m_CurrentFrameIndex.load(),
        6595  pLostAllocationCount);
        6596 }
        6597 
        6598 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
        6599 {
        6600  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST);
        6601  (*pAllocation)->InitLost();
        6602 }
        6603 
        6604 void VmaAllocator_T::FreeOwnMemory(VmaAllocation allocation)
        6605 {
        6606  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_OWN);
        6607 
        6608  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        6609  {
        6610  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6611  AllocationVectorType* const pOwnAllocations = m_pOwnAllocations[memTypeIndex][allocation->GetBlockVectorType()];
        6612  VMA_ASSERT(pOwnAllocations);
        6613  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pOwnAllocations, allocation);
        6614  VMA_ASSERT(success);
        6615  }
        6616 
        6617  VkDeviceMemory hMemory = allocation->GetMemory();
        6618 
        6619  // Callback.
        6620  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        6621  {
        6622  (*m_DeviceMemoryCallbacks.pfnFree)(this, memTypeIndex, hMemory, allocation->GetSize());
        6623  }
        6624 
        6625  if(allocation->GetMappedData() != VMA_NULL)
        6626  {
        6627  vkUnmapMemory(m_hDevice, hMemory);
        6628  }
        6629 
        6630  vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks());
        6631 
        6632  VMA_DEBUG_LOG(" Freed OwnMemory MemoryTypeIndex=%u", memTypeIndex);
        6633 }
        6634 
        6635 #if VMA_STATS_STRING_ENABLED
        6636 
        6637 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
        6638 {
        6639  bool ownAllocationsStarted = false;
        6640  for(size_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6641  {
        6642  VmaMutexLock ownAllocationsLock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6643  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6644  {
        6645  AllocationVectorType* const pOwnAllocVector = m_pOwnAllocations[memTypeIndex][blockVectorType];
        6646  VMA_ASSERT(pOwnAllocVector);
        6647  if(pOwnAllocVector->empty() == false)
        6648  {
        6649  if(ownAllocationsStarted == false)
        6650  {
        6651  ownAllocationsStarted = true;
        6652  json.WriteString("OwnAllocations");
        6653  json.BeginObject();
        6654  }
        6655 
        6656  json.BeginString("Type ");
        6657  json.ContinueString(memTypeIndex);
        6658  if(blockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED)
        6659  {
        6660  json.ContinueString(" Mapped");
        6661  }
        6662  json.EndString();
        6663 
        6664  json.BeginArray();
        6665 
        6666  for(size_t i = 0; i < pOwnAllocVector->size(); ++i)
        6667  {
        6668  const VmaAllocation hAlloc = (*pOwnAllocVector)[i];
        6669  json.BeginObject(true);
        6670 
        6671  json.WriteString("Size");
        6672  json.WriteNumber(hAlloc->GetSize());
        6673 
        6674  json.WriteString("Type");
        6675  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[hAlloc->GetSuballocationType()]);
        6676 
        6677  json.EndObject();
        6678  }
        6679 
        6680  json.EndArray();
        6681  }
        6682  }
        6683  }
        6684  if(ownAllocationsStarted)
        6685  {
        6686  json.EndObject();
        6687  }
        6688 
        6689  {
        6690  bool allocationsStarted = false;
        6691  for(size_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6692  {
        6693  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6694  {
        6695  if(m_pBlockVectors[memTypeIndex][blockVectorType]->IsEmpty() == false)
        6696  {
        6697  if(allocationsStarted == false)
        6698  {
        6699  allocationsStarted = true;
        6700  json.WriteString("Allocations");
        6701  json.BeginObject();
        6702  }
        6703 
        6704  json.BeginString("Type ");
        6705  json.ContinueString(memTypeIndex);
        6706  if(blockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED)
        6707  {
        6708  json.ContinueString(" Mapped");
        6709  }
        6710  json.EndString();
        6711 
        6712  m_pBlockVectors[memTypeIndex][blockVectorType]->PrintDetailedMap(json);
        6713  }
        6714  }
        6715  }
        6716  if(allocationsStarted)
        6717  {
        6718  json.EndObject();
        6719  }
        6720  }
        6721 
        6722  {
        6723  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6724  const size_t poolCount = m_Pools.size();
        6725  if(poolCount > 0)
        6726  {
        6727  json.WriteString("Pools");
        6728  json.BeginArray();
        6729  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        6730  {
        6731  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
        6732  }
        6733  json.EndArray();
        6734  }
        6735  }
        6736 }
        6737 
        6738 #endif // #if VMA_STATS_STRING_ENABLED
        6739 
        6740 static VkResult AllocateMemoryForImage(
        6741  VmaAllocator allocator,
        6742  VkImage image,
        6743  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        6744  VmaSuballocationType suballocType,
        6745  VmaAllocation* pAllocation)
        6746 {
        6747  VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation);
        6748 
        6749  VkMemoryRequirements vkMemReq = {};
        6750  vkGetImageMemoryRequirements(allocator->m_hDevice, image, &vkMemReq);
        6751 
        6752  return allocator->AllocateMemory(
        6753  vkMemReq,
        6754  *pAllocationCreateInfo,
        6755  suballocType,
        6756  pAllocation);
        6757 }
        6758 
        6760 // Public interface
        6761 
        6762 VkResult vmaCreateAllocator(
        6763  const VmaAllocatorCreateInfo* pCreateInfo,
        6764  VmaAllocator* pAllocator)
        6765 {
        6766  VMA_ASSERT(pCreateInfo && pAllocator);
        6767  VMA_DEBUG_LOG("vmaCreateAllocator");
        6768  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
        6769  return VK_SUCCESS;
        6770 }
        6771 
        6772 void vmaDestroyAllocator(
        6773  VmaAllocator allocator)
        6774 {
        6775  if(allocator != VK_NULL_HANDLE)
        6776  {
        6777  VMA_DEBUG_LOG("vmaDestroyAllocator");
        6778  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
        6779  vma_delete(&allocationCallbacks, allocator);
        6780  }
        6781 }
        6782 
        6783 void vmaGetPhysicalDeviceProperties(
        6784  VmaAllocator allocator,
        6785  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        6786 {
        6787  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
        6788  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
        6789 }
        6790 
        6791 void vmaGetMemoryProperties(
        6792  VmaAllocator allocator,
        6793  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
        6794 {
        6795  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
        6796  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
        6797 }
        6798 
        6799 void vmaGetMemoryTypeProperties(
        6800  VmaAllocator allocator,
        6801  uint32_t memoryTypeIndex,
        6802  VkMemoryPropertyFlags* pFlags)
        6803 {
        6804  VMA_ASSERT(allocator && pFlags);
        6805  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
        6806  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
        6807 }
        6808 
        6809 void vmaSetCurrentFrameIndex(
        6810  VmaAllocator allocator,
        6811  uint32_t frameIndex)
        6812 {
        6813  VMA_ASSERT(allocator);
        6814  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
        6815 
        6816  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        6817 
        6818  allocator->SetCurrentFrameIndex(frameIndex);
        6819 }
        6820 
        6821 void vmaCalculateStats(
        6822  VmaAllocator allocator,
        6823  VmaStats* pStats)
        6824 {
        6825  VMA_ASSERT(allocator && pStats);
        6826  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        6827  allocator->CalculateStats(pStats);
        6828 }
        6829 
        6830 #if VMA_STATS_STRING_ENABLED
        6831 
        6832 void vmaBuildStatsString(
        6833  VmaAllocator allocator,
        6834  char** ppStatsString,
        6835  VkBool32 detailedMap)
        6836 {
        6837  VMA_ASSERT(allocator && ppStatsString);
        6838  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        6839 
        6840  VmaStringBuilder sb(allocator);
        6841  {
        6842  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        6843  json.BeginObject();
        6844 
        6845  VmaStats stats;
        6846  allocator->CalculateStats(&stats);
        6847 
        6848  json.WriteString("Total");
        6849  VmaPrintStatInfo(json, stats.total);
        6850 
        6851  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
        6852  {
        6853  json.BeginString("Heap ");
        6854  json.ContinueString(heapIndex);
        6855  json.EndString();
        6856  json.BeginObject();
        6857 
        6858  json.WriteString("Size");
        6859  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
        6860 
        6861  json.WriteString("Flags");
        6862  json.BeginArray(true);
        6863  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
        6864  {
        6865  json.WriteString("DEVICE_LOCAL");
        6866  }
        6867  json.EndArray();
        6868 
        6869  if(stats.memoryHeap[heapIndex].BlockCount > 0)
        6870  {
        6871  json.WriteString("Stats");
        6872  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
        6873  }
        6874 
        6875  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
        6876  {
        6877  if(allocator->m_MemProps.memoryTypes[typeIndex].heapIndex == heapIndex)
        6878  {
        6879  json.BeginString("Type ");
        6880  json.ContinueString(typeIndex);
        6881  json.EndString();
        6882 
        6883  json.BeginObject();
        6884 
        6885  json.WriteString("Flags");
        6886  json.BeginArray(true);
        6887  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
        6888  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        6889  {
        6890  json.WriteString("DEVICE_LOCAL");
        6891  }
        6892  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        6893  {
        6894  json.WriteString("HOST_VISIBLE");
        6895  }
        6896  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
        6897  {
        6898  json.WriteString("HOST_COHERENT");
        6899  }
        6900  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
        6901  {
        6902  json.WriteString("HOST_CACHED");
        6903  }
        6904  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        6905  {
        6906  json.WriteString("LAZILY_ALLOCATED");
        6907  }
        6908  json.EndArray();
        6909 
        6910  if(stats.memoryType[typeIndex].BlockCount > 0)
        6911  {
        6912  json.WriteString("Stats");
        6913  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
        6914  }
        6915 
        6916  json.EndObject();
        6917  }
        6918  }
        6919 
        6920  json.EndObject();
        6921  }
        6922  if(detailedMap == VK_TRUE)
        6923  {
        6924  allocator->PrintDetailedMap(json);
        6925  }
        6926 
        6927  json.EndObject();
        6928  }
        6929 
        6930  const size_t len = sb.GetLength();
        6931  char* const pChars = vma_new_array(allocator, char, len + 1);
        6932  if(len > 0)
        6933  {
        6934  memcpy(pChars, sb.GetData(), len);
        6935  }
        6936  pChars[len] = '\0';
        6937  *ppStatsString = pChars;
        6938 }
        6939 
        6940 void vmaFreeStatsString(
        6941  VmaAllocator allocator,
        6942  char* pStatsString)
        6943 {
        6944  if(pStatsString != VMA_NULL)
        6945  {
        6946  VMA_ASSERT(allocator);
        6947  size_t len = strlen(pStatsString);
        6948  vma_delete_array(allocator, pStatsString, len + 1);
        6949  }
        6950 }
        6951 
        6952 #endif // #if VMA_STATS_STRING_ENABLED
        6953 
        6956 VkResult vmaFindMemoryTypeIndex(
        6957  VmaAllocator allocator,
        6958  uint32_t memoryTypeBits,
        6959  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        6960  uint32_t* pMemoryTypeIndex)
        6961 {
        6962  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        6963  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        6964  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        6965 
        6966  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        6967  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
        6968  if(preferredFlags == 0)
        6969  {
        6970  preferredFlags = requiredFlags;
        6971  }
        6972  // preferredFlags, if not 0, must be a superset of requiredFlags.
        6973  VMA_ASSERT((requiredFlags & ~preferredFlags) == 0);
        6974 
        6975  // Convert usage to requiredFlags and preferredFlags.
        6976  switch(pAllocationCreateInfo->usage)
        6977  {
        6978  case VMA_MEMORY_USAGE_UNKNOWN:
        6979  break;
        6980  case VMA_MEMORY_USAGE_GPU_ONLY:
        6981  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        6982  break;
        6983  case VMA_MEMORY_USAGE_CPU_ONLY:
        6984  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        6985  break;
        6986  case VMA_MEMORY_USAGE_CPU_TO_GPU:
        6987  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        6988  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        6989  break;
        6990  case VMA_MEMORY_USAGE_GPU_TO_CPU:
        6991  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        6992  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        6993  break;
        6994  default:
        6995  break;
        6996  }
        6997 
        6998  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0)
        6999  {
        7000  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        7001  }
        7002 
        7003  *pMemoryTypeIndex = UINT32_MAX;
        7004  uint32_t minCost = UINT32_MAX;
        7005  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        7006  memTypeIndex < allocator->GetMemoryTypeCount();
        7007  ++memTypeIndex, memTypeBit <<= 1)
        7008  {
        7009  // This memory type is acceptable according to memoryTypeBits bitmask.
        7010  if((memTypeBit & memoryTypeBits) != 0)
        7011  {
        7012  const VkMemoryPropertyFlags currFlags =
        7013  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        7014  // This memory type contains requiredFlags.
        7015  if((requiredFlags & ~currFlags) == 0)
        7016  {
        7017  // Calculate cost as number of bits from preferredFlags not present in this memory type.
        7018  uint32_t currCost = CountBitsSet(preferredFlags & ~currFlags);
        7019  // Remember memory type with lowest cost.
        7020  if(currCost < minCost)
        7021  {
        7022  *pMemoryTypeIndex = memTypeIndex;
        7023  if(currCost == 0)
        7024  {
        7025  return VK_SUCCESS;
        7026  }
        7027  minCost = currCost;
        7028  }
        7029  }
        7030  }
        7031  }
        7032  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
        7033 }
        7034 
        7035 VkResult vmaCreatePool(
        7036  VmaAllocator allocator,
        7037  const VmaPoolCreateInfo* pCreateInfo,
        7038  VmaPool* pPool)
        7039 {
        7040  VMA_ASSERT(allocator && pCreateInfo && pPool);
        7041 
        7042  VMA_DEBUG_LOG("vmaCreatePool");
        7043 
        7044  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7045 
        7046  return allocator->CreatePool(pCreateInfo, pPool);
        7047 }
        7048 
        7049 void vmaDestroyPool(
        7050  VmaAllocator allocator,
        7051  VmaPool pool)
        7052 {
        7053  VMA_ASSERT(allocator && pool);
        7054 
        7055  VMA_DEBUG_LOG("vmaDestroyPool");
        7056 
        7057  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7058 
        7059  allocator->DestroyPool(pool);
        7060 }
        7061 
        7062 void vmaGetPoolStats(
        7063  VmaAllocator allocator,
        7064  VmaPool pool,
        7065  VmaPoolStats* pPoolStats)
        7066 {
        7067  VMA_ASSERT(allocator && pool && pPoolStats);
        7068 
        7069  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7070 
        7071  allocator->GetPoolStats(pool, pPoolStats);
        7072 }
        7073 
        7074 void vmaMakePoolAllocationsLost(
        7075  VmaAllocator allocator,
        7076  VmaPool pool,
        7077  size_t* pLostAllocationCount)
        7078 {
        7079  VMA_ASSERT(allocator && pool);
        7080 
        7081  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7082 
        7083  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
        7084 }
        7085 
        7086 VkResult vmaAllocateMemory(
        7087  VmaAllocator allocator,
        7088  const VkMemoryRequirements* pVkMemoryRequirements,
        7089  const VmaAllocationCreateInfo* pCreateInfo,
        7090  VmaAllocation* pAllocation,
        7091  VmaAllocationInfo* pAllocationInfo)
        7092 {
        7093  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
        7094 
        7095  VMA_DEBUG_LOG("vmaAllocateMemory");
        7096 
        7097  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7098 
        7099  VkResult result = allocator->AllocateMemory(
        7100  *pVkMemoryRequirements,
        7101  *pCreateInfo,
        7102  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        7103  pAllocation);
        7104 
        7105  if(pAllocationInfo && result == VK_SUCCESS)
        7106  {
        7107  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7108  }
        7109 
        7110  return result;
        7111 }
        7112 
        7113 VkResult vmaAllocateMemoryForBuffer(
        7114  VmaAllocator allocator,
        7115  VkBuffer buffer,
        7116  const VmaAllocationCreateInfo* pCreateInfo,
        7117  VmaAllocation* pAllocation,
        7118  VmaAllocationInfo* pAllocationInfo)
        7119 {
        7120  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        7121 
        7122  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
        7123 
        7124  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7125 
        7126  VkMemoryRequirements vkMemReq = {};
        7127  vkGetBufferMemoryRequirements(allocator->m_hDevice, buffer, &vkMemReq);
        7128 
        7129  VkResult result = allocator->AllocateMemory(
        7130  vkMemReq,
        7131  *pCreateInfo,
        7132  VMA_SUBALLOCATION_TYPE_BUFFER,
        7133  pAllocation);
        7134 
        7135  if(pAllocationInfo && result == VK_SUCCESS)
        7136  {
        7137  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7138  }
        7139 
        7140  return result;
        7141 }
        7142 
        7143 VkResult vmaAllocateMemoryForImage(
        7144  VmaAllocator allocator,
        7145  VkImage image,
        7146  const VmaAllocationCreateInfo* pCreateInfo,
        7147  VmaAllocation* pAllocation,
        7148  VmaAllocationInfo* pAllocationInfo)
        7149 {
        7150  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        7151 
        7152  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
        7153 
        7154  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7155 
        7156  VkResult result = AllocateMemoryForImage(
        7157  allocator,
        7158  image,
        7159  pCreateInfo,
        7160  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        7161  pAllocation);
        7162 
        7163  if(pAllocationInfo && result == VK_SUCCESS)
        7164  {
        7165  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7166  }
        7167 
        7168  return result;
        7169 }
        7170 
        7171 void vmaFreeMemory(
        7172  VmaAllocator allocator,
        7173  VmaAllocation allocation)
        7174 {
        7175  VMA_ASSERT(allocator && allocation);
        7176 
        7177  VMA_DEBUG_LOG("vmaFreeMemory");
        7178 
        7179  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7180 
        7181  allocator->FreeMemory(allocation);
        7182 }
        7183 
        7184 void vmaGetAllocationInfo(
        7185  VmaAllocator allocator,
        7186  VmaAllocation allocation,
        7187  VmaAllocationInfo* pAllocationInfo)
        7188 {
        7189  VMA_ASSERT(allocator && allocation && pAllocationInfo);
        7190 
        7191  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7192 
        7193  allocator->GetAllocationInfo(allocation, pAllocationInfo);
        7194 }
        7195 
        7196 void vmaSetAllocationUserData(
        7197  VmaAllocator allocator,
        7198  VmaAllocation allocation,
        7199  void* pUserData)
        7200 {
        7201  VMA_ASSERT(allocator && allocation);
        7202 
        7203  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7204 
        7205  allocation->SetUserData(pUserData);
        7206 }
        7207 
        7208 void vmaCreateLostAllocation(
        7209  VmaAllocator allocator,
        7210  VmaAllocation* pAllocation)
        7211 {
        7212  VMA_ASSERT(allocator && pAllocation);
        7213 
        7214  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        7215 
        7216  allocator->CreateLostAllocation(pAllocation);
        7217 }
        7218 
        7219 VkResult vmaMapMemory(
        7220  VmaAllocator allocator,
        7221  VmaAllocation allocation,
        7222  void** ppData)
        7223 {
        7224  VMA_ASSERT(allocator && allocation && ppData);
        7225 
        7226  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7227 
        7228  return vkMapMemory(allocator->m_hDevice, allocation->GetMemory(),
        7229  allocation->GetOffset(), allocation->GetSize(), 0, ppData);
        7230 }
        7231 
        7232 void vmaUnmapMemory(
        7233  VmaAllocator allocator,
        7234  VmaAllocation allocation)
        7235 {
        7236  VMA_ASSERT(allocator && allocation);
        7237 
        7238  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7239 
        7240  vkUnmapMemory(allocator->m_hDevice, allocation->GetMemory());
        7241 }
        7242 
        7243 void vmaUnmapPersistentlyMappedMemory(VmaAllocator allocator)
        7244 {
        7245  VMA_ASSERT(allocator);
        7246 
        7247  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7248 
        7249  allocator->UnmapPersistentlyMappedMemory();
        7250 }
        7251 
        7252 VkResult vmaMapPersistentlyMappedMemory(VmaAllocator allocator)
        7253 {
        7254  VMA_ASSERT(allocator);
        7255 
        7256  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7257 
        7258  return allocator->MapPersistentlyMappedMemory();
        7259 }
        7260 
        7261 VkResult vmaDefragment(
        7262  VmaAllocator allocator,
        7263  VmaAllocation* pAllocations,
        7264  size_t allocationCount,
        7265  VkBool32* pAllocationsChanged,
        7266  const VmaDefragmentationInfo *pDefragmentationInfo,
        7267  VmaDefragmentationStats* pDefragmentationStats)
        7268 {
        7269  VMA_ASSERT(allocator && pAllocations);
        7270 
        7271  VMA_DEBUG_LOG("vmaDefragment");
        7272 
        7273  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7274 
        7275  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
        7276 }
        7277 
        7278 VkResult vmaCreateBuffer(
        7279  VmaAllocator allocator,
        7280  const VkBufferCreateInfo* pBufferCreateInfo,
        7281  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        7282  VkBuffer* pBuffer,
        7283  VmaAllocation* pAllocation,
        7284  VmaAllocationInfo* pAllocationInfo)
        7285 {
        7286  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
        7287 
        7288  VMA_DEBUG_LOG("vmaCreateBuffer");
        7289 
        7290  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7291 
        7292  *pBuffer = VK_NULL_HANDLE;
        7293  *pAllocation = VK_NULL_HANDLE;
        7294 
        7295  // 1. Create VkBuffer.
        7296  VkResult res = vkCreateBuffer(allocator->m_hDevice, pBufferCreateInfo, allocator->GetAllocationCallbacks(), pBuffer);
        7297  if(res >= 0)
        7298  {
        7299  // 2. vkGetBufferMemoryRequirements.
        7300  VkMemoryRequirements vkMemReq = {};
        7301  vkGetBufferMemoryRequirements(allocator->m_hDevice, *pBuffer, &vkMemReq);
        7302 
        7303  // 3. Allocate memory using allocator.
        7304  res = allocator->AllocateMemory(
        7305  vkMemReq,
        7306  *pAllocationCreateInfo,
        7307  VMA_SUBALLOCATION_TYPE_BUFFER,
        7308  pAllocation);
        7309  if(res >= 0)
        7310  {
        7311  // 3. Bind buffer with memory.
        7312  res = vkBindBufferMemory(allocator->m_hDevice, *pBuffer, (*pAllocation)->GetMemory(), (*pAllocation)->GetOffset());
        7313  if(res >= 0)
        7314  {
        7315  // All steps succeeded.
        7316  if(pAllocationInfo != VMA_NULL)
        7317  {
        7318  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7319  }
        7320  return VK_SUCCESS;
        7321  }
        7322  allocator->FreeMemory(*pAllocation);
        7323  *pAllocation = VK_NULL_HANDLE;
        7324  return res;
        7325  }
        7326  vkDestroyBuffer(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        7327  *pBuffer = VK_NULL_HANDLE;
        7328  return res;
        7329  }
        7330  return res;
        7331 }
        7332 
        7333 void vmaDestroyBuffer(
        7334  VmaAllocator allocator,
        7335  VkBuffer buffer,
        7336  VmaAllocation allocation)
        7337 {
        7338  if(buffer != VK_NULL_HANDLE)
        7339  {
        7340  VMA_ASSERT(allocator);
        7341 
        7342  VMA_DEBUG_LOG("vmaDestroyBuffer");
        7343 
        7344  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7345 
        7346  vkDestroyBuffer(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        7347 
        7348  allocator->FreeMemory(allocation);
        7349  }
        7350 }
        7351 
        7352 VkResult vmaCreateImage(
        7353  VmaAllocator allocator,
        7354  const VkImageCreateInfo* pImageCreateInfo,
        7355  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        7356  VkImage* pImage,
        7357  VmaAllocation* pAllocation,
        7358  VmaAllocationInfo* pAllocationInfo)
        7359 {
        7360  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
        7361 
        7362  VMA_DEBUG_LOG("vmaCreateImage");
        7363 
        7364  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7365 
        7366  *pImage = VK_NULL_HANDLE;
        7367  *pAllocation = VK_NULL_HANDLE;
        7368 
        7369  // 1. Create VkImage.
        7370  VkResult res = vkCreateImage(allocator->m_hDevice, pImageCreateInfo, allocator->GetAllocationCallbacks(), pImage);
        7371  if(res >= 0)
        7372  {
        7373  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
        7374  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
        7375  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
        7376 
        7377  // 2. Allocate memory using allocator.
        7378  res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation);
        7379  if(res >= 0)
        7380  {
        7381  // 3. Bind image with memory.
        7382  res = vkBindImageMemory(allocator->m_hDevice, *pImage, (*pAllocation)->GetMemory(), (*pAllocation)->GetOffset());
        7383  if(res >= 0)
        7384  {
        7385  // All steps succeeded.
        7386  if(pAllocationInfo != VMA_NULL)
        7387  {
        7388  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7389  }
        7390  return VK_SUCCESS;
        7391  }
        7392  allocator->FreeMemory(*pAllocation);
        7393  *pAllocation = VK_NULL_HANDLE;
        7394  return res;
        7395  }
        7396  vkDestroyImage(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        7397  *pImage = VK_NULL_HANDLE;
        7398  return res;
        7399  }
        7400  return res;
        7401 }
        7402 
        7403 void vmaDestroyImage(
        7404  VmaAllocator allocator,
        7405  VkImage image,
        7406  VmaAllocation allocation)
        7407 {
        7408  if(image != VK_NULL_HANDLE)
        7409  {
        7410  VMA_ASSERT(allocator);
        7411 
        7412  VMA_DEBUG_LOG("vmaDestroyImage");
        7413 
        7414  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7415 
        7416  vkDestroyImage(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
        7417 
        7418  allocator->FreeMemory(allocation);
        7419  }
        7420 }
        7421 
        7422 #endif // #ifdef VMA_IMPLEMENTATION
        VmaAllocatorCreateInfo::physicalDevice
        VkPhysicalDevice physicalDevice
        Vulkan physical device.
        Definition: vk_mem_alloc.h:457
        -
        VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:756
        +Go to the documentation of this file.
        1 //
        2 // Copyright (c) 2017 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 
        420 #include <vulkan/vulkan.h>
        421 
        423 
        427 VK_DEFINE_HANDLE(VmaAllocator)
        428 
        429 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
        431  VmaAllocator allocator,
        432  uint32_t memoryType,
        433  VkDeviceMemory memory,
        434  VkDeviceSize size);
        436 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
        437  VmaAllocator allocator,
        438  uint32_t memoryType,
        439  VkDeviceMemory memory,
        440  VkDeviceSize size);
        441 
        447 typedef struct VmaDeviceMemoryCallbacks {
        449  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
        451  PFN_vmaFreeDeviceMemoryFunction pfnFree;
        452 } VmaDeviceMemoryCallbacks;
        453 
        455 typedef enum VmaAllocatorFlagBits {
        460  VMA_ALLOCATOR_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
        461 
        462  VMA_ALLOCATOR_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        463 } VmaAllocatorFlagBits;
        464 typedef VkFlags VmaAllocatorFlags;
        465 
        467 typedef struct VmaAllocatorCreateInfo
        468 {
        470  VmaAllocatorFlags flags;
        472 
        473  VkPhysicalDevice physicalDevice;
        475 
        476  VkDevice device;
        478 
        479  VkDeviceSize preferredLargeHeapBlockSize;
        481 
        482  VkDeviceSize preferredSmallHeapBlockSize;
        484 
        485  const VkAllocationCallbacks* pAllocationCallbacks;
        487 
        488  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
        502  uint32_t frameInUseCount;
        520  const VkDeviceSize* pHeapSizeLimit;
        521 } VmaAllocatorCreateInfo;
        522 
        524 VkResult vmaCreateAllocator(
        525  const VmaAllocatorCreateInfo* pCreateInfo,
        526  VmaAllocator* pAllocator);
        527 
        529 void vmaDestroyAllocator(
        530  VmaAllocator allocator);
        531 
        536 void vmaGetPhysicalDeviceProperties(
        537  VmaAllocator allocator,
        538  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
        539 
        544 void vmaGetMemoryProperties(
        545  VmaAllocator allocator,
        546  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
        547 
        554 void vmaGetMemoryTypeProperties(
        555  VmaAllocator allocator,
        556  uint32_t memoryTypeIndex,
        557  VkMemoryPropertyFlags* pFlags);
        558 
        567 void vmaSetCurrentFrameIndex(
        568  VmaAllocator allocator,
        569  uint32_t frameIndex);
        570 
        571 typedef struct VmaStatInfo
        572 {
        574  uint32_t BlockCount;
        576  uint32_t AllocationCount;
        578  uint32_t UnusedRangeCount;
        580  VkDeviceSize UsedBytes;
        582  VkDeviceSize UnusedBytes;
        583  VkDeviceSize AllocationSizeMin, AllocationSizeAvg, AllocationSizeMax;
        584  VkDeviceSize UnusedRangeSizeMin, UnusedRangeSizeAvg, UnusedRangeSizeMax;
        585 } VmaStatInfo;
        586 
        588 struct VmaStats
        589 {
        590  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
        591  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
        592  VmaStatInfo total;
        593 };
        594 
        596 void vmaCalculateStats(
        597  VmaAllocator allocator,
        598  VmaStats* pStats);
        599 
        600 #define VMA_STATS_STRING_ENABLED 1
        601 
        602 #if VMA_STATS_STRING_ENABLED
        603 
        605 
        607 void vmaBuildStatsString(
        608  VmaAllocator allocator,
        609  char** ppStatsString,
        610  VkBool32 detailedMap);
        611 
        612 void vmaFreeStatsString(
        613  VmaAllocator allocator,
        614  char* pStatsString);
        615 
        616 #endif // #if VMA_STATS_STRING_ENABLED
        617 
        620 
        625 VK_DEFINE_HANDLE(VmaPool)
        626 
        627 typedef enum VmaMemoryUsage
        628 {
        630  VMA_MEMORY_USAGE_UNKNOWN = 0,
        632  VMA_MEMORY_USAGE_GPU_ONLY = 1,
        634 
        635  VMA_MEMORY_USAGE_CPU_ONLY = 2,
        637 
        638  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
        640 
        641  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
        642  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
        643 } VmaMemoryUsage;
        644 
        646 typedef enum VmaAllocationCreateFlagBits {
        658  VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT = 0x00000001,
        659 
        669  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
        679  VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT = 0x00000004,
        690  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
        697  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
        698 
        699  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        700 } VmaAllocationCreateFlagBits;
        701 typedef VkFlags VmaAllocationCreateFlags;
        702 
        703 typedef struct VmaAllocationCreateInfo
        704 {
        706  VmaAllocationCreateFlags flags;
        712  VmaMemoryUsage usage;
        717  VkMemoryPropertyFlags requiredFlags;
        723  VkMemoryPropertyFlags preferredFlags;
        725  void* pUserData;
        730  VmaPool pool;
        731 } VmaAllocationCreateInfo;
        732 
        747 VkResult vmaFindMemoryTypeIndex(
        748  VmaAllocator allocator,
        749  uint32_t memoryTypeBits,
        750  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        751  uint32_t* pMemoryTypeIndex);
        752 
        755 
        760 typedef enum VmaPoolCreateFlagBits {
        770  VMA_POOL_CREATE_PERSISTENT_MAP_BIT = 0x00000001,
        788  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
        789 
        790  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        791 } VmaPoolCreateFlagBits;
        792 typedef VkFlags VmaPoolCreateFlags;
        793 
        796 typedef struct VmaPoolCreateInfo {
        799  uint32_t memoryTypeIndex;
        802  VmaPoolCreateFlags flags;
        807  VkDeviceSize blockSize;
        812  size_t minBlockCount;
        820  size_t maxBlockCount;
        834  uint32_t frameInUseCount;
        835 } VmaPoolCreateInfo;
        836 
        839 typedef struct VmaPoolStats {
        842  VkDeviceSize size;
        845  VkDeviceSize unusedSize;
        848  size_t allocationCount;
        851  size_t unusedRangeCount;
        852 } VmaPoolStats;
        853 
        860 VkResult vmaCreatePool(
        861  VmaAllocator allocator,
        862  const VmaPoolCreateInfo* pCreateInfo,
        863  VmaPool* pPool);
        864 
        867 void vmaDestroyPool(
        868  VmaAllocator allocator,
        869  VmaPool pool);
        870 
        877 void vmaGetPoolStats(
        878  VmaAllocator allocator,
        879  VmaPool pool,
        880  VmaPoolStats* pPoolStats);
        881 
        888 void vmaMakePoolAllocationsLost(
        889  VmaAllocator allocator,
        890  VmaPool pool,
        891  size_t* pLostAllocationCount);
        892 
        893 VK_DEFINE_HANDLE(VmaAllocation)
        894 
        895 
        897 typedef struct VmaAllocationInfo {
        902  uint32_t memoryType;
        911  VkDeviceMemory deviceMemory;
        916  VkDeviceSize offset;
        921  VkDeviceSize size;
        927  void* pMappedData;
        932  void* pUserData;
        933 } VmaAllocationInfo;
        934 
        945 VkResult vmaAllocateMemory(
        946  VmaAllocator allocator,
        947  const VkMemoryRequirements* pVkMemoryRequirements,
        948  const VmaAllocationCreateInfo* pCreateInfo,
        949  VmaAllocation* pAllocation,
        950  VmaAllocationInfo* pAllocationInfo);
        951 
        958 VkResult vmaAllocateMemoryForBuffer(
        959  VmaAllocator allocator,
        960  VkBuffer buffer,
        961  const VmaAllocationCreateInfo* pCreateInfo,
        962  VmaAllocation* pAllocation,
        963  VmaAllocationInfo* pAllocationInfo);
        964 
        966 VkResult vmaAllocateMemoryForImage(
        967  VmaAllocator allocator,
        968  VkImage image,
        969  const VmaAllocationCreateInfo* pCreateInfo,
        970  VmaAllocation* pAllocation,
        971  VmaAllocationInfo* pAllocationInfo);
        972 
        974 void vmaFreeMemory(
        975  VmaAllocator allocator,
        976  VmaAllocation allocation);
        977 
        979 void vmaGetAllocationInfo(
        980  VmaAllocator allocator,
        981  VmaAllocation allocation,
        982  VmaAllocationInfo* pAllocationInfo);
        983 
        985 void vmaSetAllocationUserData(
        986  VmaAllocator allocator,
        987  VmaAllocation allocation,
        988  void* pUserData);
        989 
        1000 void vmaCreateLostAllocation(
        1001  VmaAllocator allocator,
        1002  VmaAllocation* pAllocation);
        1003 
        1012 VkResult vmaMapMemory(
        1013  VmaAllocator allocator,
        1014  VmaAllocation allocation,
        1015  void** ppData);
        1016 
        1017 void vmaUnmapMemory(
        1018  VmaAllocator allocator,
        1019  VmaAllocation allocation);
        1020 
        1039 void vmaUnmapPersistentlyMappedMemory(VmaAllocator allocator);
        1040 
        1048 VkResult vmaMapPersistentlyMappedMemory(VmaAllocator allocator);
        1049 
        1051 typedef struct VmaDefragmentationInfo {
        1056  VkDeviceSize maxBytesToMove;
        1061  uint32_t maxAllocationsToMove;
        1062 } VmaDefragmentationInfo;
        1063 
        1065 typedef struct VmaDefragmentationStats {
        1067  VkDeviceSize bytesMoved;
        1069  VkDeviceSize bytesFreed;
        1071  uint32_t allocationsMoved;
        1073  uint32_t deviceMemoryBlocksFreed;
        1074 } VmaDefragmentationStats;
        1075 
        1146 VkResult vmaDefragment(
        1147  VmaAllocator allocator,
        1148  VmaAllocation* pAllocations,
        1149  size_t allocationCount,
        1150  VkBool32* pAllocationsChanged,
        1151  const VmaDefragmentationInfo *pDefragmentationInfo,
        1152  VmaDefragmentationStats* pDefragmentationStats);
        1153 
        1156 
        1179 VkResult vmaCreateBuffer(
        1180  VmaAllocator allocator,
        1181  const VkBufferCreateInfo* pBufferCreateInfo,
        1182  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1183  VkBuffer* pBuffer,
        1184  VmaAllocation* pAllocation,
        1185  VmaAllocationInfo* pAllocationInfo);
        1186 
        1187 void vmaDestroyBuffer(
        1188  VmaAllocator allocator,
        1189  VkBuffer buffer,
        1190  VmaAllocation allocation);
        1191 
        1193 VkResult vmaCreateImage(
        1194  VmaAllocator allocator,
        1195  const VkImageCreateInfo* pImageCreateInfo,
        1196  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1197  VkImage* pImage,
        1198  VmaAllocation* pAllocation,
        1199  VmaAllocationInfo* pAllocationInfo);
        1200 
        1201 void vmaDestroyImage(
        1202  VmaAllocator allocator,
        1203  VkImage image,
        1204  VmaAllocation allocation);
        1205 
        1208 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
        1209 
        1210 // For Visual Studio IntelliSense.
        1211 #ifdef __INTELLISENSE__
        1212 #define VMA_IMPLEMENTATION
        1213 #endif
        1214 
        1215 #ifdef VMA_IMPLEMENTATION
        1216 #undef VMA_IMPLEMENTATION
        1217 
        1218 #include <cstdint>
        1219 #include <cstdlib>
        1220 #include <cstring>
        1221 
        1222 /*******************************************************************************
        1223 CONFIGURATION SECTION
        1224 
        1225 Define some of these macros before each #include of this header or change them
        1226 here if you need other then default behavior depending on your environment.
        1227 */
        1228 
        1229 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
        1230 //#define VMA_USE_STL_CONTAINERS 1
        1231 
        1232 /* Set this macro to 1 to make the library including and using STL containers:
        1233 std::pair, std::vector, std::list, std::unordered_map.
        1234 
        1235 Set it to 0 or undefined to make the library using its own implementation of
        1236 the containers.
        1237 */
        1238 #if VMA_USE_STL_CONTAINERS
        1239  #define VMA_USE_STL_VECTOR 1
        1240  #define VMA_USE_STL_UNORDERED_MAP 1
        1241  #define VMA_USE_STL_LIST 1
        1242 #endif
        1243 
        1244 #if VMA_USE_STL_VECTOR
        1245  #include <vector>
        1246 #endif
        1247 
        1248 #if VMA_USE_STL_UNORDERED_MAP
        1249  #include <unordered_map>
        1250 #endif
        1251 
        1252 #if VMA_USE_STL_LIST
        1253  #include <list>
        1254 #endif
        1255 
        1256 /*
        1257 Following headers are used in this CONFIGURATION section only, so feel free to
        1258 remove them if not needed.
        1259 */
        1260 #include <cassert> // for assert
        1261 #include <algorithm> // for min, max
        1262 #include <mutex> // for std::mutex
        1263 #include <atomic> // for std::atomic
        1264 
        1265 #if !defined(_WIN32)
        1266  #include <malloc.h> // for aligned_alloc()
        1267 #endif
        1268 
        1269 // Normal assert to check for programmer's errors, especially in Debug configuration.
        1270 #ifndef VMA_ASSERT
        1271  #ifdef _DEBUG
        1272  #define VMA_ASSERT(expr) assert(expr)
        1273  #else
        1274  #define VMA_ASSERT(expr)
        1275  #endif
        1276 #endif
        1277 
        1278 // Assert that will be called very often, like inside data structures e.g. operator[].
        1279 // Making it non-empty can make program slow.
        1280 #ifndef VMA_HEAVY_ASSERT
        1281  #ifdef _DEBUG
        1282  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
        1283  #else
        1284  #define VMA_HEAVY_ASSERT(expr)
        1285  #endif
        1286 #endif
        1287 
        1288 #ifndef VMA_NULL
        1289  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
        1290  #define VMA_NULL nullptr
        1291 #endif
        1292 
        1293 #ifndef VMA_ALIGN_OF
        1294  #define VMA_ALIGN_OF(type) (__alignof(type))
        1295 #endif
        1296 
        1297 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
        1298  #if defined(_WIN32)
        1299  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
        1300  #else
        1301  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
        1302  #endif
        1303 #endif
        1304 
        1305 #ifndef VMA_SYSTEM_FREE
        1306  #if defined(_WIN32)
        1307  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
        1308  #else
        1309  #define VMA_SYSTEM_FREE(ptr) free(ptr)
        1310  #endif
        1311 #endif
        1312 
        1313 #ifndef VMA_MIN
        1314  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
        1315 #endif
        1316 
        1317 #ifndef VMA_MAX
        1318  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
        1319 #endif
        1320 
        1321 #ifndef VMA_SWAP
        1322  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
        1323 #endif
        1324 
        1325 #ifndef VMA_SORT
        1326  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
        1327 #endif
        1328 
        1329 #ifndef VMA_DEBUG_LOG
        1330  #define VMA_DEBUG_LOG(format, ...)
        1331  /*
        1332  #define VMA_DEBUG_LOG(format, ...) do { \
        1333  printf(format, __VA_ARGS__); \
        1334  printf("\n"); \
        1335  } while(false)
        1336  */
        1337 #endif
        1338 
        1339 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
        1340 #if VMA_STATS_STRING_ENABLED
        1341  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
        1342  {
        1343  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
        1344  }
        1345  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
        1346  {
        1347  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
        1348  }
        1349  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
        1350  {
        1351  snprintf(outStr, strLen, "%p", ptr);
        1352  }
        1353 #endif
        1354 
        1355 #ifndef VMA_MUTEX
        1356  class VmaMutex
        1357  {
        1358  public:
        1359  VmaMutex() { }
        1360  ~VmaMutex() { }
        1361  void Lock() { m_Mutex.lock(); }
        1362  void Unlock() { m_Mutex.unlock(); }
        1363  private:
        1364  std::mutex m_Mutex;
        1365  };
        1366  #define VMA_MUTEX VmaMutex
        1367 #endif
        1368 
        1369 /*
        1370 If providing your own implementation, you need to implement a subset of std::atomic:
        1371 
        1372 - Constructor(uint32_t desired)
        1373 - uint32_t load() const
        1374 - void store(uint32_t desired)
        1375 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
        1376 */
        1377 #ifndef VMA_ATOMIC_UINT32
        1378  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
        1379 #endif
        1380 
        1381 #ifndef VMA_BEST_FIT
        1382 
        1394  #define VMA_BEST_FIT (1)
        1395 #endif
        1396 
        1397 #ifndef VMA_DEBUG_ALWAYS_OWN_MEMORY
        1398 
        1402  #define VMA_DEBUG_ALWAYS_OWN_MEMORY (0)
        1403 #endif
        1404 
        1405 #ifndef VMA_DEBUG_ALIGNMENT
        1406 
        1410  #define VMA_DEBUG_ALIGNMENT (1)
        1411 #endif
        1412 
        1413 #ifndef VMA_DEBUG_MARGIN
        1414 
        1418  #define VMA_DEBUG_MARGIN (0)
        1419 #endif
        1420 
        1421 #ifndef VMA_DEBUG_GLOBAL_MUTEX
        1422 
        1426  #define VMA_DEBUG_GLOBAL_MUTEX (0)
        1427 #endif
        1428 
        1429 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
        1430 
        1434  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
        1435 #endif
        1436 
        1437 #ifndef VMA_SMALL_HEAP_MAX_SIZE
        1438  #define VMA_SMALL_HEAP_MAX_SIZE (512 * 1024 * 1024)
        1440 #endif
        1441 
        1442 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
        1443  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256 * 1024 * 1024)
        1445 #endif
        1446 
        1447 #ifndef VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE
        1448  #define VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE (64 * 1024 * 1024)
        1450 #endif
        1451 
        1452 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
        1453 
        1454 /*******************************************************************************
        1455 END OF CONFIGURATION
        1456 */
        1457 
        1458 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
        1459  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
        1460 
        1461 // Returns number of bits set to 1 in (v).
        1462 static inline uint32_t CountBitsSet(uint32_t v)
        1463 {
        1464  uint32_t c = v - ((v >> 1) & 0x55555555);
        1465  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
        1466  c = ((c >> 4) + c) & 0x0F0F0F0F;
        1467  c = ((c >> 8) + c) & 0x00FF00FF;
        1468  c = ((c >> 16) + c) & 0x0000FFFF;
        1469  return c;
        1470 }
        1471 
        1472 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
        1473 // Use types like uint32_t, uint64_t as T.
        1474 template <typename T>
        1475 static inline T VmaAlignUp(T val, T align)
        1476 {
        1477  return (val + align - 1) / align * align;
        1478 }
        1479 
        1480 // Division with mathematical rounding to nearest number.
        1481 template <typename T>
        1482 inline T VmaRoundDiv(T x, T y)
        1483 {
        1484  return (x + (y / (T)2)) / y;
        1485 }
        1486 
        1487 #ifndef VMA_SORT
        1488 
        1489 template<typename Iterator, typename Compare>
        1490 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
        1491 {
        1492  Iterator centerValue = end; --centerValue;
        1493  Iterator insertIndex = beg;
        1494  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
        1495  {
        1496  if(cmp(*memTypeIndex, *centerValue))
        1497  {
        1498  if(insertIndex != memTypeIndex)
        1499  {
        1500  VMA_SWAP(*memTypeIndex, *insertIndex);
        1501  }
        1502  ++insertIndex;
        1503  }
        1504  }
        1505  if(insertIndex != centerValue)
        1506  {
        1507  VMA_SWAP(*insertIndex, *centerValue);
        1508  }
        1509  return insertIndex;
        1510 }
        1511 
        1512 template<typename Iterator, typename Compare>
        1513 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
        1514 {
        1515  if(beg < end)
        1516  {
        1517  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
        1518  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
        1519  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
        1520  }
        1521 }
        1522 
        1523 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
        1524 
        1525 #endif // #ifndef VMA_SORT
        1526 
        1527 /*
        1528 Returns true if two memory blocks occupy overlapping pages.
        1529 ResourceA must be in less memory offset than ResourceB.
        1530 
        1531 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
        1532 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
        1533 */
        1534 static inline bool VmaBlocksOnSamePage(
        1535  VkDeviceSize resourceAOffset,
        1536  VkDeviceSize resourceASize,
        1537  VkDeviceSize resourceBOffset,
        1538  VkDeviceSize pageSize)
        1539 {
        1540  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
        1541  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
        1542  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
        1543  VkDeviceSize resourceBStart = resourceBOffset;
        1544  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
        1545  return resourceAEndPage == resourceBStartPage;
        1546 }
        1547 
        1548 enum VmaSuballocationType
        1549 {
        1550  VMA_SUBALLOCATION_TYPE_FREE = 0,
        1551  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
        1552  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
        1553  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        1554  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        1555  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        1556  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
        1557 };
        1558 
        1559 /*
        1560 Returns true if given suballocation types could conflict and must respect
        1561 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
        1562 or linear image and another one is optimal image. If type is unknown, behave
        1563 conservatively.
        1564 */
        1565 static inline bool VmaIsBufferImageGranularityConflict(
        1566  VmaSuballocationType suballocType1,
        1567  VmaSuballocationType suballocType2)
        1568 {
        1569  if(suballocType1 > suballocType2)
        1570  {
        1571  VMA_SWAP(suballocType1, suballocType2);
        1572  }
        1573 
        1574  switch(suballocType1)
        1575  {
        1576  case VMA_SUBALLOCATION_TYPE_FREE:
        1577  return false;
        1578  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        1579  return true;
        1580  case VMA_SUBALLOCATION_TYPE_BUFFER:
        1581  return
        1582  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        1583  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        1584  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        1585  return
        1586  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        1587  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
        1588  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        1589  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        1590  return
        1591  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        1592  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        1593  return false;
        1594  default:
        1595  VMA_ASSERT(0);
        1596  return true;
        1597  }
        1598 }
        1599 
        1600 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
        1601 struct VmaMutexLock
        1602 {
        1603 public:
        1604  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
        1605  m_pMutex(useMutex ? &mutex : VMA_NULL)
        1606  {
        1607  if(m_pMutex)
        1608  {
        1609  m_pMutex->Lock();
        1610  }
        1611  }
        1612 
        1613  ~VmaMutexLock()
        1614  {
        1615  if(m_pMutex)
        1616  {
        1617  m_pMutex->Unlock();
        1618  }
        1619  }
        1620 
        1621 private:
        1622  VMA_MUTEX* m_pMutex;
        1623 };
        1624 
        1625 #if VMA_DEBUG_GLOBAL_MUTEX
        1626  static VMA_MUTEX gDebugGlobalMutex;
        1627  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
        1628 #else
        1629  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
        1630 #endif
        1631 
        1632 // Minimum size of a free suballocation to register it in the free suballocation collection.
        1633 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
        1634 
        1635 /*
        1636 Performs binary search and returns iterator to first element that is greater or
        1637 equal to (key), according to comparison (cmp).
        1638 
        1639 Cmp should return true if first argument is less than second argument.
        1640 
        1641 Returned value is the found element, if present in the collection or place where
        1642 new element with value (key) should be inserted.
        1643 */
        1644 template <typename IterT, typename KeyT, typename CmpT>
        1645 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)
        1646 {
        1647  size_t down = 0, up = (end - beg);
        1648  while(down < up)
        1649  {
        1650  const size_t mid = (down + up) / 2;
        1651  if(cmp(*(beg+mid), key))
        1652  {
        1653  down = mid + 1;
        1654  }
        1655  else
        1656  {
        1657  up = mid;
        1658  }
        1659  }
        1660  return beg + down;
        1661 }
        1662 
        1664 // Memory allocation
        1665 
        1666 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
        1667 {
        1668  if((pAllocationCallbacks != VMA_NULL) &&
        1669  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
        1670  {
        1671  return (*pAllocationCallbacks->pfnAllocation)(
        1672  pAllocationCallbacks->pUserData,
        1673  size,
        1674  alignment,
        1675  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        1676  }
        1677  else
        1678  {
        1679  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
        1680  }
        1681 }
        1682 
        1683 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
        1684 {
        1685  if((pAllocationCallbacks != VMA_NULL) &&
        1686  (pAllocationCallbacks->pfnFree != VMA_NULL))
        1687  {
        1688  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
        1689  }
        1690  else
        1691  {
        1692  VMA_SYSTEM_FREE(ptr);
        1693  }
        1694 }
        1695 
        1696 template<typename T>
        1697 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
        1698 {
        1699  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
        1700 }
        1701 
        1702 template<typename T>
        1703 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
        1704 {
        1705  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
        1706 }
        1707 
        1708 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
        1709 
        1710 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
        1711 
        1712 template<typename T>
        1713 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
        1714 {
        1715  ptr->~T();
        1716  VmaFree(pAllocationCallbacks, ptr);
        1717 }
        1718 
        1719 template<typename T>
        1720 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
        1721 {
        1722  if(ptr != VMA_NULL)
        1723  {
        1724  for(size_t i = count; i--; )
        1725  {
        1726  ptr[i].~T();
        1727  }
        1728  VmaFree(pAllocationCallbacks, ptr);
        1729  }
        1730 }
        1731 
        1732 // STL-compatible allocator.
        1733 template<typename T>
        1734 class VmaStlAllocator
        1735 {
        1736 public:
        1737  const VkAllocationCallbacks* const m_pCallbacks;
        1738  typedef T value_type;
        1739 
        1740  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
        1741  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
        1742 
        1743  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
        1744  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
        1745 
        1746  template<typename U>
        1747  bool operator==(const VmaStlAllocator<U>& rhs) const
        1748  {
        1749  return m_pCallbacks == rhs.m_pCallbacks;
        1750  }
        1751  template<typename U>
        1752  bool operator!=(const VmaStlAllocator<U>& rhs) const
        1753  {
        1754  return m_pCallbacks != rhs.m_pCallbacks;
        1755  }
        1756 
        1757  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
        1758 };
        1759 
        1760 #if VMA_USE_STL_VECTOR
        1761 
        1762 #define VmaVector std::vector
        1763 
        1764 template<typename T, typename allocatorT>
        1765 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
        1766 {
        1767  vec.insert(vec.begin() + index, item);
        1768 }
        1769 
        1770 template<typename T, typename allocatorT>
        1771 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
        1772 {
        1773  vec.erase(vec.begin() + index);
        1774 }
        1775 
        1776 #else // #if VMA_USE_STL_VECTOR
        1777 
        1778 /* Class with interface compatible with subset of std::vector.
        1779 T must be POD because constructors and destructors are not called and memcpy is
        1780 used for these objects. */
        1781 template<typename T, typename AllocatorT>
        1782 class VmaVector
        1783 {
        1784 public:
        1785  typedef T value_type;
        1786 
        1787  VmaVector(const AllocatorT& allocator) :
        1788  m_Allocator(allocator),
        1789  m_pArray(VMA_NULL),
        1790  m_Count(0),
        1791  m_Capacity(0)
        1792  {
        1793  }
        1794 
        1795  VmaVector(size_t count, const AllocatorT& allocator) :
        1796  m_Allocator(allocator),
        1797  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
        1798  m_Count(count),
        1799  m_Capacity(count)
        1800  {
        1801  }
        1802 
        1803  VmaVector(const VmaVector<T, AllocatorT>& src) :
        1804  m_Allocator(src.m_Allocator),
        1805  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
        1806  m_Count(src.m_Count),
        1807  m_Capacity(src.m_Count)
        1808  {
        1809  if(m_Count != 0)
        1810  {
        1811  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
        1812  }
        1813  }
        1814 
        1815  ~VmaVector()
        1816  {
        1817  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        1818  }
        1819 
        1820  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
        1821  {
        1822  if(&rhs != this)
        1823  {
        1824  resize(rhs.m_Count);
        1825  if(m_Count != 0)
        1826  {
        1827  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        1828  }
        1829  }
        1830  return *this;
        1831  }
        1832 
        1833  bool empty() const { return m_Count == 0; }
        1834  size_t size() const { return m_Count; }
        1835  T* data() { return m_pArray; }
        1836  const T* data() const { return m_pArray; }
        1837 
        1838  T& operator[](size_t index)
        1839  {
        1840  VMA_HEAVY_ASSERT(index < m_Count);
        1841  return m_pArray[index];
        1842  }
        1843  const T& operator[](size_t index) const
        1844  {
        1845  VMA_HEAVY_ASSERT(index < m_Count);
        1846  return m_pArray[index];
        1847  }
        1848 
        1849  T& front()
        1850  {
        1851  VMA_HEAVY_ASSERT(m_Count > 0);
        1852  return m_pArray[0];
        1853  }
        1854  const T& front() const
        1855  {
        1856  VMA_HEAVY_ASSERT(m_Count > 0);
        1857  return m_pArray[0];
        1858  }
        1859  T& back()
        1860  {
        1861  VMA_HEAVY_ASSERT(m_Count > 0);
        1862  return m_pArray[m_Count - 1];
        1863  }
        1864  const T& back() const
        1865  {
        1866  VMA_HEAVY_ASSERT(m_Count > 0);
        1867  return m_pArray[m_Count - 1];
        1868  }
        1869 
        1870  void reserve(size_t newCapacity, bool freeMemory = false)
        1871  {
        1872  newCapacity = VMA_MAX(newCapacity, m_Count);
        1873 
        1874  if((newCapacity < m_Capacity) && !freeMemory)
        1875  {
        1876  newCapacity = m_Capacity;
        1877  }
        1878 
        1879  if(newCapacity != m_Capacity)
        1880  {
        1881  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        1882  if(m_Count != 0)
        1883  {
        1884  memcpy(newArray, m_pArray, m_Count * sizeof(T));
        1885  }
        1886  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        1887  m_Capacity = newCapacity;
        1888  m_pArray = newArray;
        1889  }
        1890  }
        1891 
        1892  void resize(size_t newCount, bool freeMemory = false)
        1893  {
        1894  size_t newCapacity = m_Capacity;
        1895  if(newCount > m_Capacity)
        1896  {
        1897  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
        1898  }
        1899  else if(freeMemory)
        1900  {
        1901  newCapacity = newCount;
        1902  }
        1903 
        1904  if(newCapacity != m_Capacity)
        1905  {
        1906  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        1907  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        1908  if(elementsToCopy != 0)
        1909  {
        1910  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        1911  }
        1912  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        1913  m_Capacity = newCapacity;
        1914  m_pArray = newArray;
        1915  }
        1916 
        1917  m_Count = newCount;
        1918  }
        1919 
        1920  void clear(bool freeMemory = false)
        1921  {
        1922  resize(0, freeMemory);
        1923  }
        1924 
        1925  void insert(size_t index, const T& src)
        1926  {
        1927  VMA_HEAVY_ASSERT(index <= m_Count);
        1928  const size_t oldCount = size();
        1929  resize(oldCount + 1);
        1930  if(index < oldCount)
        1931  {
        1932  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
        1933  }
        1934  m_pArray[index] = src;
        1935  }
        1936 
        1937  void remove(size_t index)
        1938  {
        1939  VMA_HEAVY_ASSERT(index < m_Count);
        1940  const size_t oldCount = size();
        1941  if(index < oldCount - 1)
        1942  {
        1943  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
        1944  }
        1945  resize(oldCount - 1);
        1946  }
        1947 
        1948  void push_back(const T& src)
        1949  {
        1950  const size_t newIndex = size();
        1951  resize(newIndex + 1);
        1952  m_pArray[newIndex] = src;
        1953  }
        1954 
        1955  void pop_back()
        1956  {
        1957  VMA_HEAVY_ASSERT(m_Count > 0);
        1958  resize(size() - 1);
        1959  }
        1960 
        1961  void push_front(const T& src)
        1962  {
        1963  insert(0, src);
        1964  }
        1965 
        1966  void pop_front()
        1967  {
        1968  VMA_HEAVY_ASSERT(m_Count > 0);
        1969  remove(0);
        1970  }
        1971 
        1972  typedef T* iterator;
        1973 
        1974  iterator begin() { return m_pArray; }
        1975  iterator end() { return m_pArray + m_Count; }
        1976 
        1977 private:
        1978  AllocatorT m_Allocator;
        1979  T* m_pArray;
        1980  size_t m_Count;
        1981  size_t m_Capacity;
        1982 };
        1983 
        1984 template<typename T, typename allocatorT>
        1985 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
        1986 {
        1987  vec.insert(index, item);
        1988 }
        1989 
        1990 template<typename T, typename allocatorT>
        1991 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
        1992 {
        1993  vec.remove(index);
        1994 }
        1995 
        1996 #endif // #if VMA_USE_STL_VECTOR
        1997 
        1998 template<typename CmpLess, typename VectorT>
        1999 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
        2000 {
        2001  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        2002  vector.data(),
        2003  vector.data() + vector.size(),
        2004  value,
        2005  CmpLess()) - vector.data();
        2006  VmaVectorInsert(vector, indexToInsert, value);
        2007  return indexToInsert;
        2008 }
        2009 
        2010 template<typename CmpLess, typename VectorT>
        2011 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
        2012 {
        2013  CmpLess comparator;
        2014  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        2015  vector.data(),
        2016  vector.data() + vector.size(),
        2017  value,
        2018  comparator);
        2019  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        2020  {
        2021  size_t indexToRemove = it - vector.begin();
        2022  VmaVectorRemove(vector, indexToRemove);
        2023  return true;
        2024  }
        2025  return false;
        2026 }
        2027 
        2028 template<typename CmpLess, typename VectorT>
        2029 size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)
        2030 {
        2031  CmpLess comparator;
        2032  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        2033  vector.data(),
        2034  vector.data() + vector.size(),
        2035  value,
        2036  comparator);
        2037  if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))
        2038  {
        2039  return it - vector.begin();
        2040  }
        2041  else
        2042  {
        2043  return vector.size();
        2044  }
        2045 }
        2046 
        2048 // class VmaPoolAllocator
        2049 
        2050 /*
        2051 Allocator for objects of type T using a list of arrays (pools) to speed up
        2052 allocation. Number of elements that can be allocated is not bounded because
        2053 allocator can create multiple blocks.
        2054 */
        2055 template<typename T>
        2056 class VmaPoolAllocator
        2057 {
        2058 public:
        2059  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
        2060  ~VmaPoolAllocator();
        2061  void Clear();
        2062  T* Alloc();
        2063  void Free(T* ptr);
        2064 
        2065 private:
        2066  union Item
        2067  {
        2068  uint32_t NextFreeIndex;
        2069  T Value;
        2070  };
        2071 
        2072  struct ItemBlock
        2073  {
        2074  Item* pItems;
        2075  uint32_t FirstFreeIndex;
        2076  };
        2077 
        2078  const VkAllocationCallbacks* m_pAllocationCallbacks;
        2079  size_t m_ItemsPerBlock;
        2080  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
        2081 
        2082  ItemBlock& CreateNewBlock();
        2083 };
        2084 
        2085 template<typename T>
        2086 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
        2087  m_pAllocationCallbacks(pAllocationCallbacks),
        2088  m_ItemsPerBlock(itemsPerBlock),
        2089  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
        2090 {
        2091  VMA_ASSERT(itemsPerBlock > 0);
        2092 }
        2093 
        2094 template<typename T>
        2095 VmaPoolAllocator<T>::~VmaPoolAllocator()
        2096 {
        2097  Clear();
        2098 }
        2099 
        2100 template<typename T>
        2101 void VmaPoolAllocator<T>::Clear()
        2102 {
        2103  for(size_t i = m_ItemBlocks.size(); i--; )
        2104  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
        2105  m_ItemBlocks.clear();
        2106 }
        2107 
        2108 template<typename T>
        2109 T* VmaPoolAllocator<T>::Alloc()
        2110 {
        2111  for(size_t i = m_ItemBlocks.size(); i--; )
        2112  {
        2113  ItemBlock& block = m_ItemBlocks[i];
        2114  // This block has some free items: Use first one.
        2115  if(block.FirstFreeIndex != UINT32_MAX)
        2116  {
        2117  Item* const pItem = &block.pItems[block.FirstFreeIndex];
        2118  block.FirstFreeIndex = pItem->NextFreeIndex;
        2119  return &pItem->Value;
        2120  }
        2121  }
        2122 
        2123  // No block has free item: Create new one and use it.
        2124  ItemBlock& newBlock = CreateNewBlock();
        2125  Item* const pItem = &newBlock.pItems[0];
        2126  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
        2127  return &pItem->Value;
        2128 }
        2129 
        2130 template<typename T>
        2131 void VmaPoolAllocator<T>::Free(T* ptr)
        2132 {
        2133  // Search all memory blocks to find ptr.
        2134  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
        2135  {
        2136  ItemBlock& block = m_ItemBlocks[i];
        2137 
        2138  // Casting to union.
        2139  Item* pItemPtr;
        2140  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
        2141 
        2142  // Check if pItemPtr is in address range of this block.
        2143  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
        2144  {
        2145  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
        2146  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
        2147  block.FirstFreeIndex = index;
        2148  return;
        2149  }
        2150  }
        2151  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
        2152 }
        2153 
        2154 template<typename T>
        2155 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
        2156 {
        2157  ItemBlock newBlock = {
        2158  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
        2159 
        2160  m_ItemBlocks.push_back(newBlock);
        2161 
        2162  // Setup singly-linked list of all free items in this block.
        2163  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
        2164  newBlock.pItems[i].NextFreeIndex = i + 1;
        2165  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
        2166  return m_ItemBlocks.back();
        2167 }
        2168 
        2170 // class VmaRawList, VmaList
        2171 
        2172 #if VMA_USE_STL_LIST
        2173 
        2174 #define VmaList std::list
        2175 
        2176 #else // #if VMA_USE_STL_LIST
        2177 
        2178 template<typename T>
        2179 struct VmaListItem
        2180 {
        2181  VmaListItem* pPrev;
        2182  VmaListItem* pNext;
        2183  T Value;
        2184 };
        2185 
        2186 // Doubly linked list.
        2187 template<typename T>
        2188 class VmaRawList
        2189 {
        2190 public:
        2191  typedef VmaListItem<T> ItemType;
        2192 
        2193  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
        2194  ~VmaRawList();
        2195  void Clear();
        2196 
        2197  size_t GetCount() const { return m_Count; }
        2198  bool IsEmpty() const { return m_Count == 0; }
        2199 
        2200  ItemType* Front() { return m_pFront; }
        2201  const ItemType* Front() const { return m_pFront; }
        2202  ItemType* Back() { return m_pBack; }
        2203  const ItemType* Back() const { return m_pBack; }
        2204 
        2205  ItemType* PushBack();
        2206  ItemType* PushFront();
        2207  ItemType* PushBack(const T& value);
        2208  ItemType* PushFront(const T& value);
        2209  void PopBack();
        2210  void PopFront();
        2211 
        2212  // Item can be null - it means PushBack.
        2213  ItemType* InsertBefore(ItemType* pItem);
        2214  // Item can be null - it means PushFront.
        2215  ItemType* InsertAfter(ItemType* pItem);
        2216 
        2217  ItemType* InsertBefore(ItemType* pItem, const T& value);
        2218  ItemType* InsertAfter(ItemType* pItem, const T& value);
        2219 
        2220  void Remove(ItemType* pItem);
        2221 
        2222 private:
        2223  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        2224  VmaPoolAllocator<ItemType> m_ItemAllocator;
        2225  ItemType* m_pFront;
        2226  ItemType* m_pBack;
        2227  size_t m_Count;
        2228 
        2229  // Declared not defined, to block copy constructor and assignment operator.
        2230  VmaRawList(const VmaRawList<T>& src);
        2231  VmaRawList<T>& operator=(const VmaRawList<T>& rhs);
        2232 };
        2233 
        2234 template<typename T>
        2235 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
        2236  m_pAllocationCallbacks(pAllocationCallbacks),
        2237  m_ItemAllocator(pAllocationCallbacks, 128),
        2238  m_pFront(VMA_NULL),
        2239  m_pBack(VMA_NULL),
        2240  m_Count(0)
        2241 {
        2242 }
        2243 
        2244 template<typename T>
        2245 VmaRawList<T>::~VmaRawList()
        2246 {
        2247  // Intentionally not calling Clear, because that would be unnecessary
        2248  // computations to return all items to m_ItemAllocator as free.
        2249 }
        2250 
        2251 template<typename T>
        2252 void VmaRawList<T>::Clear()
        2253 {
        2254  if(IsEmpty() == false)
        2255  {
        2256  ItemType* pItem = m_pBack;
        2257  while(pItem != VMA_NULL)
        2258  {
        2259  ItemType* const pPrevItem = pItem->pPrev;
        2260  m_ItemAllocator.Free(pItem);
        2261  pItem = pPrevItem;
        2262  }
        2263  m_pFront = VMA_NULL;
        2264  m_pBack = VMA_NULL;
        2265  m_Count = 0;
        2266  }
        2267 }
        2268 
        2269 template<typename T>
        2270 VmaListItem<T>* VmaRawList<T>::PushBack()
        2271 {
        2272  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        2273  pNewItem->pNext = VMA_NULL;
        2274  if(IsEmpty())
        2275  {
        2276  pNewItem->pPrev = VMA_NULL;
        2277  m_pFront = pNewItem;
        2278  m_pBack = pNewItem;
        2279  m_Count = 1;
        2280  }
        2281  else
        2282  {
        2283  pNewItem->pPrev = m_pBack;
        2284  m_pBack->pNext = pNewItem;
        2285  m_pBack = pNewItem;
        2286  ++m_Count;
        2287  }
        2288  return pNewItem;
        2289 }
        2290 
        2291 template<typename T>
        2292 VmaListItem<T>* VmaRawList<T>::PushFront()
        2293 {
        2294  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        2295  pNewItem->pPrev = VMA_NULL;
        2296  if(IsEmpty())
        2297  {
        2298  pNewItem->pNext = VMA_NULL;
        2299  m_pFront = pNewItem;
        2300  m_pBack = pNewItem;
        2301  m_Count = 1;
        2302  }
        2303  else
        2304  {
        2305  pNewItem->pNext = m_pFront;
        2306  m_pFront->pPrev = pNewItem;
        2307  m_pFront = pNewItem;
        2308  ++m_Count;
        2309  }
        2310  return pNewItem;
        2311 }
        2312 
        2313 template<typename T>
        2314 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
        2315 {
        2316  ItemType* const pNewItem = PushBack();
        2317  pNewItem->Value = value;
        2318  return pNewItem;
        2319 }
        2320 
        2321 template<typename T>
        2322 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
        2323 {
        2324  ItemType* const pNewItem = PushFront();
        2325  pNewItem->Value = value;
        2326  return pNewItem;
        2327 }
        2328 
        2329 template<typename T>
        2330 void VmaRawList<T>::PopBack()
        2331 {
        2332  VMA_HEAVY_ASSERT(m_Count > 0);
        2333  ItemType* const pBackItem = m_pBack;
        2334  ItemType* const pPrevItem = pBackItem->pPrev;
        2335  if(pPrevItem != VMA_NULL)
        2336  {
        2337  pPrevItem->pNext = VMA_NULL;
        2338  }
        2339  m_pBack = pPrevItem;
        2340  m_ItemAllocator.Free(pBackItem);
        2341  --m_Count;
        2342 }
        2343 
        2344 template<typename T>
        2345 void VmaRawList<T>::PopFront()
        2346 {
        2347  VMA_HEAVY_ASSERT(m_Count > 0);
        2348  ItemType* const pFrontItem = m_pFront;
        2349  ItemType* const pNextItem = pFrontItem->pNext;
        2350  if(pNextItem != VMA_NULL)
        2351  {
        2352  pNextItem->pPrev = VMA_NULL;
        2353  }
        2354  m_pFront = pNextItem;
        2355  m_ItemAllocator.Free(pFrontItem);
        2356  --m_Count;
        2357 }
        2358 
        2359 template<typename T>
        2360 void VmaRawList<T>::Remove(ItemType* pItem)
        2361 {
        2362  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
        2363  VMA_HEAVY_ASSERT(m_Count > 0);
        2364 
        2365  if(pItem->pPrev != VMA_NULL)
        2366  {
        2367  pItem->pPrev->pNext = pItem->pNext;
        2368  }
        2369  else
        2370  {
        2371  VMA_HEAVY_ASSERT(m_pFront == pItem);
        2372  m_pFront = pItem->pNext;
        2373  }
        2374 
        2375  if(pItem->pNext != VMA_NULL)
        2376  {
        2377  pItem->pNext->pPrev = pItem->pPrev;
        2378  }
        2379  else
        2380  {
        2381  VMA_HEAVY_ASSERT(m_pBack == pItem);
        2382  m_pBack = pItem->pPrev;
        2383  }
        2384 
        2385  m_ItemAllocator.Free(pItem);
        2386  --m_Count;
        2387 }
        2388 
        2389 template<typename T>
        2390 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
        2391 {
        2392  if(pItem != VMA_NULL)
        2393  {
        2394  ItemType* const prevItem = pItem->pPrev;
        2395  ItemType* const newItem = m_ItemAllocator.Alloc();
        2396  newItem->pPrev = prevItem;
        2397  newItem->pNext = pItem;
        2398  pItem->pPrev = newItem;
        2399  if(prevItem != VMA_NULL)
        2400  {
        2401  prevItem->pNext = newItem;
        2402  }
        2403  else
        2404  {
        2405  VMA_HEAVY_ASSERT(m_pFront == pItem);
        2406  m_pFront = newItem;
        2407  }
        2408  ++m_Count;
        2409  return newItem;
        2410  }
        2411  else
        2412  return PushBack();
        2413 }
        2414 
        2415 template<typename T>
        2416 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
        2417 {
        2418  if(pItem != VMA_NULL)
        2419  {
        2420  ItemType* const nextItem = pItem->pNext;
        2421  ItemType* const newItem = m_ItemAllocator.Alloc();
        2422  newItem->pNext = nextItem;
        2423  newItem->pPrev = pItem;
        2424  pItem->pNext = newItem;
        2425  if(nextItem != VMA_NULL)
        2426  {
        2427  nextItem->pPrev = newItem;
        2428  }
        2429  else
        2430  {
        2431  VMA_HEAVY_ASSERT(m_pBack == pItem);
        2432  m_pBack = newItem;
        2433  }
        2434  ++m_Count;
        2435  return newItem;
        2436  }
        2437  else
        2438  return PushFront();
        2439 }
        2440 
        2441 template<typename T>
        2442 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
        2443 {
        2444  ItemType* const newItem = InsertBefore(pItem);
        2445  newItem->Value = value;
        2446  return newItem;
        2447 }
        2448 
        2449 template<typename T>
        2450 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
        2451 {
        2452  ItemType* const newItem = InsertAfter(pItem);
        2453  newItem->Value = value;
        2454  return newItem;
        2455 }
        2456 
        2457 template<typename T, typename AllocatorT>
        2458 class VmaList
        2459 {
        2460 public:
        2461  class iterator
        2462  {
        2463  public:
        2464  iterator() :
        2465  m_pList(VMA_NULL),
        2466  m_pItem(VMA_NULL)
        2467  {
        2468  }
        2469 
        2470  T& operator*() const
        2471  {
        2472  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2473  return m_pItem->Value;
        2474  }
        2475  T* operator->() const
        2476  {
        2477  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2478  return &m_pItem->Value;
        2479  }
        2480 
        2481  iterator& operator++()
        2482  {
        2483  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2484  m_pItem = m_pItem->pNext;
        2485  return *this;
        2486  }
        2487  iterator& operator--()
        2488  {
        2489  if(m_pItem != VMA_NULL)
        2490  {
        2491  m_pItem = m_pItem->pPrev;
        2492  }
        2493  else
        2494  {
        2495  VMA_HEAVY_ASSERT(!m_pList.IsEmpty());
        2496  m_pItem = m_pList->Back();
        2497  }
        2498  return *this;
        2499  }
        2500 
        2501  iterator operator++(int)
        2502  {
        2503  iterator result = *this;
        2504  ++*this;
        2505  return result;
        2506  }
        2507  iterator operator--(int)
        2508  {
        2509  iterator result = *this;
        2510  --*this;
        2511  return result;
        2512  }
        2513 
        2514  bool operator==(const iterator& rhs) const
        2515  {
        2516  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2517  return m_pItem == rhs.m_pItem;
        2518  }
        2519  bool operator!=(const iterator& rhs) const
        2520  {
        2521  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2522  return m_pItem != rhs.m_pItem;
        2523  }
        2524 
        2525  private:
        2526  VmaRawList<T>* m_pList;
        2527  VmaListItem<T>* m_pItem;
        2528 
        2529  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
        2530  m_pList(pList),
        2531  m_pItem(pItem)
        2532  {
        2533  }
        2534 
        2535  friend class VmaList<T, AllocatorT>;
        2536  };
        2537 
        2538  class const_iterator
        2539  {
        2540  public:
        2541  const_iterator() :
        2542  m_pList(VMA_NULL),
        2543  m_pItem(VMA_NULL)
        2544  {
        2545  }
        2546 
        2547  const_iterator(const iterator& src) :
        2548  m_pList(src.m_pList),
        2549  m_pItem(src.m_pItem)
        2550  {
        2551  }
        2552 
        2553  const T& operator*() const
        2554  {
        2555  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2556  return m_pItem->Value;
        2557  }
        2558  const T* operator->() const
        2559  {
        2560  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2561  return &m_pItem->Value;
        2562  }
        2563 
        2564  const_iterator& operator++()
        2565  {
        2566  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        2567  m_pItem = m_pItem->pNext;
        2568  return *this;
        2569  }
        2570  const_iterator& operator--()
        2571  {
        2572  if(m_pItem != VMA_NULL)
        2573  {
        2574  m_pItem = m_pItem->pPrev;
        2575  }
        2576  else
        2577  {
        2578  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        2579  m_pItem = m_pList->Back();
        2580  }
        2581  return *this;
        2582  }
        2583 
        2584  const_iterator operator++(int)
        2585  {
        2586  const_iterator result = *this;
        2587  ++*this;
        2588  return result;
        2589  }
        2590  const_iterator operator--(int)
        2591  {
        2592  const_iterator result = *this;
        2593  --*this;
        2594  return result;
        2595  }
        2596 
        2597  bool operator==(const const_iterator& rhs) const
        2598  {
        2599  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2600  return m_pItem == rhs.m_pItem;
        2601  }
        2602  bool operator!=(const const_iterator& rhs) const
        2603  {
        2604  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        2605  return m_pItem != rhs.m_pItem;
        2606  }
        2607 
        2608  private:
        2609  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
        2610  m_pList(pList),
        2611  m_pItem(pItem)
        2612  {
        2613  }
        2614 
        2615  const VmaRawList<T>* m_pList;
        2616  const VmaListItem<T>* m_pItem;
        2617 
        2618  friend class VmaList<T, AllocatorT>;
        2619  };
        2620 
        2621  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
        2622 
        2623  bool empty() const { return m_RawList.IsEmpty(); }
        2624  size_t size() const { return m_RawList.GetCount(); }
        2625 
        2626  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
        2627  iterator end() { return iterator(&m_RawList, VMA_NULL); }
        2628 
        2629  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
        2630  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
        2631 
        2632  void clear() { m_RawList.Clear(); }
        2633  void push_back(const T& value) { m_RawList.PushBack(value); }
        2634  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
        2635  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
        2636 
        2637 private:
        2638  VmaRawList<T> m_RawList;
        2639 };
        2640 
        2641 #endif // #if VMA_USE_STL_LIST
        2642 
        2644 // class VmaMap
        2645 
        2646 // Unused in this version.
        2647 #if 0
        2648 
        2649 #if VMA_USE_STL_UNORDERED_MAP
        2650 
        2651 #define VmaPair std::pair
        2652 
        2653 #define VMA_MAP_TYPE(KeyT, ValueT) \
        2654  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
        2655 
        2656 #else // #if VMA_USE_STL_UNORDERED_MAP
        2657 
        2658 template<typename T1, typename T2>
        2659 struct VmaPair
        2660 {
        2661  T1 first;
        2662  T2 second;
        2663 
        2664  VmaPair() : first(), second() { }
        2665  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
        2666 };
        2667 
        2668 /* Class compatible with subset of interface of std::unordered_map.
        2669 KeyT, ValueT must be POD because they will be stored in VmaVector.
        2670 */
        2671 template<typename KeyT, typename ValueT>
        2672 class VmaMap
        2673 {
        2674 public:
        2675  typedef VmaPair<KeyT, ValueT> PairType;
        2676  typedef PairType* iterator;
        2677 
        2678  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
        2679 
        2680  iterator begin() { return m_Vector.begin(); }
        2681  iterator end() { return m_Vector.end(); }
        2682 
        2683  void insert(const PairType& pair);
        2684  iterator find(const KeyT& key);
        2685  void erase(iterator it);
        2686 
        2687 private:
        2688  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
        2689 };
        2690 
        2691 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
        2692 
        2693 template<typename FirstT, typename SecondT>
        2694 struct VmaPairFirstLess
        2695 {
        2696  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
        2697  {
        2698  return lhs.first < rhs.first;
        2699  }
        2700  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
        2701  {
        2702  return lhs.first < rhsFirst;
        2703  }
        2704 };
        2705 
        2706 template<typename KeyT, typename ValueT>
        2707 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
        2708 {
        2709  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        2710  m_Vector.data(),
        2711  m_Vector.data() + m_Vector.size(),
        2712  pair,
        2713  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
        2714  VmaVectorInsert(m_Vector, indexToInsert, pair);
        2715 }
        2716 
        2717 template<typename KeyT, typename ValueT>
        2718 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
        2719 {
        2720  PairType* it = VmaBinaryFindFirstNotLess(
        2721  m_Vector.data(),
        2722  m_Vector.data() + m_Vector.size(),
        2723  key,
        2724  VmaPairFirstLess<KeyT, ValueT>());
        2725  if((it != m_Vector.end()) && (it->first == key))
        2726  {
        2727  return it;
        2728  }
        2729  else
        2730  {
        2731  return m_Vector.end();
        2732  }
        2733 }
        2734 
        2735 template<typename KeyT, typename ValueT>
        2736 void VmaMap<KeyT, ValueT>::erase(iterator it)
        2737 {
        2738  VmaVectorRemove(m_Vector, it - m_Vector.begin());
        2739 }
        2740 
        2741 #endif // #if VMA_USE_STL_UNORDERED_MAP
        2742 
        2743 #endif // #if 0
        2744 
        2746 
        2747 class VmaDeviceMemoryBlock;
        2748 
        2749 enum VMA_BLOCK_VECTOR_TYPE
        2750 {
        2751  VMA_BLOCK_VECTOR_TYPE_UNMAPPED,
        2752  VMA_BLOCK_VECTOR_TYPE_MAPPED,
        2753  VMA_BLOCK_VECTOR_TYPE_COUNT
        2754 };
        2755 
        2756 static VMA_BLOCK_VECTOR_TYPE VmaAllocationCreateFlagsToBlockVectorType(VmaAllocationCreateFlags flags)
        2757 {
        2758  return (flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0 ?
        2759  VMA_BLOCK_VECTOR_TYPE_MAPPED :
        2760  VMA_BLOCK_VECTOR_TYPE_UNMAPPED;
        2761 }
        2762 
        2763 struct VmaAllocation_T
        2764 {
        2765 public:
        2766  enum ALLOCATION_TYPE
        2767  {
        2768  ALLOCATION_TYPE_NONE,
        2769  ALLOCATION_TYPE_BLOCK,
        2770  ALLOCATION_TYPE_OWN,
        2771  };
        2772 
        2773  VmaAllocation_T(uint32_t currentFrameIndex) :
        2774  m_Alignment(1),
        2775  m_Size(0),
        2776  m_pUserData(VMA_NULL),
        2777  m_Type(ALLOCATION_TYPE_NONE),
        2778  m_SuballocationType(VMA_SUBALLOCATION_TYPE_UNKNOWN),
        2779  m_LastUseFrameIndex(currentFrameIndex)
        2780  {
        2781  }
        2782 
        2783  void InitBlockAllocation(
        2784  VmaPool hPool,
        2785  VmaDeviceMemoryBlock* block,
        2786  VkDeviceSize offset,
        2787  VkDeviceSize alignment,
        2788  VkDeviceSize size,
        2789  VmaSuballocationType suballocationType,
        2790  void* pUserData,
        2791  bool canBecomeLost)
        2792  {
        2793  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        2794  VMA_ASSERT(block != VMA_NULL);
        2795  m_Type = ALLOCATION_TYPE_BLOCK;
        2796  m_Alignment = alignment;
        2797  m_Size = size;
        2798  m_pUserData = pUserData;
        2799  m_SuballocationType = suballocationType;
        2800  m_BlockAllocation.m_hPool = hPool;
        2801  m_BlockAllocation.m_Block = block;
        2802  m_BlockAllocation.m_Offset = offset;
        2803  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
        2804  }
        2805 
        2806  void InitLost()
        2807  {
        2808  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        2809  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
        2810  m_Type = ALLOCATION_TYPE_BLOCK;
        2811  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
        2812  m_BlockAllocation.m_Block = VMA_NULL;
        2813  m_BlockAllocation.m_Offset = 0;
        2814  m_BlockAllocation.m_CanBecomeLost = true;
        2815  }
        2816 
        2817  void ChangeBlockAllocation(
        2818  VmaDeviceMemoryBlock* block,
        2819  VkDeviceSize offset)
        2820  {
        2821  VMA_ASSERT(block != VMA_NULL);
        2822  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        2823  m_BlockAllocation.m_Block = block;
        2824  m_BlockAllocation.m_Offset = offset;
        2825  }
        2826 
        2827  void InitOwnAllocation(
        2828  uint32_t memoryTypeIndex,
        2829  VkDeviceMemory hMemory,
        2830  VmaSuballocationType suballocationType,
        2831  bool persistentMap,
        2832  void* pMappedData,
        2833  VkDeviceSize size,
        2834  void* pUserData)
        2835  {
        2836  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        2837  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
        2838  m_Type = ALLOCATION_TYPE_OWN;
        2839  m_Alignment = 0;
        2840  m_Size = size;
        2841  m_pUserData = pUserData;
        2842  m_SuballocationType = suballocationType;
        2843  m_OwnAllocation.m_MemoryTypeIndex = memoryTypeIndex;
        2844  m_OwnAllocation.m_hMemory = hMemory;
        2845  m_OwnAllocation.m_PersistentMap = persistentMap;
        2846  m_OwnAllocation.m_pMappedData = pMappedData;
        2847  }
        2848 
        2849  ALLOCATION_TYPE GetType() const { return m_Type; }
        2850  VkDeviceSize GetAlignment() const { return m_Alignment; }
        2851  VkDeviceSize GetSize() const { return m_Size; }
        2852  void* GetUserData() const { return m_pUserData; }
        2853  void SetUserData(void* pUserData) { m_pUserData = pUserData; }
        2854  VmaSuballocationType GetSuballocationType() const { return m_SuballocationType; }
        2855 
        2856  VmaDeviceMemoryBlock* GetBlock() const
        2857  {
        2858  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        2859  return m_BlockAllocation.m_Block;
        2860  }
        2861  VkDeviceSize GetOffset() const;
        2862  VkDeviceMemory GetMemory() const;
        2863  uint32_t GetMemoryTypeIndex() const;
        2864  VMA_BLOCK_VECTOR_TYPE GetBlockVectorType() const;
        2865  void* GetMappedData() const;
        2866  bool CanBecomeLost() const;
        2867  VmaPool GetPool() const;
        2868 
        2869  VkResult OwnAllocMapPersistentlyMappedMemory(VkDevice hDevice)
        2870  {
        2871  VMA_ASSERT(m_Type == ALLOCATION_TYPE_OWN);
        2872  if(m_OwnAllocation.m_PersistentMap)
        2873  {
        2874  return vkMapMemory(hDevice, m_OwnAllocation.m_hMemory, 0, VK_WHOLE_SIZE, 0, &m_OwnAllocation.m_pMappedData);
        2875  }
        2876  return VK_SUCCESS;
        2877  }
        2878  void OwnAllocUnmapPersistentlyMappedMemory(VkDevice hDevice)
        2879  {
        2880  VMA_ASSERT(m_Type == ALLOCATION_TYPE_OWN);
        2881  if(m_OwnAllocation.m_pMappedData)
        2882  {
        2883  VMA_ASSERT(m_OwnAllocation.m_PersistentMap);
        2884  vkUnmapMemory(hDevice, m_OwnAllocation.m_hMemory);
        2885  m_OwnAllocation.m_pMappedData = VMA_NULL;
        2886  }
        2887  }
        2888 
        2889  uint32_t GetLastUseFrameIndex() const
        2890  {
        2891  return m_LastUseFrameIndex.load();
        2892  }
        2893  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
        2894  {
        2895  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
        2896  }
        2897  /*
        2898  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
        2899  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
        2900  - Else, returns false.
        2901 
        2902  If hAllocation is already lost, assert - you should not call it then.
        2903  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
        2904  */
        2905  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        2906 
        2907  void OwnAllocCalcStatsInfo(VmaStatInfo& outInfo)
        2908  {
        2909  VMA_ASSERT(m_Type == ALLOCATION_TYPE_OWN);
        2910  outInfo.BlockCount = 1;
        2911  outInfo.AllocationCount = 1;
        2912  outInfo.UnusedRangeCount = 0;
        2913  outInfo.UsedBytes = m_Size;
        2914  outInfo.UnusedBytes = 0;
        2915  outInfo.AllocationSizeMin = outInfo.AllocationSizeMax = m_Size;
        2916  outInfo.UnusedRangeSizeMin = UINT64_MAX;
        2917  outInfo.UnusedRangeSizeMax = 0;
        2918  }
        2919 
        2920 private:
        2921  VkDeviceSize m_Alignment;
        2922  VkDeviceSize m_Size;
        2923  void* m_pUserData;
        2924  ALLOCATION_TYPE m_Type;
        2925  VmaSuballocationType m_SuballocationType;
        2926  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
        2927 
        2928  // Allocation out of VmaDeviceMemoryBlock.
        2929  struct BlockAllocation
        2930  {
        2931  VmaPool m_hPool; // Null if belongs to general memory.
        2932  VmaDeviceMemoryBlock* m_Block;
        2933  VkDeviceSize m_Offset;
        2934  bool m_CanBecomeLost;
        2935  };
        2936 
        2937  // Allocation for an object that has its own private VkDeviceMemory.
        2938  struct OwnAllocation
        2939  {
        2940  uint32_t m_MemoryTypeIndex;
        2941  VkDeviceMemory m_hMemory;
        2942  bool m_PersistentMap;
        2943  void* m_pMappedData;
        2944  };
        2945 
        2946  union
        2947  {
        2948  // Allocation out of VmaDeviceMemoryBlock.
        2949  BlockAllocation m_BlockAllocation;
        2950  // Allocation for an object that has its own private VkDeviceMemory.
        2951  OwnAllocation m_OwnAllocation;
        2952  };
        2953 };
        2954 
        2955 /*
        2956 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
        2957 allocated memory block or free.
        2958 */
        2959 struct VmaSuballocation
        2960 {
        2961  VkDeviceSize offset;
        2962  VkDeviceSize size;
        2963  VmaAllocation hAllocation;
        2964  VmaSuballocationType type;
        2965 };
        2966 
        2967 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
        2968 
        2969 // Cost of one additional allocation lost, as equivalent in bytes.
        2970 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
        2971 
        2972 /*
        2973 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
        2974 
        2975 If canMakeOtherLost was false:
        2976 - item points to a FREE suballocation.
        2977 - itemsToMakeLostCount is 0.
        2978 
        2979 If canMakeOtherLost was true:
        2980 - item points to first of sequence of suballocations, which are either FREE,
        2981  or point to VmaAllocations that can become lost.
        2982 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
        2983  the requested allocation to succeed.
        2984 */
        2985 struct VmaAllocationRequest
        2986 {
        2987  VkDeviceSize offset;
        2988  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
        2989  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
        2990  VmaSuballocationList::iterator item;
        2991  size_t itemsToMakeLostCount;
        2992 
        2993  VkDeviceSize CalcCost() const
        2994  {
        2995  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
        2996  }
        2997 };
        2998 
        2999 /*
        3000 Represents a single block of device memory (VkDeviceMemory ) with all the
        3001 data about its regions (aka suballocations, VmaAllocation), assigned and free.
        3002 
        3003 Thread-safety: This class must be externally synchronized.
        3004 */
        3005 class VmaDeviceMemoryBlock
        3006 {
        3007 public:
        3008  uint32_t m_MemoryTypeIndex;
        3009  VMA_BLOCK_VECTOR_TYPE m_BlockVectorType;
        3010  VkDeviceMemory m_hMemory;
        3011  VkDeviceSize m_Size;
        3012  bool m_PersistentMap;
        3013  void* m_pMappedData;
        3014  uint32_t m_FreeCount;
        3015  VkDeviceSize m_SumFreeSize;
        3016  VmaSuballocationList m_Suballocations;
        3017  // Suballocations that are free and have size greater than certain threshold.
        3018  // Sorted by size, ascending.
        3019  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
        3020 
        3021  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
        3022 
        3023  ~VmaDeviceMemoryBlock()
        3024  {
        3025  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        3026  }
        3027 
        3028  // Always call after construction.
        3029  void Init(
        3030  uint32_t newMemoryTypeIndex,
        3031  VMA_BLOCK_VECTOR_TYPE newBlockVectorType,
        3032  VkDeviceMemory newMemory,
        3033  VkDeviceSize newSize,
        3034  bool persistentMap,
        3035  void* pMappedData);
        3036  // Always call before destruction.
        3037  void Destroy(VmaAllocator allocator);
        3038 
        3039  // Validates all data structures inside this object. If not valid, returns false.
        3040  bool Validate() const;
        3041 
        3042  // Tries to find a place for suballocation with given parameters inside this allocation.
        3043  // If succeeded, fills pAllocationRequest and returns true.
        3044  // If failed, returns false.
        3045  bool CreateAllocationRequest(
        3046  uint32_t currentFrameIndex,
        3047  uint32_t frameInUseCount,
        3048  VkDeviceSize bufferImageGranularity,
        3049  VkDeviceSize allocSize,
        3050  VkDeviceSize allocAlignment,
        3051  VmaSuballocationType allocType,
        3052  bool canMakeOtherLost,
        3053  VmaAllocationRequest* pAllocationRequest);
        3054 
        3055  bool MakeRequestedAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount, VmaAllocationRequest* pAllocationRequest);
        3056 
        3057  uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        3058 
        3059  // Returns true if this allocation is empty - contains only single free suballocation.
        3060  bool IsEmpty() const;
        3061 
        3062  // Makes actual allocation based on request. Request must already be checked
        3063  // and valid.
        3064  void Alloc(
        3065  const VmaAllocationRequest& request,
        3066  VmaSuballocationType type,
        3067  VkDeviceSize allocSize,
        3068  VmaAllocation hAllocation);
        3069 
        3070  // Frees suballocation assigned to given memory region.
        3071  void Free(const VmaAllocation allocation);
        3072 
        3073 #if VMA_STATS_STRING_ENABLED
        3074  void PrintDetailedMap(class VmaJsonWriter& json) const;
        3075 #endif
        3076 
        3077 private:
        3078  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
        3079  // If yes, fills pOffset and returns true. If no, returns false.
        3080  bool CheckAllocation(
        3081  uint32_t currentFrameIndex,
        3082  uint32_t frameInUseCount,
        3083  VkDeviceSize bufferImageGranularity,
        3084  VkDeviceSize allocSize,
        3085  VkDeviceSize allocAlignment,
        3086  VmaSuballocationType allocType,
        3087  VmaSuballocationList::const_iterator suballocItem,
        3088  bool canMakeOtherLost,
        3089  VkDeviceSize* pOffset,
        3090  size_t* itemsToMakeLostCount,
        3091  VkDeviceSize* pSumFreeSize,
        3092  VkDeviceSize* pSumItemSize) const;
        3093 
        3094  // Given free suballocation, it merges it with following one, which must also be free.
        3095  void MergeFreeWithNext(VmaSuballocationList::iterator item);
        3096  // Releases given suballocation, making it free.
        3097  // Merges it with adjacent free suballocations if applicable.
        3098  // Returns iterator to new free suballocation at this place.
        3099  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
        3100  // Given free suballocation, it inserts it into sorted list of
        3101  // m_FreeSuballocationsBySize if it's suitable.
        3102  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
        3103  // Given free suballocation, it removes it from sorted list of
        3104  // m_FreeSuballocationsBySize if it's suitable.
        3105  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
        3106 
        3107  bool ValidateFreeSuballocationList() const;
        3108 };
        3109 
        3110 struct VmaPointerLess
        3111 {
        3112  bool operator()(const void* lhs, const void* rhs) const
        3113  {
        3114  return lhs < rhs;
        3115  }
        3116 };
        3117 
        3118 class VmaDefragmentator;
        3119 
        3120 /*
        3121 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
        3122 Vulkan memory type.
        3123 
        3124 Synchronized internally with a mutex.
        3125 */
        3126 struct VmaBlockVector
        3127 {
        3128  VmaBlockVector(
        3129  VmaAllocator hAllocator,
        3130  uint32_t memoryTypeIndex,
        3131  VMA_BLOCK_VECTOR_TYPE blockVectorType,
        3132  VkDeviceSize preferredBlockSize,
        3133  size_t minBlockCount,
        3134  size_t maxBlockCount,
        3135  VkDeviceSize bufferImageGranularity,
        3136  uint32_t frameInUseCount,
        3137  bool isCustomPool);
        3138  ~VmaBlockVector();
        3139 
        3140  VkResult CreateMinBlocks();
        3141 
        3142  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        3143  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
        3144  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
        3145  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
        3146  VMA_BLOCK_VECTOR_TYPE GetBlockVectorType() const { return m_BlockVectorType; }
        3147 
        3148  void GetPoolStats(VmaPoolStats* pStats);
        3149 
        3150  bool IsEmpty() const { return m_Blocks.empty(); }
        3151 
        3152  VkResult Allocate(
        3153  VmaPool hCurrentPool,
        3154  uint32_t currentFrameIndex,
        3155  const VkMemoryRequirements& vkMemReq,
        3156  const VmaAllocationCreateInfo& createInfo,
        3157  VmaSuballocationType suballocType,
        3158  VmaAllocation* pAllocation);
        3159 
        3160  void Free(
        3161  VmaAllocation hAllocation);
        3162 
        3163  // Adds statistics of this BlockVector to pStats.
        3164  void AddStats(VmaStats* pStats);
        3165 
        3166 #if VMA_STATS_STRING_ENABLED
        3167  void PrintDetailedMap(class VmaJsonWriter& json);
        3168 #endif
        3169 
        3170  void UnmapPersistentlyMappedMemory();
        3171  VkResult MapPersistentlyMappedMemory();
        3172 
        3173  void MakePoolAllocationsLost(
        3174  uint32_t currentFrameIndex,
        3175  size_t* pLostAllocationCount);
        3176 
        3177  VmaDefragmentator* EnsureDefragmentator(
        3178  VkDevice hDevice,
        3179  const VkAllocationCallbacks* pAllocationCallbacks,
        3180  uint32_t currentFrameIndex);
        3181 
        3182  VkResult Defragment(
        3183  VmaDefragmentationStats* pDefragmentationStats,
        3184  VkDeviceSize& maxBytesToMove,
        3185  uint32_t& maxAllocationsToMove);
        3186 
        3187  void DestroyDefragmentator();
        3188 
        3189 private:
        3190  friend class VmaDefragmentator;
        3191 
        3192  const VmaAllocator m_hAllocator;
        3193  const uint32_t m_MemoryTypeIndex;
        3194  const VMA_BLOCK_VECTOR_TYPE m_BlockVectorType;
        3195  const VkDeviceSize m_PreferredBlockSize;
        3196  const size_t m_MinBlockCount;
        3197  const size_t m_MaxBlockCount;
        3198  const VkDeviceSize m_BufferImageGranularity;
        3199  const uint32_t m_FrameInUseCount;
        3200  const bool m_IsCustomPool;
        3201  VMA_MUTEX m_Mutex;
        3202  // Incrementally sorted by sumFreeSize, ascending.
        3203  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
        3204  /* There can be at most one allocation that is completely empty - a
        3205  hysteresis to avoid pessimistic case of alternating creation and destruction
        3206  of a VkDeviceMemory. */
        3207  bool m_HasEmptyBlock;
        3208  VmaDefragmentator* m_pDefragmentator;
        3209 
        3210  // Finds and removes given block from vector.
        3211  void Remove(VmaDeviceMemoryBlock* pBlock);
        3212 
        3213  // Performs single step in sorting m_Blocks. They may not be fully sorted
        3214  // after this call.
        3215  void IncrementallySortBlocks();
        3216 
        3217  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
        3218 };
        3219 
        3220 struct VmaPool_T
        3221 {
        3222 public:
        3223  VmaBlockVector m_BlockVector;
        3224 
        3225  // Takes ownership.
        3226  VmaPool_T(
        3227  VmaAllocator hAllocator,
        3228  const VmaPoolCreateInfo& createInfo);
        3229  ~VmaPool_T();
        3230 
        3231  VmaBlockVector& GetBlockVector() { return m_BlockVector; }
        3232 
        3233 #if VMA_STATS_STRING_ENABLED
        3234  //void PrintDetailedMap(class VmaStringBuilder& sb);
        3235 #endif
        3236 };
        3237 
        3238 class VmaDefragmentator
        3239 {
        3240  const VkDevice m_hDevice;
        3241  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        3242  VmaBlockVector* const m_pBlockVector;
        3243  uint32_t m_CurrentFrameIndex;
        3244  VMA_BLOCK_VECTOR_TYPE m_BlockVectorType;
        3245  VkDeviceSize m_BytesMoved;
        3246  uint32_t m_AllocationsMoved;
        3247 
        3248  struct AllocationInfo
        3249  {
        3250  VmaAllocation m_hAllocation;
        3251  VkBool32* m_pChanged;
        3252 
        3253  AllocationInfo() :
        3254  m_hAllocation(VK_NULL_HANDLE),
        3255  m_pChanged(VMA_NULL)
        3256  {
        3257  }
        3258  };
        3259 
        3260  struct AllocationInfoSizeGreater
        3261  {
        3262  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        3263  {
        3264  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
        3265  }
        3266  };
        3267 
        3268  // Used between AddAllocation and Defragment.
        3269  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        3270 
        3271  struct BlockInfo
        3272  {
        3273  VmaDeviceMemoryBlock* m_pBlock;
        3274  bool m_HasNonMovableAllocations;
        3275  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        3276 
        3277  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
        3278  m_pBlock(VMA_NULL),
        3279  m_HasNonMovableAllocations(true),
        3280  m_Allocations(pAllocationCallbacks),
        3281  m_pMappedDataForDefragmentation(VMA_NULL)
        3282  {
        3283  }
        3284 
        3285  void CalcHasNonMovableAllocations()
        3286  {
        3287  const size_t blockAllocCount =
        3288  m_pBlock->m_Suballocations.size() - m_pBlock->m_FreeCount;
        3289  const size_t defragmentAllocCount = m_Allocations.size();
        3290  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
        3291  }
        3292 
        3293  void SortAllocationsBySizeDescecnding()
        3294  {
        3295  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
        3296  }
        3297 
        3298  VkResult EnsureMapping(VkDevice hDevice, void** ppMappedData)
        3299  {
        3300  // It has already been mapped for defragmentation.
        3301  if(m_pMappedDataForDefragmentation)
        3302  {
        3303  *ppMappedData = m_pMappedDataForDefragmentation;
        3304  return VK_SUCCESS;
        3305  }
        3306 
        3307  // It is persistently mapped.
        3308  if(m_pBlock->m_PersistentMap)
        3309  {
        3310  VMA_ASSERT(m_pBlock->m_pMappedData != VMA_NULL);
        3311  *ppMappedData = m_pBlock->m_pMappedData;
        3312  return VK_SUCCESS;
        3313  }
        3314 
        3315  // Map on first usage.
        3316  VkResult res = vkMapMemory(hDevice, m_pBlock->m_hMemory, 0, VK_WHOLE_SIZE, 0, &m_pMappedDataForDefragmentation);
        3317  *ppMappedData = m_pMappedDataForDefragmentation;
        3318  return res;
        3319  }
        3320 
        3321  void Unmap(VkDevice hDevice)
        3322  {
        3323  if(m_pMappedDataForDefragmentation != VMA_NULL)
        3324  {
        3325  vkUnmapMemory(hDevice, m_pBlock->m_hMemory);
        3326  }
        3327  }
        3328 
        3329  private:
        3330  // Not null if mapped for defragmentation only, not persistently mapped.
        3331  void* m_pMappedDataForDefragmentation;
        3332  };
        3333 
        3334  struct BlockPointerLess
        3335  {
        3336  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
        3337  {
        3338  return pLhsBlockInfo->m_pBlock < pRhsBlock;
        3339  }
        3340  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        3341  {
        3342  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
        3343  }
        3344  };
        3345 
        3346  // 1. Blocks with some non-movable allocations go first.
        3347  // 2. Blocks with smaller sumFreeSize go first.
        3348  struct BlockInfoCompareMoveDestination
        3349  {
        3350  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        3351  {
        3352  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
        3353  {
        3354  return true;
        3355  }
        3356  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
        3357  {
        3358  return false;
        3359  }
        3360  if(pLhsBlockInfo->m_pBlock->m_SumFreeSize < pRhsBlockInfo->m_pBlock->m_SumFreeSize)
        3361  {
        3362  return true;
        3363  }
        3364  return false;
        3365  }
        3366  };
        3367 
        3368  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
        3369  BlockInfoVector m_Blocks;
        3370 
        3371  VkResult DefragmentRound(
        3372  VkDeviceSize maxBytesToMove,
        3373  uint32_t maxAllocationsToMove);
        3374 
        3375  static bool MoveMakesSense(
        3376  size_t dstBlockIndex, VkDeviceSize dstOffset,
        3377  size_t srcBlockIndex, VkDeviceSize srcOffset);
        3378 
        3379 public:
        3380  VmaDefragmentator(
        3381  VkDevice hDevice,
        3382  const VkAllocationCallbacks* pAllocationCallbacks,
        3383  VmaBlockVector* pBlockVector,
        3384  uint32_t currentFrameIndex);
        3385 
        3386  ~VmaDefragmentator();
        3387 
        3388  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        3389  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        3390 
        3391  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        3392 
        3393  VkResult Defragment(
        3394  VkDeviceSize maxBytesToMove,
        3395  uint32_t maxAllocationsToMove);
        3396 };
        3397 
        3398 // Main allocator object.
        3399 struct VmaAllocator_T
        3400 {
        3401  bool m_UseMutex;
        3402  VkDevice m_hDevice;
        3403  bool m_AllocationCallbacksSpecified;
        3404  VkAllocationCallbacks m_AllocationCallbacks;
        3405  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
        3406  // Non-zero when we are inside UnmapPersistentlyMappedMemory...MapPersistentlyMappedMemory.
        3407  // Counter to allow nested calls to these functions.
        3408  uint32_t m_UnmapPersistentlyMappedMemoryCounter;
        3409 
        3410  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
        3411  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
        3412  VMA_MUTEX m_HeapSizeLimitMutex;
        3413 
        3414  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
        3415  VkPhysicalDeviceMemoryProperties m_MemProps;
        3416 
        3417  // Default pools.
        3418  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES][VMA_BLOCK_VECTOR_TYPE_COUNT];
        3419 
        3420  // Each vector is sorted by memory (handle value).
        3421  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
        3422  AllocationVectorType* m_pOwnAllocations[VK_MAX_MEMORY_TYPES][VMA_BLOCK_VECTOR_TYPE_COUNT];
        3423  VMA_MUTEX m_OwnAllocationsMutex[VK_MAX_MEMORY_TYPES];
        3424 
        3425  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
        3426  ~VmaAllocator_T();
        3427 
        3428  const VkAllocationCallbacks* GetAllocationCallbacks() const
        3429  {
        3430  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        3431  }
        3432 
        3433  VkDeviceSize GetBufferImageGranularity() const
        3434  {
        3435  return VMA_MAX(
        3436  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
        3437  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        3438  }
        3439 
        3440  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
        3441  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
        3442 
        3443  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
        3444  {
        3445  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
        3446  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        3447  }
        3448 
        3449  // Main allocation function.
        3450  VkResult AllocateMemory(
        3451  const VkMemoryRequirements& vkMemReq,
        3452  const VmaAllocationCreateInfo& createInfo,
        3453  VmaSuballocationType suballocType,
        3454  VmaAllocation* pAllocation);
        3455 
        3456  // Main deallocation function.
        3457  void FreeMemory(const VmaAllocation allocation);
        3458 
        3459  void CalculateStats(VmaStats* pStats);
        3460 
        3461 #if VMA_STATS_STRING_ENABLED
        3462  void PrintDetailedMap(class VmaJsonWriter& json);
        3463 #endif
        3464 
        3465  void UnmapPersistentlyMappedMemory();
        3466  VkResult MapPersistentlyMappedMemory();
        3467 
        3468  VkResult Defragment(
        3469  VmaAllocation* pAllocations,
        3470  size_t allocationCount,
        3471  VkBool32* pAllocationsChanged,
        3472  const VmaDefragmentationInfo* pDefragmentationInfo,
        3473  VmaDefragmentationStats* pDefragmentationStats);
        3474 
        3475  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
        3476 
        3477  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
        3478  void DestroyPool(VmaPool pool);
        3479  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
        3480 
        3481  void SetCurrentFrameIndex(uint32_t frameIndex);
        3482 
        3483  void MakePoolAllocationsLost(
        3484  VmaPool hPool,
        3485  size_t* pLostAllocationCount);
        3486 
        3487  void CreateLostAllocation(VmaAllocation* pAllocation);
        3488 
        3489  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
        3490  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
        3491 
        3492 private:
        3493  VkDeviceSize m_PreferredLargeHeapBlockSize;
        3494  VkDeviceSize m_PreferredSmallHeapBlockSize;
        3495 
        3496  VkPhysicalDevice m_PhysicalDevice;
        3497  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
        3498 
        3499  VMA_MUTEX m_PoolsMutex;
        3500  // Protected by m_PoolsMutex. Sorted by pointer value.
        3501  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
        3502 
        3503  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
        3504 
        3505  VkResult AllocateMemoryOfType(
        3506  const VkMemoryRequirements& vkMemReq,
        3507  const VmaAllocationCreateInfo& createInfo,
        3508  uint32_t memTypeIndex,
        3509  VmaSuballocationType suballocType,
        3510  VmaAllocation* pAllocation);
        3511 
        3512  // Allocates and registers new VkDeviceMemory specifically for single allocation.
        3513  VkResult AllocateOwnMemory(
        3514  VkDeviceSize size,
        3515  VmaSuballocationType suballocType,
        3516  uint32_t memTypeIndex,
        3517  bool map,
        3518  void* pUserData,
        3519  VmaAllocation* pAllocation);
        3520 
        3521  // Tries to free pMemory as Own Memory. Returns true if found and freed.
        3522  void FreeOwnMemory(VmaAllocation allocation);
        3523 };
        3524 
        3526 // Memory allocation #2 after VmaAllocator_T definition
        3527 
        3528 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
        3529 {
        3530  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
        3531 }
        3532 
        3533 static void VmaFree(VmaAllocator hAllocator, void* ptr)
        3534 {
        3535  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
        3536 }
        3537 
        3538 template<typename T>
        3539 static T* VmaAllocate(VmaAllocator hAllocator)
        3540 {
        3541  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
        3542 }
        3543 
        3544 template<typename T>
        3545 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
        3546 {
        3547  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
        3548 }
        3549 
        3550 template<typename T>
        3551 static void vma_delete(VmaAllocator hAllocator, T* ptr)
        3552 {
        3553  if(ptr != VMA_NULL)
        3554  {
        3555  ptr->~T();
        3556  VmaFree(hAllocator, ptr);
        3557  }
        3558 }
        3559 
        3560 template<typename T>
        3561 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
        3562 {
        3563  if(ptr != VMA_NULL)
        3564  {
        3565  for(size_t i = count; i--; )
        3566  ptr[i].~T();
        3567  VmaFree(hAllocator, ptr);
        3568  }
        3569 }
        3570 
        3572 // VmaStringBuilder
        3573 
        3574 #if VMA_STATS_STRING_ENABLED
        3575 
        3576 class VmaStringBuilder
        3577 {
        3578 public:
        3579  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
        3580  size_t GetLength() const { return m_Data.size(); }
        3581  const char* GetData() const { return m_Data.data(); }
        3582 
        3583  void Add(char ch) { m_Data.push_back(ch); }
        3584  void Add(const char* pStr);
        3585  void AddNewLine() { Add('\n'); }
        3586  void AddNumber(uint32_t num);
        3587  void AddNumber(uint64_t num);
        3588  void AddPointer(const void* ptr);
        3589 
        3590 private:
        3591  VmaVector< char, VmaStlAllocator<char> > m_Data;
        3592 };
        3593 
        3594 void VmaStringBuilder::Add(const char* pStr)
        3595 {
        3596  const size_t strLen = strlen(pStr);
        3597  if(strLen > 0)
        3598  {
        3599  const size_t oldCount = m_Data.size();
        3600  m_Data.resize(oldCount + strLen);
        3601  memcpy(m_Data.data() + oldCount, pStr, strLen);
        3602  }
        3603 }
        3604 
        3605 void VmaStringBuilder::AddNumber(uint32_t num)
        3606 {
        3607  char buf[11];
        3608  VmaUint32ToStr(buf, sizeof(buf), num);
        3609  Add(buf);
        3610 }
        3611 
        3612 void VmaStringBuilder::AddNumber(uint64_t num)
        3613 {
        3614  char buf[21];
        3615  VmaUint64ToStr(buf, sizeof(buf), num);
        3616  Add(buf);
        3617 }
        3618 
        3619 void VmaStringBuilder::AddPointer(const void* ptr)
        3620 {
        3621  char buf[21];
        3622  VmaPtrToStr(buf, sizeof(buf), ptr);
        3623  Add(buf);
        3624 }
        3625 
        3626 #endif // #if VMA_STATS_STRING_ENABLED
        3627 
        3629 // VmaJsonWriter
        3630 
        3631 #if VMA_STATS_STRING_ENABLED
        3632 
        3633 class VmaJsonWriter
        3634 {
        3635 public:
        3636  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
        3637  ~VmaJsonWriter();
        3638 
        3639  void BeginObject(bool singleLine = false);
        3640  void EndObject();
        3641 
        3642  void BeginArray(bool singleLine = false);
        3643  void EndArray();
        3644 
        3645  void WriteString(const char* pStr);
        3646  void BeginString(const char* pStr = VMA_NULL);
        3647  void ContinueString(const char* pStr);
        3648  void ContinueString(uint32_t n);
        3649  void ContinueString(uint64_t n);
        3650  void EndString(const char* pStr = VMA_NULL);
        3651 
        3652  void WriteNumber(uint32_t n);
        3653  void WriteNumber(uint64_t n);
        3654  void WriteBool(bool b);
        3655  void WriteNull();
        3656 
        3657 private:
        3658  static const char* const INDENT;
        3659 
        3660  enum COLLECTION_TYPE
        3661  {
        3662  COLLECTION_TYPE_OBJECT,
        3663  COLLECTION_TYPE_ARRAY,
        3664  };
        3665  struct StackItem
        3666  {
        3667  COLLECTION_TYPE type;
        3668  uint32_t valueCount;
        3669  bool singleLineMode;
        3670  };
        3671 
        3672  VmaStringBuilder& m_SB;
        3673  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
        3674  bool m_InsideString;
        3675 
        3676  void BeginValue(bool isString);
        3677  void WriteIndent(bool oneLess = false);
        3678 };
        3679 
        3680 const char* const VmaJsonWriter::INDENT = " ";
        3681 
        3682 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
        3683  m_SB(sb),
        3684  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
        3685  m_InsideString(false)
        3686 {
        3687 }
        3688 
        3689 VmaJsonWriter::~VmaJsonWriter()
        3690 {
        3691  VMA_ASSERT(!m_InsideString);
        3692  VMA_ASSERT(m_Stack.empty());
        3693 }
        3694 
        3695 void VmaJsonWriter::BeginObject(bool singleLine)
        3696 {
        3697  VMA_ASSERT(!m_InsideString);
        3698 
        3699  BeginValue(false);
        3700  m_SB.Add('{');
        3701 
        3702  StackItem item;
        3703  item.type = COLLECTION_TYPE_OBJECT;
        3704  item.valueCount = 0;
        3705  item.singleLineMode = singleLine;
        3706  m_Stack.push_back(item);
        3707 }
        3708 
        3709 void VmaJsonWriter::EndObject()
        3710 {
        3711  VMA_ASSERT(!m_InsideString);
        3712 
        3713  WriteIndent(true);
        3714  m_SB.Add('}');
        3715 
        3716  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
        3717  m_Stack.pop_back();
        3718 }
        3719 
        3720 void VmaJsonWriter::BeginArray(bool singleLine)
        3721 {
        3722  VMA_ASSERT(!m_InsideString);
        3723 
        3724  BeginValue(false);
        3725  m_SB.Add('[');
        3726 
        3727  StackItem item;
        3728  item.type = COLLECTION_TYPE_ARRAY;
        3729  item.valueCount = 0;
        3730  item.singleLineMode = singleLine;
        3731  m_Stack.push_back(item);
        3732 }
        3733 
        3734 void VmaJsonWriter::EndArray()
        3735 {
        3736  VMA_ASSERT(!m_InsideString);
        3737 
        3738  WriteIndent(true);
        3739  m_SB.Add(']');
        3740 
        3741  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
        3742  m_Stack.pop_back();
        3743 }
        3744 
        3745 void VmaJsonWriter::WriteString(const char* pStr)
        3746 {
        3747  BeginString(pStr);
        3748  EndString();
        3749 }
        3750 
        3751 void VmaJsonWriter::BeginString(const char* pStr)
        3752 {
        3753  VMA_ASSERT(!m_InsideString);
        3754 
        3755  BeginValue(true);
        3756  m_SB.Add('"');
        3757  m_InsideString = true;
        3758  if(pStr != VMA_NULL && pStr[0] != '\0')
        3759  {
        3760  ContinueString(pStr);
        3761  }
        3762 }
        3763 
        3764 void VmaJsonWriter::ContinueString(const char* pStr)
        3765 {
        3766  VMA_ASSERT(m_InsideString);
        3767 
        3768  const size_t strLen = strlen(pStr);
        3769  for(size_t i = 0; i < strLen; ++i)
        3770  {
        3771  char ch = pStr[i];
        3772  if(ch == '\'')
        3773  {
        3774  m_SB.Add("\\\\");
        3775  }
        3776  else if(ch == '"')
        3777  {
        3778  m_SB.Add("\\\"");
        3779  }
        3780  else if(ch >= 32)
        3781  {
        3782  m_SB.Add(ch);
        3783  }
        3784  else switch(ch)
        3785  {
        3786  case '\n':
        3787  m_SB.Add("\\n");
        3788  break;
        3789  case '\r':
        3790  m_SB.Add("\\r");
        3791  break;
        3792  case '\t':
        3793  m_SB.Add("\\t");
        3794  break;
        3795  default:
        3796  VMA_ASSERT(0 && "Character not currently supported.");
        3797  break;
        3798  }
        3799  }
        3800 }
        3801 
        3802 void VmaJsonWriter::ContinueString(uint32_t n)
        3803 {
        3804  VMA_ASSERT(m_InsideString);
        3805  m_SB.AddNumber(n);
        3806 }
        3807 
        3808 void VmaJsonWriter::ContinueString(uint64_t n)
        3809 {
        3810  VMA_ASSERT(m_InsideString);
        3811  m_SB.AddNumber(n);
        3812 }
        3813 
        3814 void VmaJsonWriter::EndString(const char* pStr)
        3815 {
        3816  VMA_ASSERT(m_InsideString);
        3817  if(pStr != VMA_NULL && pStr[0] != '\0')
        3818  {
        3819  ContinueString(pStr);
        3820  }
        3821  m_SB.Add('"');
        3822  m_InsideString = false;
        3823 }
        3824 
        3825 void VmaJsonWriter::WriteNumber(uint32_t n)
        3826 {
        3827  VMA_ASSERT(!m_InsideString);
        3828  BeginValue(false);
        3829  m_SB.AddNumber(n);
        3830 }
        3831 
        3832 void VmaJsonWriter::WriteNumber(uint64_t n)
        3833 {
        3834  VMA_ASSERT(!m_InsideString);
        3835  BeginValue(false);
        3836  m_SB.AddNumber(n);
        3837 }
        3838 
        3839 void VmaJsonWriter::WriteBool(bool b)
        3840 {
        3841  VMA_ASSERT(!m_InsideString);
        3842  BeginValue(false);
        3843  m_SB.Add(b ? "true" : "false");
        3844 }
        3845 
        3846 void VmaJsonWriter::WriteNull()
        3847 {
        3848  VMA_ASSERT(!m_InsideString);
        3849  BeginValue(false);
        3850  m_SB.Add("null");
        3851 }
        3852 
        3853 void VmaJsonWriter::BeginValue(bool isString)
        3854 {
        3855  if(!m_Stack.empty())
        3856  {
        3857  StackItem& currItem = m_Stack.back();
        3858  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        3859  currItem.valueCount % 2 == 0)
        3860  {
        3861  VMA_ASSERT(isString);
        3862  }
        3863 
        3864  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        3865  currItem.valueCount % 2 != 0)
        3866  {
        3867  m_SB.Add(": ");
        3868  }
        3869  else if(currItem.valueCount > 0)
        3870  {
        3871  m_SB.Add(", ");
        3872  WriteIndent();
        3873  }
        3874  else
        3875  {
        3876  WriteIndent();
        3877  }
        3878  ++currItem.valueCount;
        3879  }
        3880 }
        3881 
        3882 void VmaJsonWriter::WriteIndent(bool oneLess)
        3883 {
        3884  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
        3885  {
        3886  m_SB.AddNewLine();
        3887 
        3888  size_t count = m_Stack.size();
        3889  if(count > 0 && oneLess)
        3890  {
        3891  --count;
        3892  }
        3893  for(size_t i = 0; i < count; ++i)
        3894  {
        3895  m_SB.Add(INDENT);
        3896  }
        3897  }
        3898 }
        3899 
        3900 #endif // #if VMA_STATS_STRING_ENABLED
        3901 
        3903 
        3904 VkDeviceSize VmaAllocation_T::GetOffset() const
        3905 {
        3906  switch(m_Type)
        3907  {
        3908  case ALLOCATION_TYPE_BLOCK:
        3909  return m_BlockAllocation.m_Offset;
        3910  case ALLOCATION_TYPE_OWN:
        3911  return 0;
        3912  default:
        3913  VMA_ASSERT(0);
        3914  return 0;
        3915  }
        3916 }
        3917 
        3918 VkDeviceMemory VmaAllocation_T::GetMemory() const
        3919 {
        3920  switch(m_Type)
        3921  {
        3922  case ALLOCATION_TYPE_BLOCK:
        3923  return m_BlockAllocation.m_Block->m_hMemory;
        3924  case ALLOCATION_TYPE_OWN:
        3925  return m_OwnAllocation.m_hMemory;
        3926  default:
        3927  VMA_ASSERT(0);
        3928  return VK_NULL_HANDLE;
        3929  }
        3930 }
        3931 
        3932 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
        3933 {
        3934  switch(m_Type)
        3935  {
        3936  case ALLOCATION_TYPE_BLOCK:
        3937  return m_BlockAllocation.m_Block->m_MemoryTypeIndex;
        3938  case ALLOCATION_TYPE_OWN:
        3939  return m_OwnAllocation.m_MemoryTypeIndex;
        3940  default:
        3941  VMA_ASSERT(0);
        3942  return UINT32_MAX;
        3943  }
        3944 }
        3945 
        3946 VMA_BLOCK_VECTOR_TYPE VmaAllocation_T::GetBlockVectorType() const
        3947 {
        3948  switch(m_Type)
        3949  {
        3950  case ALLOCATION_TYPE_BLOCK:
        3951  return m_BlockAllocation.m_Block->m_BlockVectorType;
        3952  case ALLOCATION_TYPE_OWN:
        3953  return (m_OwnAllocation.m_PersistentMap ? VMA_BLOCK_VECTOR_TYPE_MAPPED : VMA_BLOCK_VECTOR_TYPE_UNMAPPED);
        3954  default:
        3955  VMA_ASSERT(0);
        3956  return VMA_BLOCK_VECTOR_TYPE_COUNT;
        3957  }
        3958 }
        3959 
        3960 void* VmaAllocation_T::GetMappedData() const
        3961 {
        3962  switch(m_Type)
        3963  {
        3964  case ALLOCATION_TYPE_BLOCK:
        3965  if(m_BlockAllocation.m_Block->m_pMappedData != VMA_NULL)
        3966  {
        3967  return (char*)m_BlockAllocation.m_Block->m_pMappedData + m_BlockAllocation.m_Offset;
        3968  }
        3969  else
        3970  {
        3971  return VMA_NULL;
        3972  }
        3973  break;
        3974  case ALLOCATION_TYPE_OWN:
        3975  return m_OwnAllocation.m_pMappedData;
        3976  default:
        3977  VMA_ASSERT(0);
        3978  return VMA_NULL;
        3979  }
        3980 }
        3981 
        3982 bool VmaAllocation_T::CanBecomeLost() const
        3983 {
        3984  switch(m_Type)
        3985  {
        3986  case ALLOCATION_TYPE_BLOCK:
        3987  return m_BlockAllocation.m_CanBecomeLost;
        3988  case ALLOCATION_TYPE_OWN:
        3989  return false;
        3990  default:
        3991  VMA_ASSERT(0);
        3992  return false;
        3993  }
        3994 }
        3995 
        3996 VmaPool VmaAllocation_T::GetPool() const
        3997 {
        3998  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        3999  return m_BlockAllocation.m_hPool;
        4000 }
        4001 
        4002 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        4003 {
        4004  VMA_ASSERT(CanBecomeLost());
        4005 
        4006  /*
        4007  Warning: This is a carefully designed algorithm.
        4008  Do not modify unless you really know what you're doing :)
        4009  */
        4010  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
        4011  for(;;)
        4012  {
        4013  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        4014  {
        4015  VMA_ASSERT(0);
        4016  return false;
        4017  }
        4018  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
        4019  {
        4020  return false;
        4021  }
        4022  else // Last use time earlier than current time.
        4023  {
        4024  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
        4025  {
        4026  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
        4027  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
        4028  return true;
        4029  }
        4030  }
        4031  }
        4032 }
        4033 
        4034 #if VMA_STATS_STRING_ENABLED
        4035 
        4036 // Correspond to values of enum VmaSuballocationType.
        4037 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
        4038  "FREE",
        4039  "UNKNOWN",
        4040  "BUFFER",
        4041  "IMAGE_UNKNOWN",
        4042  "IMAGE_LINEAR",
        4043  "IMAGE_OPTIMAL",
        4044 };
        4045 
        4046 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
        4047 {
        4048  json.BeginObject();
        4049 
        4050  json.WriteString("Blocks");
        4051  json.WriteNumber(stat.BlockCount);
        4052 
        4053  json.WriteString("Allocations");
        4054  json.WriteNumber(stat.AllocationCount);
        4055 
        4056  json.WriteString("UnusedRanges");
        4057  json.WriteNumber(stat.UnusedRangeCount);
        4058 
        4059  json.WriteString("UsedBytes");
        4060  json.WriteNumber(stat.UsedBytes);
        4061 
        4062  json.WriteString("UnusedBytes");
        4063  json.WriteNumber(stat.UnusedBytes);
        4064 
        4065  if(stat.AllocationCount > 1)
        4066  {
        4067  json.WriteString("AllocationSize");
        4068  json.BeginObject(true);
        4069  json.WriteString("Min");
        4070  json.WriteNumber(stat.AllocationSizeMin);
        4071  json.WriteString("Avg");
        4072  json.WriteNumber(stat.AllocationSizeAvg);
        4073  json.WriteString("Max");
        4074  json.WriteNumber(stat.AllocationSizeMax);
        4075  json.EndObject();
        4076  }
        4077 
        4078  if(stat.UnusedRangeCount > 1)
        4079  {
        4080  json.WriteString("UnusedRangeSize");
        4081  json.BeginObject(true);
        4082  json.WriteString("Min");
        4083  json.WriteNumber(stat.UnusedRangeSizeMin);
        4084  json.WriteString("Avg");
        4085  json.WriteNumber(stat.UnusedRangeSizeAvg);
        4086  json.WriteString("Max");
        4087  json.WriteNumber(stat.UnusedRangeSizeMax);
        4088  json.EndObject();
        4089  }
        4090 
        4091  json.EndObject();
        4092 }
        4093 
        4094 #endif // #if VMA_STATS_STRING_ENABLED
        4095 
        4096 struct VmaSuballocationItemSizeLess
        4097 {
        4098  bool operator()(
        4099  const VmaSuballocationList::iterator lhs,
        4100  const VmaSuballocationList::iterator rhs) const
        4101  {
        4102  return lhs->size < rhs->size;
        4103  }
        4104  bool operator()(
        4105  const VmaSuballocationList::iterator lhs,
        4106  VkDeviceSize rhsSize) const
        4107  {
        4108  return lhs->size < rhsSize;
        4109  }
        4110 };
        4111 
        4112 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
        4113  m_MemoryTypeIndex(UINT32_MAX),
        4114  m_BlockVectorType(VMA_BLOCK_VECTOR_TYPE_COUNT),
        4115  m_hMemory(VK_NULL_HANDLE),
        4116  m_Size(0),
        4117  m_PersistentMap(false),
        4118  m_pMappedData(VMA_NULL),
        4119  m_FreeCount(0),
        4120  m_SumFreeSize(0),
        4121  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        4122  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
        4123 {
        4124 }
        4125 
        4126 void VmaDeviceMemoryBlock::Init(
        4127  uint32_t newMemoryTypeIndex,
        4128  VMA_BLOCK_VECTOR_TYPE newBlockVectorType,
        4129  VkDeviceMemory newMemory,
        4130  VkDeviceSize newSize,
        4131  bool persistentMap,
        4132  void* pMappedData)
        4133 {
        4134  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        4135 
        4136  m_MemoryTypeIndex = newMemoryTypeIndex;
        4137  m_BlockVectorType = newBlockVectorType;
        4138  m_hMemory = newMemory;
        4139  m_Size = newSize;
        4140  m_PersistentMap = persistentMap;
        4141  m_pMappedData = pMappedData;
        4142  m_FreeCount = 1;
        4143  m_SumFreeSize = newSize;
        4144 
        4145  m_Suballocations.clear();
        4146  m_FreeSuballocationsBySize.clear();
        4147 
        4148  VmaSuballocation suballoc = {};
        4149  suballoc.offset = 0;
        4150  suballoc.size = newSize;
        4151  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4152  suballoc.hAllocation = VK_NULL_HANDLE;
        4153 
        4154  m_Suballocations.push_back(suballoc);
        4155  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
        4156  --suballocItem;
        4157  m_FreeSuballocationsBySize.push_back(suballocItem);
        4158 }
        4159 
        4160 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
        4161 {
        4162  // This is the most important assert in the entire library.
        4163  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
        4164  VMA_ASSERT(IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
        4165 
        4166  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
        4167  if(m_pMappedData != VMA_NULL)
        4168  {
        4169  vkUnmapMemory(allocator->m_hDevice, m_hMemory);
        4170  m_pMappedData = VMA_NULL;
        4171  }
        4172 
        4173  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Size, m_hMemory);
        4174  m_hMemory = VK_NULL_HANDLE;
        4175 }
        4176 
        4177 bool VmaDeviceMemoryBlock::Validate() const
        4178 {
        4179  if((m_hMemory == VK_NULL_HANDLE) ||
        4180  (m_Size == 0) ||
        4181  m_Suballocations.empty())
        4182  {
        4183  return false;
        4184  }
        4185 
        4186  // Expected offset of new suballocation as calculates from previous ones.
        4187  VkDeviceSize calculatedOffset = 0;
        4188  // Expected number of free suballocations as calculated from traversing their list.
        4189  uint32_t calculatedFreeCount = 0;
        4190  // Expected sum size of free suballocations as calculated from traversing their list.
        4191  VkDeviceSize calculatedSumFreeSize = 0;
        4192  // Expected number of free suballocations that should be registered in
        4193  // m_FreeSuballocationsBySize calculated from traversing their list.
        4194  size_t freeSuballocationsToRegister = 0;
        4195  // True if previous visisted suballocation was free.
        4196  bool prevFree = false;
        4197 
        4198  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        4199  suballocItem != m_Suballocations.cend();
        4200  ++suballocItem)
        4201  {
        4202  const VmaSuballocation& subAlloc = *suballocItem;
        4203 
        4204  // Actual offset of this suballocation doesn't match expected one.
        4205  if(subAlloc.offset != calculatedOffset)
        4206  {
        4207  return false;
        4208  }
        4209 
        4210  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        4211  // Two adjacent free suballocations are invalid. They should be merged.
        4212  if(prevFree && currFree)
        4213  {
        4214  return false;
        4215  }
        4216  prevFree = currFree;
        4217 
        4218  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
        4219  {
        4220  return false;
        4221  }
        4222 
        4223  if(currFree)
        4224  {
        4225  calculatedSumFreeSize += subAlloc.size;
        4226  ++calculatedFreeCount;
        4227  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4228  {
        4229  ++freeSuballocationsToRegister;
        4230  }
        4231  }
        4232 
        4233  calculatedOffset += subAlloc.size;
        4234  }
        4235 
        4236  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
        4237  // match expected one.
        4238  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
        4239  {
        4240  return false;
        4241  }
        4242 
        4243  VkDeviceSize lastSize = 0;
        4244  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
        4245  {
        4246  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
        4247 
        4248  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        4249  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
        4250  {
        4251  return false;
        4252  }
        4253  // They must be sorted by size ascending.
        4254  if(suballocItem->size < lastSize)
        4255  {
        4256  return false;
        4257  }
        4258 
        4259  lastSize = suballocItem->size;
        4260  }
        4261 
        4262  // Check if totals match calculacted values.
        4263  return
        4264  (calculatedOffset == m_Size) &&
        4265  (calculatedSumFreeSize == m_SumFreeSize) &&
        4266  (calculatedFreeCount == m_FreeCount);
        4267 }
        4268 
        4269 /*
        4270 How many suitable free suballocations to analyze before choosing best one.
        4271 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
        4272  be chosen.
        4273 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
        4274  suballocations will be analized and best one will be chosen.
        4275 - Any other value is also acceptable.
        4276 */
        4277 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
        4278 
        4279 bool VmaDeviceMemoryBlock::CreateAllocationRequest(
        4280  uint32_t currentFrameIndex,
        4281  uint32_t frameInUseCount,
        4282  VkDeviceSize bufferImageGranularity,
        4283  VkDeviceSize allocSize,
        4284  VkDeviceSize allocAlignment,
        4285  VmaSuballocationType allocType,
        4286  bool canMakeOtherLost,
        4287  VmaAllocationRequest* pAllocationRequest)
        4288 {
        4289  VMA_ASSERT(allocSize > 0);
        4290  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        4291  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        4292  VMA_HEAVY_ASSERT(Validate());
        4293 
        4294  // There is not enough total free space in this block to fullfill the request: Early return.
        4295  if(canMakeOtherLost == false && m_SumFreeSize < allocSize)
        4296  {
        4297  return false;
        4298  }
        4299 
        4300  // New algorithm, efficiently searching freeSuballocationsBySize.
        4301  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
        4302  if(freeSuballocCount > 0)
        4303  {
        4304  if(VMA_BEST_FIT)
        4305  {
        4306  // Find first free suballocation with size not less than allocSize.
        4307  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        4308  m_FreeSuballocationsBySize.data(),
        4309  m_FreeSuballocationsBySize.data() + freeSuballocCount,
        4310  allocSize,
        4311  VmaSuballocationItemSizeLess());
        4312  size_t index = it - m_FreeSuballocationsBySize.data();
        4313  for(; index < freeSuballocCount; ++index)
        4314  {
        4315  if(CheckAllocation(
        4316  currentFrameIndex,
        4317  frameInUseCount,
        4318  bufferImageGranularity,
        4319  allocSize,
        4320  allocAlignment,
        4321  allocType,
        4322  m_FreeSuballocationsBySize[index],
        4323  false, // canMakeOtherLost
        4324  &pAllocationRequest->offset,
        4325  &pAllocationRequest->itemsToMakeLostCount,
        4326  &pAllocationRequest->sumFreeSize,
        4327  &pAllocationRequest->sumItemSize))
        4328  {
        4329  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        4330  return true;
        4331  }
        4332  }
        4333  }
        4334  else
        4335  {
        4336  // Search staring from biggest suballocations.
        4337  for(size_t index = freeSuballocCount; index--; )
        4338  {
        4339  if(CheckAllocation(
        4340  currentFrameIndex,
        4341  frameInUseCount,
        4342  bufferImageGranularity,
        4343  allocSize,
        4344  allocAlignment,
        4345  allocType,
        4346  m_FreeSuballocationsBySize[index],
        4347  false, // canMakeOtherLost
        4348  &pAllocationRequest->offset,
        4349  &pAllocationRequest->itemsToMakeLostCount,
        4350  &pAllocationRequest->sumFreeSize,
        4351  &pAllocationRequest->sumItemSize))
        4352  {
        4353  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        4354  return true;
        4355  }
        4356  }
        4357  }
        4358  }
        4359 
        4360  if(canMakeOtherLost)
        4361  {
        4362  // Brute-force algorithm. TODO: Come up with something better.
        4363 
        4364  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
        4365  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
        4366 
        4367  VmaAllocationRequest tmpAllocRequest = {};
        4368  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
        4369  suballocIt != m_Suballocations.end();
        4370  ++suballocIt)
        4371  {
        4372  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
        4373  suballocIt->hAllocation->CanBecomeLost())
        4374  {
        4375  if(CheckAllocation(
        4376  currentFrameIndex,
        4377  frameInUseCount,
        4378  bufferImageGranularity,
        4379  allocSize,
        4380  allocAlignment,
        4381  allocType,
        4382  suballocIt,
        4383  canMakeOtherLost,
        4384  &tmpAllocRequest.offset,
        4385  &tmpAllocRequest.itemsToMakeLostCount,
        4386  &tmpAllocRequest.sumFreeSize,
        4387  &tmpAllocRequest.sumItemSize))
        4388  {
        4389  tmpAllocRequest.item = suballocIt;
        4390 
        4391  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
        4392  {
        4393  *pAllocationRequest = tmpAllocRequest;
        4394  }
        4395  }
        4396  }
        4397  }
        4398 
        4399  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
        4400  {
        4401  return true;
        4402  }
        4403  }
        4404 
        4405  return false;
        4406 }
        4407 
        4408 bool VmaDeviceMemoryBlock::MakeRequestedAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount, VmaAllocationRequest* pAllocationRequest)
        4409 {
        4410  while(pAllocationRequest->itemsToMakeLostCount > 0)
        4411  {
        4412  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
        4413  {
        4414  ++pAllocationRequest->item;
        4415  }
        4416  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        4417  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
        4418  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
        4419  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        4420  {
        4421  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
        4422  --pAllocationRequest->itemsToMakeLostCount;
        4423  }
        4424  else
        4425  {
        4426  return false;
        4427  }
        4428  }
        4429 
        4430  VMA_HEAVY_ASSERT(Validate());
        4431  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        4432  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4433 
        4434  return true;
        4435 }
        4436 
        4437 uint32_t VmaDeviceMemoryBlock::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        4438 {
        4439  uint32_t lostAllocationCount = 0;
        4440  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        4441  it != m_Suballocations.end();
        4442  ++it)
        4443  {
        4444  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
        4445  it->hAllocation->CanBecomeLost() &&
        4446  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        4447  {
        4448  it = FreeSuballocation(it);
        4449  ++lostAllocationCount;
        4450  }
        4451  }
        4452  return lostAllocationCount;
        4453 }
        4454 
        4455 bool VmaDeviceMemoryBlock::CheckAllocation(
        4456  uint32_t currentFrameIndex,
        4457  uint32_t frameInUseCount,
        4458  VkDeviceSize bufferImageGranularity,
        4459  VkDeviceSize allocSize,
        4460  VkDeviceSize allocAlignment,
        4461  VmaSuballocationType allocType,
        4462  VmaSuballocationList::const_iterator suballocItem,
        4463  bool canMakeOtherLost,
        4464  VkDeviceSize* pOffset,
        4465  size_t* itemsToMakeLostCount,
        4466  VkDeviceSize* pSumFreeSize,
        4467  VkDeviceSize* pSumItemSize) const
        4468 {
        4469  VMA_ASSERT(allocSize > 0);
        4470  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        4471  VMA_ASSERT(suballocItem != m_Suballocations.cend());
        4472  VMA_ASSERT(pOffset != VMA_NULL);
        4473 
        4474  *itemsToMakeLostCount = 0;
        4475  *pSumFreeSize = 0;
        4476  *pSumItemSize = 0;
        4477 
        4478  if(canMakeOtherLost)
        4479  {
        4480  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        4481  {
        4482  *pSumFreeSize = suballocItem->size;
        4483  }
        4484  else
        4485  {
        4486  if(suballocItem->hAllocation->CanBecomeLost() &&
        4487  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        4488  {
        4489  ++*itemsToMakeLostCount;
        4490  *pSumItemSize = suballocItem->size;
        4491  }
        4492  else
        4493  {
        4494  return false;
        4495  }
        4496  }
        4497 
        4498  // Remaining size is too small for this request: Early return.
        4499  if(m_Size - suballocItem->offset < allocSize)
        4500  {
        4501  return false;
        4502  }
        4503 
        4504  // Start from offset equal to beginning of this suballocation.
        4505  *pOffset = suballocItem->offset;
        4506 
        4507  // Apply VMA_DEBUG_MARGIN at the beginning.
        4508  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
        4509  {
        4510  *pOffset += VMA_DEBUG_MARGIN;
        4511  }
        4512 
        4513  // Apply alignment.
        4514  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
        4515  *pOffset = VmaAlignUp(*pOffset, alignment);
        4516 
        4517  // Check previous suballocations for BufferImageGranularity conflicts.
        4518  // Make bigger alignment if necessary.
        4519  if(bufferImageGranularity > 1)
        4520  {
        4521  bool bufferImageGranularityConflict = false;
        4522  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        4523  while(prevSuballocItem != m_Suballocations.cbegin())
        4524  {
        4525  --prevSuballocItem;
        4526  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        4527  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        4528  {
        4529  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        4530  {
        4531  bufferImageGranularityConflict = true;
        4532  break;
        4533  }
        4534  }
        4535  else
        4536  // Already on previous page.
        4537  break;
        4538  }
        4539  if(bufferImageGranularityConflict)
        4540  {
        4541  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        4542  }
        4543  }
        4544 
        4545  // Now that we have final *pOffset, check if we are past suballocItem.
        4546  // If yes, return false - this function should be called for another suballocItem as starting point.
        4547  if(*pOffset >= suballocItem->offset + suballocItem->size)
        4548  {
        4549  return false;
        4550  }
        4551 
        4552  // Calculate padding at the beginning based on current offset.
        4553  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
        4554 
        4555  // Calculate required margin at the end if this is not last suballocation.
        4556  VmaSuballocationList::const_iterator next = suballocItem;
        4557  ++next;
        4558  const VkDeviceSize requiredEndMargin =
        4559  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
        4560 
        4561  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
        4562  // Another early return check.
        4563  if(suballocItem->offset + totalSize > m_Size)
        4564  {
        4565  return false;
        4566  }
        4567 
        4568  // Advance lastSuballocItem until desired size is reached.
        4569  // Update itemsToMakeLostCount.
        4570  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
        4571  if(totalSize > suballocItem->size)
        4572  {
        4573  VkDeviceSize remainingSize = totalSize - suballocItem->size;
        4574  while(remainingSize > 0)
        4575  {
        4576  ++lastSuballocItem;
        4577  if(lastSuballocItem == m_Suballocations.cend())
        4578  {
        4579  return false;
        4580  }
        4581  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        4582  {
        4583  *pSumFreeSize += lastSuballocItem->size;
        4584  }
        4585  else
        4586  {
        4587  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
        4588  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
        4589  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        4590  {
        4591  ++*itemsToMakeLostCount;
        4592  *pSumItemSize += lastSuballocItem->size;
        4593  }
        4594  else
        4595  {
        4596  return false;
        4597  }
        4598  }
        4599  remainingSize = (lastSuballocItem->size < remainingSize) ?
        4600  remainingSize - lastSuballocItem->size : 0;
        4601  }
        4602  }
        4603 
        4604  // Check next suballocations for BufferImageGranularity conflicts.
        4605  // If conflict exists, we must mark more allocations lost or fail.
        4606  if(bufferImageGranularity > 1)
        4607  {
        4608  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
        4609  ++nextSuballocItem;
        4610  while(nextSuballocItem != m_Suballocations.cend())
        4611  {
        4612  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        4613  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        4614  {
        4615  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        4616  {
        4617  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
        4618  if(nextSuballoc.hAllocation->CanBecomeLost() &&
        4619  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        4620  {
        4621  ++*itemsToMakeLostCount;
        4622  }
        4623  else
        4624  {
        4625  return false;
        4626  }
        4627  }
        4628  }
        4629  else
        4630  {
        4631  // Already on next page.
        4632  break;
        4633  }
        4634  ++nextSuballocItem;
        4635  }
        4636  }
        4637  }
        4638  else
        4639  {
        4640  const VmaSuballocation& suballoc = *suballocItem;
        4641  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        4642 
        4643  *pSumFreeSize = suballoc.size;
        4644 
        4645  // Size of this suballocation is too small for this request: Early return.
        4646  if(suballoc.size < allocSize)
        4647  {
        4648  return false;
        4649  }
        4650 
        4651  // Start from offset equal to beginning of this suballocation.
        4652  *pOffset = suballoc.offset;
        4653 
        4654  // Apply VMA_DEBUG_MARGIN at the beginning.
        4655  if((VMA_DEBUG_MARGIN > 0) && suballocItem != m_Suballocations.cbegin())
        4656  {
        4657  *pOffset += VMA_DEBUG_MARGIN;
        4658  }
        4659 
        4660  // Apply alignment.
        4661  const VkDeviceSize alignment = VMA_MAX(allocAlignment, static_cast<VkDeviceSize>(VMA_DEBUG_ALIGNMENT));
        4662  *pOffset = VmaAlignUp(*pOffset, alignment);
        4663 
        4664  // Check previous suballocations for BufferImageGranularity conflicts.
        4665  // Make bigger alignment if necessary.
        4666  if(bufferImageGranularity > 1)
        4667  {
        4668  bool bufferImageGranularityConflict = false;
        4669  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        4670  while(prevSuballocItem != m_Suballocations.cbegin())
        4671  {
        4672  --prevSuballocItem;
        4673  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        4674  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        4675  {
        4676  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        4677  {
        4678  bufferImageGranularityConflict = true;
        4679  break;
        4680  }
        4681  }
        4682  else
        4683  // Already on previous page.
        4684  break;
        4685  }
        4686  if(bufferImageGranularityConflict)
        4687  {
        4688  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        4689  }
        4690  }
        4691 
        4692  // Calculate padding at the beginning based on current offset.
        4693  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
        4694 
        4695  // Calculate required margin at the end if this is not last suballocation.
        4696  VmaSuballocationList::const_iterator next = suballocItem;
        4697  ++next;
        4698  const VkDeviceSize requiredEndMargin =
        4699  (next != m_Suballocations.cend()) ? VMA_DEBUG_MARGIN : 0;
        4700 
        4701  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
        4702  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
        4703  {
        4704  return false;
        4705  }
        4706 
        4707  // Check next suballocations for BufferImageGranularity conflicts.
        4708  // If conflict exists, allocation cannot be made here.
        4709  if(bufferImageGranularity > 1)
        4710  {
        4711  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        4712  ++nextSuballocItem;
        4713  while(nextSuballocItem != m_Suballocations.cend())
        4714  {
        4715  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        4716  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        4717  {
        4718  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        4719  {
        4720  return false;
        4721  }
        4722  }
        4723  else
        4724  {
        4725  // Already on next page.
        4726  break;
        4727  }
        4728  ++nextSuballocItem;
        4729  }
        4730  }
        4731  }
        4732 
        4733  // All tests passed: Success. pOffset is already filled.
        4734  return true;
        4735 }
        4736 
        4737 bool VmaDeviceMemoryBlock::IsEmpty() const
        4738 {
        4739  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
        4740 }
        4741 
        4742 void VmaDeviceMemoryBlock::Alloc(
        4743  const VmaAllocationRequest& request,
        4744  VmaSuballocationType type,
        4745  VkDeviceSize allocSize,
        4746  VmaAllocation hAllocation)
        4747 {
        4748  VMA_ASSERT(request.item != m_Suballocations.end());
        4749  VmaSuballocation& suballoc = *request.item;
        4750  // Given suballocation is a free block.
        4751  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        4752  // Given offset is inside this suballocation.
        4753  VMA_ASSERT(request.offset >= suballoc.offset);
        4754  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
        4755  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
        4756  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
        4757 
        4758  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
        4759  // it to become used.
        4760  UnregisterFreeSuballocation(request.item);
        4761 
        4762  suballoc.offset = request.offset;
        4763  suballoc.size = allocSize;
        4764  suballoc.type = type;
        4765  suballoc.hAllocation = hAllocation;
        4766 
        4767  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
        4768  if(paddingEnd)
        4769  {
        4770  VmaSuballocation paddingSuballoc = {};
        4771  paddingSuballoc.offset = request.offset + allocSize;
        4772  paddingSuballoc.size = paddingEnd;
        4773  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4774  VmaSuballocationList::iterator next = request.item;
        4775  ++next;
        4776  const VmaSuballocationList::iterator paddingEndItem =
        4777  m_Suballocations.insert(next, paddingSuballoc);
        4778  RegisterFreeSuballocation(paddingEndItem);
        4779  }
        4780 
        4781  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
        4782  if(paddingBegin)
        4783  {
        4784  VmaSuballocation paddingSuballoc = {};
        4785  paddingSuballoc.offset = request.offset - paddingBegin;
        4786  paddingSuballoc.size = paddingBegin;
        4787  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4788  const VmaSuballocationList::iterator paddingBeginItem =
        4789  m_Suballocations.insert(request.item, paddingSuballoc);
        4790  RegisterFreeSuballocation(paddingBeginItem);
        4791  }
        4792 
        4793  // Update totals.
        4794  m_FreeCount = m_FreeCount - 1;
        4795  if(paddingBegin > 0)
        4796  {
        4797  ++m_FreeCount;
        4798  }
        4799  if(paddingEnd > 0)
        4800  {
        4801  ++m_FreeCount;
        4802  }
        4803  m_SumFreeSize -= allocSize;
        4804 }
        4805 
        4806 VmaSuballocationList::iterator VmaDeviceMemoryBlock::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
        4807 {
        4808  // Change this suballocation to be marked as free.
        4809  VmaSuballocation& suballoc = *suballocItem;
        4810  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        4811  suballoc.hAllocation = VK_NULL_HANDLE;
        4812 
        4813  // Update totals.
        4814  ++m_FreeCount;
        4815  m_SumFreeSize += suballoc.size;
        4816 
        4817  // Merge with previous and/or next suballocation if it's also free.
        4818  bool mergeWithNext = false;
        4819  bool mergeWithPrev = false;
        4820 
        4821  VmaSuballocationList::iterator nextItem = suballocItem;
        4822  ++nextItem;
        4823  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
        4824  {
        4825  mergeWithNext = true;
        4826  }
        4827 
        4828  VmaSuballocationList::iterator prevItem = suballocItem;
        4829  if(suballocItem != m_Suballocations.begin())
        4830  {
        4831  --prevItem;
        4832  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        4833  {
        4834  mergeWithPrev = true;
        4835  }
        4836  }
        4837 
        4838  if(mergeWithNext)
        4839  {
        4840  UnregisterFreeSuballocation(nextItem);
        4841  MergeFreeWithNext(suballocItem);
        4842  }
        4843 
        4844  if(mergeWithPrev)
        4845  {
        4846  UnregisterFreeSuballocation(prevItem);
        4847  MergeFreeWithNext(prevItem);
        4848  RegisterFreeSuballocation(prevItem);
        4849  return prevItem;
        4850  }
        4851  else
        4852  {
        4853  RegisterFreeSuballocation(suballocItem);
        4854  return suballocItem;
        4855  }
        4856 }
        4857 
        4858 void VmaDeviceMemoryBlock::Free(const VmaAllocation allocation)
        4859 {
        4860  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        4861  suballocItem != m_Suballocations.end();
        4862  ++suballocItem)
        4863  {
        4864  VmaSuballocation& suballoc = *suballocItem;
        4865  if(suballoc.hAllocation == allocation)
        4866  {
        4867  FreeSuballocation(suballocItem);
        4868  VMA_HEAVY_ASSERT(Validate());
        4869  return;
        4870  }
        4871  }
        4872  VMA_ASSERT(0 && "Not found!");
        4873 }
        4874 
        4875 #if VMA_STATS_STRING_ENABLED
        4876 
        4877 void VmaDeviceMemoryBlock::PrintDetailedMap(class VmaJsonWriter& json) const
        4878 {
        4879  json.BeginObject();
        4880 
        4881  json.WriteString("TotalBytes");
        4882  json.WriteNumber(m_Size);
        4883 
        4884  json.WriteString("UnusedBytes");
        4885  json.WriteNumber(m_SumFreeSize);
        4886 
        4887  json.WriteString("Allocations");
        4888  json.WriteNumber(m_Suballocations.size() - m_FreeCount);
        4889 
        4890  json.WriteString("UnusedRanges");
        4891  json.WriteNumber(m_FreeCount);
        4892 
        4893  json.WriteString("Suballocations");
        4894  json.BeginArray();
        4895  size_t i = 0;
        4896  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        4897  suballocItem != m_Suballocations.cend();
        4898  ++suballocItem, ++i)
        4899  {
        4900  json.BeginObject(true);
        4901 
        4902  json.WriteString("Type");
        4903  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[suballocItem->type]);
        4904 
        4905  json.WriteString("Size");
        4906  json.WriteNumber(suballocItem->size);
        4907 
        4908  json.WriteString("Offset");
        4909  json.WriteNumber(suballocItem->offset);
        4910 
        4911  json.EndObject();
        4912  }
        4913  json.EndArray();
        4914 
        4915  json.EndObject();
        4916 }
        4917 
        4918 #endif // #if VMA_STATS_STRING_ENABLED
        4919 
        4920 void VmaDeviceMemoryBlock::MergeFreeWithNext(VmaSuballocationList::iterator item)
        4921 {
        4922  VMA_ASSERT(item != m_Suballocations.end());
        4923  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4924 
        4925  VmaSuballocationList::iterator nextItem = item;
        4926  ++nextItem;
        4927  VMA_ASSERT(nextItem != m_Suballocations.end());
        4928  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        4929 
        4930  item->size += nextItem->size;
        4931  --m_FreeCount;
        4932  m_Suballocations.erase(nextItem);
        4933 }
        4934 
        4935 void VmaDeviceMemoryBlock::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
        4936 {
        4937  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4938  VMA_ASSERT(item->size > 0);
        4939 
        4940  // You may want to enable this validation at the beginning or at the end of
        4941  // this function, depending on what do you want to check.
        4942  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4943 
        4944  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4945  {
        4946  if(m_FreeSuballocationsBySize.empty())
        4947  {
        4948  m_FreeSuballocationsBySize.push_back(item);
        4949  }
        4950  else
        4951  {
        4952  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
        4953  }
        4954  }
        4955 
        4956  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4957 }
        4958 
        4959 
        4960 void VmaDeviceMemoryBlock::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
        4961 {
        4962  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        4963  VMA_ASSERT(item->size > 0);
        4964 
        4965  // You may want to enable this validation at the beginning or at the end of
        4966  // this function, depending on what do you want to check.
        4967  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4968 
        4969  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        4970  {
        4971  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        4972  m_FreeSuballocationsBySize.data(),
        4973  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        4974  item,
        4975  VmaSuballocationItemSizeLess());
        4976  for(size_t index = it - m_FreeSuballocationsBySize.data();
        4977  index < m_FreeSuballocationsBySize.size();
        4978  ++index)
        4979  {
        4980  if(m_FreeSuballocationsBySize[index] == item)
        4981  {
        4982  VmaVectorRemove(m_FreeSuballocationsBySize, index);
        4983  return;
        4984  }
        4985  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
        4986  }
        4987  VMA_ASSERT(0 && "Not found.");
        4988  }
        4989 
        4990  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        4991 }
        4992 
        4993 bool VmaDeviceMemoryBlock::ValidateFreeSuballocationList() const
        4994 {
        4995  VkDeviceSize lastSize = 0;
        4996  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
        4997  {
        4998  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
        4999 
        5000  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        5001  {
        5002  VMA_ASSERT(0);
        5003  return false;
        5004  }
        5005  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        5006  {
        5007  VMA_ASSERT(0);
        5008  return false;
        5009  }
        5010  if(it->size < lastSize)
        5011  {
        5012  VMA_ASSERT(0);
        5013  return false;
        5014  }
        5015 
        5016  lastSize = it->size;
        5017  }
        5018  return true;
        5019 }
        5020 
        5021 static void InitStatInfo(VmaStatInfo& outInfo)
        5022 {
        5023  memset(&outInfo, 0, sizeof(outInfo));
        5024  outInfo.AllocationSizeMin = UINT64_MAX;
        5025  outInfo.UnusedRangeSizeMin = UINT64_MAX;
        5026 }
        5027 
        5028 static void CalcAllocationStatInfo(VmaStatInfo& outInfo, const VmaDeviceMemoryBlock& block)
        5029 {
        5030  outInfo.BlockCount = 1;
        5031 
        5032  const uint32_t rangeCount = (uint32_t)block.m_Suballocations.size();
        5033  outInfo.AllocationCount = rangeCount - block.m_FreeCount;
        5034  outInfo.UnusedRangeCount = block.m_FreeCount;
        5035 
        5036  outInfo.UnusedBytes = block.m_SumFreeSize;
        5037  outInfo.UsedBytes = block.m_Size - outInfo.UnusedBytes;
        5038 
        5039  outInfo.AllocationSizeMin = UINT64_MAX;
        5040  outInfo.AllocationSizeMax = 0;
        5041  outInfo.UnusedRangeSizeMin = UINT64_MAX;
        5042  outInfo.UnusedRangeSizeMax = 0;
        5043 
        5044  for(VmaSuballocationList::const_iterator suballocItem = block.m_Suballocations.cbegin();
        5045  suballocItem != block.m_Suballocations.cend();
        5046  ++suballocItem)
        5047  {
        5048  const VmaSuballocation& suballoc = *suballocItem;
        5049  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        5050  {
        5051  outInfo.AllocationSizeMin = VMA_MIN(outInfo.AllocationSizeMin, suballoc.size);
        5052  outInfo.AllocationSizeMax = VMA_MAX(outInfo.AllocationSizeMax, suballoc.size);
        5053  }
        5054  else
        5055  {
        5056  outInfo.UnusedRangeSizeMin = VMA_MIN(outInfo.UnusedRangeSizeMin, suballoc.size);
        5057  outInfo.UnusedRangeSizeMax = VMA_MAX(outInfo.UnusedRangeSizeMax, suballoc.size);
        5058  }
        5059  }
        5060 }
        5061 
        5062 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
        5063 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
        5064 {
        5065  inoutInfo.BlockCount += srcInfo.BlockCount;
        5066  inoutInfo.AllocationCount += srcInfo.AllocationCount;
        5067  inoutInfo.UnusedRangeCount += srcInfo.UnusedRangeCount;
        5068  inoutInfo.UsedBytes += srcInfo.UsedBytes;
        5069  inoutInfo.UnusedBytes += srcInfo.UnusedBytes;
        5070  inoutInfo.AllocationSizeMin = VMA_MIN(inoutInfo.AllocationSizeMin, srcInfo.AllocationSizeMin);
        5071  inoutInfo.AllocationSizeMax = VMA_MAX(inoutInfo.AllocationSizeMax, srcInfo.AllocationSizeMax);
        5072  inoutInfo.UnusedRangeSizeMin = VMA_MIN(inoutInfo.UnusedRangeSizeMin, srcInfo.UnusedRangeSizeMin);
        5073  inoutInfo.UnusedRangeSizeMax = VMA_MAX(inoutInfo.UnusedRangeSizeMax, srcInfo.UnusedRangeSizeMax);
        5074 }
        5075 
        5076 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
        5077 {
        5078  inoutInfo.AllocationSizeAvg = (inoutInfo.AllocationCount > 0) ?
        5079  VmaRoundDiv<VkDeviceSize>(inoutInfo.UsedBytes, inoutInfo.AllocationCount) : 0;
        5080  inoutInfo.UnusedRangeSizeAvg = (inoutInfo.UnusedRangeCount > 0) ?
        5081  VmaRoundDiv<VkDeviceSize>(inoutInfo.UnusedBytes, inoutInfo.UnusedRangeCount) : 0;
        5082 }
        5083 
        5084 VmaPool_T::VmaPool_T(
        5085  VmaAllocator hAllocator,
        5086  const VmaPoolCreateInfo& createInfo) :
        5087  m_BlockVector(
        5088  hAllocator,
        5089  createInfo.memoryTypeIndex,
        5090  (createInfo.flags & VMA_POOL_CREATE_PERSISTENT_MAP_BIT) != 0 ?
        5091  VMA_BLOCK_VECTOR_TYPE_MAPPED : VMA_BLOCK_VECTOR_TYPE_UNMAPPED,
        5092  createInfo.blockSize,
        5093  createInfo.minBlockCount,
        5094  createInfo.maxBlockCount,
        5095  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        5096  createInfo.frameInUseCount,
        5097  true) // isCustomPool
        5098 {
        5099 }
        5100 
        5101 VmaPool_T::~VmaPool_T()
        5102 {
        5103 }
        5104 
        5105 #if VMA_STATS_STRING_ENABLED
        5106 
        5107 #endif // #if VMA_STATS_STRING_ENABLED
        5108 
        5109 VmaBlockVector::VmaBlockVector(
        5110  VmaAllocator hAllocator,
        5111  uint32_t memoryTypeIndex,
        5112  VMA_BLOCK_VECTOR_TYPE blockVectorType,
        5113  VkDeviceSize preferredBlockSize,
        5114  size_t minBlockCount,
        5115  size_t maxBlockCount,
        5116  VkDeviceSize bufferImageGranularity,
        5117  uint32_t frameInUseCount,
        5118  bool isCustomPool) :
        5119  m_hAllocator(hAllocator),
        5120  m_MemoryTypeIndex(memoryTypeIndex),
        5121  m_BlockVectorType(blockVectorType),
        5122  m_PreferredBlockSize(preferredBlockSize),
        5123  m_MinBlockCount(minBlockCount),
        5124  m_MaxBlockCount(maxBlockCount),
        5125  m_BufferImageGranularity(bufferImageGranularity),
        5126  m_FrameInUseCount(frameInUseCount),
        5127  m_IsCustomPool(isCustomPool),
        5128  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
        5129  m_HasEmptyBlock(false),
        5130  m_pDefragmentator(VMA_NULL)
        5131 {
        5132 }
        5133 
        5134 VmaBlockVector::~VmaBlockVector()
        5135 {
        5136  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
        5137 
        5138  for(size_t i = m_Blocks.size(); i--; )
        5139  {
        5140  m_Blocks[i]->Destroy(m_hAllocator);
        5141  vma_delete(m_hAllocator, m_Blocks[i]);
        5142  }
        5143 }
        5144 
        5145 VkResult VmaBlockVector::CreateMinBlocks()
        5146 {
        5147  for(size_t i = 0; i < m_MinBlockCount; ++i)
        5148  {
        5149  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        5150  if(res != VK_SUCCESS)
        5151  {
        5152  return res;
        5153  }
        5154  }
        5155  return VK_SUCCESS;
        5156 }
        5157 
        5158 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
        5159 {
        5160  pStats->size = 0;
        5161  pStats->unusedSize = 0;
        5162  pStats->allocationCount = 0;
        5163  pStats->unusedRangeCount = 0;
        5164 
        5165  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5166 
        5167  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5168  {
        5169  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        5170  VMA_ASSERT(pBlock);
        5171  VMA_HEAVY_ASSERT(pBlock->Validate());
        5172 
        5173  const uint32_t rangeCount = (uint32_t)pBlock->m_Suballocations.size();
        5174 
        5175  pStats->size += pBlock->m_Size;
        5176  pStats->unusedSize += pBlock->m_SumFreeSize;
        5177  pStats->allocationCount += rangeCount - pBlock->m_FreeCount;
        5178  pStats->unusedRangeCount += pBlock->m_FreeCount;
        5179  }
        5180 }
        5181 
        5182 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
        5183 
        5184 VkResult VmaBlockVector::Allocate(
        5185  VmaPool hCurrentPool,
        5186  uint32_t currentFrameIndex,
        5187  const VkMemoryRequirements& vkMemReq,
        5188  const VmaAllocationCreateInfo& createInfo,
        5189  VmaSuballocationType suballocType,
        5190  VmaAllocation* pAllocation)
        5191 {
        5192  // Validate flags.
        5193  if(((createInfo.flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0) !=
        5194  (m_BlockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED))
        5195  {
        5196  VMA_ASSERT(0 && "Usage of VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT must match VMA_POOL_CREATE_PERSISTENT_MAP_BIT.");
        5197  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        5198  }
        5199 
        5200  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5201 
        5202  // 1. Search existing allocations. Try to allocate without making other allocations lost.
        5203  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        5204  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        5205  {
        5206  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        5207  VMA_ASSERT(pCurrBlock);
        5208  VmaAllocationRequest currRequest = {};
        5209  if(pCurrBlock->CreateAllocationRequest(
        5210  currentFrameIndex,
        5211  m_FrameInUseCount,
        5212  m_BufferImageGranularity,
        5213  vkMemReq.size,
        5214  vkMemReq.alignment,
        5215  suballocType,
        5216  false, // canMakeOtherLost
        5217  &currRequest))
        5218  {
        5219  // Allocate from pCurrBlock.
        5220  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
        5221 
        5222  // We no longer have an empty Allocation.
        5223  if(pCurrBlock->IsEmpty())
        5224  {
        5225  m_HasEmptyBlock = false;
        5226  }
        5227 
        5228  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex);
        5229  pCurrBlock->Alloc(currRequest, suballocType, vkMemReq.size, *pAllocation);
        5230  (*pAllocation)->InitBlockAllocation(
        5231  hCurrentPool,
        5232  pCurrBlock,
        5233  currRequest.offset,
        5234  vkMemReq.alignment,
        5235  vkMemReq.size,
        5236  suballocType,
        5237  createInfo.pUserData,
        5238  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        5239  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
        5240  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        5241  return VK_SUCCESS;
        5242  }
        5243  }
        5244 
        5245  const bool canCreateNewBlock =
        5246  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        5247  (m_Blocks.size() < m_MaxBlockCount);
        5248 
        5249  // 2. Try to create new block.
        5250  if(canCreateNewBlock)
        5251  {
        5252  // 2.1. Start with full preferredBlockSize.
        5253  VkDeviceSize blockSize = m_PreferredBlockSize;
        5254  size_t newBlockIndex = 0;
        5255  VkResult res = CreateBlock(blockSize, &newBlockIndex);
        5256  // Allocating blocks of other sizes is allowed only in default pools.
        5257  // In custom pools block size is fixed.
        5258  if(res < 0 && m_IsCustomPool == false)
        5259  {
        5260  // 2.2. Try half the size.
        5261  blockSize /= 2;
        5262  if(blockSize >= vkMemReq.size)
        5263  {
        5264  res = CreateBlock(blockSize, &newBlockIndex);
        5265  if(res < 0)
        5266  {
        5267  // 2.3. Try quarter the size.
        5268  blockSize /= 2;
        5269  if(blockSize >= vkMemReq.size)
        5270  {
        5271  res = CreateBlock(blockSize, &newBlockIndex);
        5272  }
        5273  }
        5274  }
        5275  }
        5276  if(res == VK_SUCCESS)
        5277  {
        5278  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
        5279  VMA_ASSERT(pBlock->m_Size >= vkMemReq.size);
        5280 
        5281  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
        5282  VmaAllocationRequest allocRequest = {};
        5283  allocRequest.item = pBlock->m_Suballocations.begin();
        5284  allocRequest.offset = 0;
        5285  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex);
        5286  pBlock->Alloc(allocRequest, suballocType, vkMemReq.size, *pAllocation);
        5287  (*pAllocation)->InitBlockAllocation(
        5288  hCurrentPool,
        5289  pBlock,
        5290  allocRequest.offset,
        5291  vkMemReq.alignment,
        5292  vkMemReq.size,
        5293  suballocType,
        5294  createInfo.pUserData,
        5295  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        5296  VMA_HEAVY_ASSERT(pBlock->Validate());
        5297  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
        5298 
        5299  return VK_SUCCESS;
        5300  }
        5301  }
        5302 
        5303  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
        5304 
        5305  // 3. Try to allocate from existing blocks with making other allocations lost.
        5306  if(canMakeOtherLost)
        5307  {
        5308  uint32_t tryIndex = 0;
        5309  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
        5310  {
        5311  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
        5312  VmaAllocationRequest bestRequest = {};
        5313  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
        5314 
        5315  // 1. Search existing allocations.
        5316  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        5317  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        5318  {
        5319  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        5320  VMA_ASSERT(pCurrBlock);
        5321  VmaAllocationRequest currRequest = {};
        5322  if(pCurrBlock->CreateAllocationRequest(
        5323  currentFrameIndex,
        5324  m_FrameInUseCount,
        5325  m_BufferImageGranularity,
        5326  vkMemReq.size,
        5327  vkMemReq.alignment,
        5328  suballocType,
        5329  canMakeOtherLost,
        5330  &currRequest))
        5331  {
        5332  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        5333  if(pBestRequestBlock == VMA_NULL ||
        5334  currRequestCost < bestRequestCost)
        5335  {
        5336  pBestRequestBlock = pCurrBlock;
        5337  bestRequest = currRequest;
        5338  bestRequestCost = currRequestCost;
        5339 
        5340  if(bestRequestCost == 0)
        5341  {
        5342  break;
        5343  }
        5344  }
        5345  }
        5346  }
        5347 
        5348  if(pBestRequestBlock != VMA_NULL)
        5349  {
        5350  if(pBestRequestBlock->MakeRequestedAllocationsLost(
        5351  currentFrameIndex,
        5352  m_FrameInUseCount,
        5353  &bestRequest))
        5354  {
        5355  // We no longer have an empty Allocation.
        5356  if(pBestRequestBlock->IsEmpty())
        5357  {
        5358  m_HasEmptyBlock = false;
        5359  }
        5360  // Allocate from this pBlock.
        5361  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex);
        5362  pBestRequestBlock->Alloc(bestRequest, suballocType, vkMemReq.size, *pAllocation);
        5363  (*pAllocation)->InitBlockAllocation(
        5364  hCurrentPool,
        5365  pBestRequestBlock,
        5366  bestRequest.offset,
        5367  vkMemReq.alignment,
        5368  vkMemReq.size,
        5369  suballocType,
        5370  createInfo.pUserData,
        5371  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        5372  VMA_HEAVY_ASSERT(pBlock->Validate());
        5373  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        5374  return VK_SUCCESS;
        5375  }
        5376  // else: Some allocations must have been touched while we are here. Next try.
        5377  }
        5378  else
        5379  {
        5380  // Could not find place in any of the blocks - break outer loop.
        5381  break;
        5382  }
        5383  }
        5384  /* Maximum number of tries exceeded - a very unlike event when many other
        5385  threads are simultaneously touching allocations making it impossible to make
        5386  lost at the same time as we try to allocate. */
        5387  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
        5388  {
        5389  return VK_ERROR_TOO_MANY_OBJECTS;
        5390  }
        5391  }
        5392 
        5393  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        5394 }
        5395 
        5396 void VmaBlockVector::Free(
        5397  VmaAllocation hAllocation)
        5398 {
        5399  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
        5400 
        5401  // Scope for lock.
        5402  {
        5403  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5404 
        5405  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        5406 
        5407  pBlock->Free(hAllocation);
        5408  VMA_HEAVY_ASSERT(pBlock->Validate());
        5409 
        5410  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
        5411 
        5412  // pBlock became empty after this deallocation.
        5413  if(pBlock->IsEmpty())
        5414  {
        5415  // Already has empty Allocation. We don't want to have two, so delete this one.
        5416  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
        5417  {
        5418  pBlockToDelete = pBlock;
        5419  Remove(pBlock);
        5420  }
        5421  // We now have first empty Allocation.
        5422  else
        5423  {
        5424  m_HasEmptyBlock = true;
        5425  }
        5426  }
        5427  // Must be called after srcBlockIndex is used, because later it may become invalid!
        5428  IncrementallySortBlocks();
        5429  }
        5430 
        5431  // Destruction of a free Allocation. Deferred until this point, outside of mutex
        5432  // lock, for performance reason.
        5433  if(pBlockToDelete != VMA_NULL)
        5434  {
        5435  VMA_DEBUG_LOG(" Deleted empty allocation");
        5436  pBlockToDelete->Destroy(m_hAllocator);
        5437  vma_delete(m_hAllocator, pBlockToDelete);
        5438  }
        5439 }
        5440 
        5441 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
        5442 {
        5443  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5444  {
        5445  if(m_Blocks[blockIndex] == pBlock)
        5446  {
        5447  VmaVectorRemove(m_Blocks, blockIndex);
        5448  return;
        5449  }
        5450  }
        5451  VMA_ASSERT(0);
        5452 }
        5453 
        5454 void VmaBlockVector::IncrementallySortBlocks()
        5455 {
        5456  // Bubble sort only until first swap.
        5457  for(size_t i = 1; i < m_Blocks.size(); ++i)
        5458  {
        5459  if(m_Blocks[i - 1]->m_SumFreeSize > m_Blocks[i]->m_SumFreeSize)
        5460  {
        5461  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
        5462  return;
        5463  }
        5464  }
        5465 }
        5466 
        5467 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
        5468 {
        5469  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        5470  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
        5471  allocInfo.allocationSize = blockSize;
        5472  const VkDevice hDevice = m_hAllocator->m_hDevice;
        5473  VkDeviceMemory mem = VK_NULL_HANDLE;
        5474  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
        5475  if(res < 0)
        5476  {
        5477  return res;
        5478  }
        5479 
        5480  // New VkDeviceMemory successfully created.
        5481 
        5482  // Map memory if needed.
        5483  void* pMappedData = VMA_NULL;
        5484  const bool persistentMap = (m_BlockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED);
        5485  if(persistentMap && m_hAllocator->m_UnmapPersistentlyMappedMemoryCounter == 0)
        5486  {
        5487  res = vkMapMemory(hDevice, mem, 0, VK_WHOLE_SIZE, 0, &pMappedData);
        5488  if(res < 0)
        5489  {
        5490  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        5491  m_hAllocator->FreeVulkanMemory(m_MemoryTypeIndex, blockSize, mem);
        5492  return res;
        5493  }
        5494  }
        5495 
        5496  // Create new Allocation for it.
        5497  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
        5498  pBlock->Init(
        5499  m_MemoryTypeIndex,
        5500  (VMA_BLOCK_VECTOR_TYPE)m_BlockVectorType,
        5501  mem,
        5502  allocInfo.allocationSize,
        5503  persistentMap,
        5504  pMappedData);
        5505 
        5506  m_Blocks.push_back(pBlock);
        5507  if(pNewBlockIndex != VMA_NULL)
        5508  {
        5509  *pNewBlockIndex = m_Blocks.size() - 1;
        5510  }
        5511 
        5512  return VK_SUCCESS;
        5513 }
        5514 
        5515 #if VMA_STATS_STRING_ENABLED
        5516 
        5517 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
        5518 {
        5519  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5520 
        5521  json.BeginObject();
        5522 
        5523  if(m_IsCustomPool)
        5524  {
        5525  json.WriteString("MemoryTypeIndex");
        5526  json.WriteNumber(m_MemoryTypeIndex);
        5527 
        5528  if(m_BlockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED)
        5529  {
        5530  json.WriteString("Mapped");
        5531  json.WriteBool(true);
        5532  }
        5533 
        5534  json.WriteString("BlockSize");
        5535  json.WriteNumber(m_PreferredBlockSize);
        5536 
        5537  json.WriteString("BlockCount");
        5538  json.BeginObject(true);
        5539  if(m_MinBlockCount > 0)
        5540  {
        5541  json.WriteString("Min");
        5542  json.WriteNumber(m_MinBlockCount);
        5543  }
        5544  if(m_MaxBlockCount < SIZE_MAX)
        5545  {
        5546  json.WriteString("Max");
        5547  json.WriteNumber(m_MaxBlockCount);
        5548  }
        5549  json.WriteString("Cur");
        5550  json.WriteNumber(m_Blocks.size());
        5551  json.EndObject();
        5552 
        5553  if(m_FrameInUseCount > 0)
        5554  {
        5555  json.WriteString("FrameInUseCount");
        5556  json.WriteNumber(m_FrameInUseCount);
        5557  }
        5558  }
        5559  else
        5560  {
        5561  json.WriteString("PreferredBlockSize");
        5562  json.WriteNumber(m_PreferredBlockSize);
        5563  }
        5564 
        5565  json.WriteString("Blocks");
        5566  json.BeginArray();
        5567  for(size_t i = 0; i < m_Blocks.size(); ++i)
        5568  {
        5569  m_Blocks[i]->PrintDetailedMap(json);
        5570  }
        5571  json.EndArray();
        5572 
        5573  json.EndObject();
        5574 }
        5575 
        5576 #endif // #if VMA_STATS_STRING_ENABLED
        5577 
        5578 void VmaBlockVector::UnmapPersistentlyMappedMemory()
        5579 {
        5580  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5581 
        5582  for(size_t i = m_Blocks.size(); i--; )
        5583  {
        5584  VmaDeviceMemoryBlock* pBlock = m_Blocks[i];
        5585  if(pBlock->m_pMappedData != VMA_NULL)
        5586  {
        5587  VMA_ASSERT(pBlock->m_PersistentMap != false);
        5588  vkUnmapMemory(m_hAllocator->m_hDevice, pBlock->m_hMemory);
        5589  pBlock->m_pMappedData = VMA_NULL;
        5590  }
        5591  }
        5592 }
        5593 
        5594 VkResult VmaBlockVector::MapPersistentlyMappedMemory()
        5595 {
        5596  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5597 
        5598  VkResult finalResult = VK_SUCCESS;
        5599  for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
        5600  {
        5601  VmaDeviceMemoryBlock* pBlock = m_Blocks[i];
        5602  if(pBlock->m_PersistentMap)
        5603  {
        5604  VMA_ASSERT(pBlock->m_pMappedData == nullptr);
        5605  VkResult localResult = vkMapMemory(m_hAllocator->m_hDevice, pBlock->m_hMemory, 0, VK_WHOLE_SIZE, 0, &pBlock->m_pMappedData);
        5606  if(localResult != VK_SUCCESS)
        5607  {
        5608  finalResult = localResult;
        5609  }
        5610  }
        5611  }
        5612  return finalResult;
        5613 }
        5614 
        5615 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
        5616  VkDevice hDevice,
        5617  const VkAllocationCallbacks* pAllocationCallbacks,
        5618  uint32_t currentFrameIndex)
        5619 {
        5620  if(m_pDefragmentator == VMA_NULL)
        5621  {
        5622  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
        5623  hDevice,
        5624  pAllocationCallbacks,
        5625  this,
        5626  currentFrameIndex);
        5627  }
        5628 
        5629  return m_pDefragmentator;
        5630 }
        5631 
        5632 VkResult VmaBlockVector::Defragment(
        5633  VmaDefragmentationStats* pDefragmentationStats,
        5634  VkDeviceSize& maxBytesToMove,
        5635  uint32_t& maxAllocationsToMove)
        5636 {
        5637  if(m_pDefragmentator == VMA_NULL)
        5638  {
        5639  return VK_SUCCESS;
        5640  }
        5641 
        5642  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5643 
        5644  // Defragment.
        5645  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
        5646 
        5647  // Accumulate statistics.
        5648  if(pDefragmentationStats != VMA_NULL)
        5649  {
        5650  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
        5651  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
        5652  pDefragmentationStats->bytesMoved += bytesMoved;
        5653  pDefragmentationStats->allocationsMoved += allocationsMoved;
        5654  VMA_ASSERT(bytesMoved <= maxBytesToMove);
        5655  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
        5656  maxBytesToMove -= bytesMoved;
        5657  maxAllocationsToMove -= allocationsMoved;
        5658  }
        5659 
        5660  // Free empty blocks.
        5661  m_HasEmptyBlock = false;
        5662  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        5663  {
        5664  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        5665  if(pBlock->IsEmpty())
        5666  {
        5667  if(m_Blocks.size() > m_MinBlockCount)
        5668  {
        5669  if(pDefragmentationStats != VMA_NULL)
        5670  {
        5671  ++pDefragmentationStats->deviceMemoryBlocksFreed;
        5672  pDefragmentationStats->bytesFreed += pBlock->m_Size;
        5673  }
        5674 
        5675  VmaVectorRemove(m_Blocks, blockIndex);
        5676  pBlock->Destroy(m_hAllocator);
        5677  vma_delete(m_hAllocator, pBlock);
        5678  }
        5679  else
        5680  {
        5681  m_HasEmptyBlock = true;
        5682  }
        5683  }
        5684  }
        5685 
        5686  return result;
        5687 }
        5688 
        5689 void VmaBlockVector::DestroyDefragmentator()
        5690 {
        5691  if(m_pDefragmentator != VMA_NULL)
        5692  {
        5693  vma_delete(m_hAllocator, m_pDefragmentator);
        5694  m_pDefragmentator = VMA_NULL;
        5695  }
        5696 }
        5697 
        5698 void VmaBlockVector::MakePoolAllocationsLost(
        5699  uint32_t currentFrameIndex,
        5700  size_t* pLostAllocationCount)
        5701 {
        5702  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5703 
        5704  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5705  {
        5706  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        5707  VMA_ASSERT(pBlock);
        5708  pBlock->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
        5709  }
        5710 }
        5711 
        5712 void VmaBlockVector::AddStats(VmaStats* pStats)
        5713 {
        5714  const uint32_t memTypeIndex = m_MemoryTypeIndex;
        5715  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
        5716 
        5717  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        5718 
        5719  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        5720  {
        5721  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        5722  VMA_ASSERT(pBlock);
        5723  VMA_HEAVY_ASSERT(pBlock->Validate());
        5724  VmaStatInfo allocationStatInfo;
        5725  CalcAllocationStatInfo(allocationStatInfo, *pBlock);
        5726  VmaAddStatInfo(pStats->total, allocationStatInfo);
        5727  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        5728  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        5729  }
        5730 }
        5731 
        5733 // VmaDefragmentator members definition
        5734 
        5735 VmaDefragmentator::VmaDefragmentator(
        5736  VkDevice hDevice,
        5737  const VkAllocationCallbacks* pAllocationCallbacks,
        5738  VmaBlockVector* pBlockVector,
        5739  uint32_t currentFrameIndex) :
        5740  m_hDevice(hDevice),
        5741  m_pAllocationCallbacks(pAllocationCallbacks),
        5742  m_pBlockVector(pBlockVector),
        5743  m_CurrentFrameIndex(currentFrameIndex),
        5744  m_BytesMoved(0),
        5745  m_AllocationsMoved(0),
        5746  m_Allocations(VmaStlAllocator<AllocationInfo>(pAllocationCallbacks)),
        5747  m_Blocks(VmaStlAllocator<BlockInfo*>(pAllocationCallbacks))
        5748 {
        5749 }
        5750 
        5751 VmaDefragmentator::~VmaDefragmentator()
        5752 {
        5753  for(size_t i = m_Blocks.size(); i--; )
        5754  {
        5755  vma_delete(m_pAllocationCallbacks, m_Blocks[i]);
        5756  }
        5757 }
        5758 
        5759 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        5760 {
        5761  AllocationInfo allocInfo;
        5762  allocInfo.m_hAllocation = hAlloc;
        5763  allocInfo.m_pChanged = pChanged;
        5764  m_Allocations.push_back(allocInfo);
        5765 }
        5766 
        5767 VkResult VmaDefragmentator::DefragmentRound(
        5768  VkDeviceSize maxBytesToMove,
        5769  uint32_t maxAllocationsToMove)
        5770 {
        5771  if(m_Blocks.empty())
        5772  {
        5773  return VK_SUCCESS;
        5774  }
        5775 
        5776  size_t srcBlockIndex = m_Blocks.size() - 1;
        5777  size_t srcAllocIndex = SIZE_MAX;
        5778  for(;;)
        5779  {
        5780  // 1. Find next allocation to move.
        5781  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
        5782  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
        5783  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
        5784  {
        5785  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
        5786  {
        5787  // Finished: no more allocations to process.
        5788  if(srcBlockIndex == 0)
        5789  {
        5790  return VK_SUCCESS;
        5791  }
        5792  else
        5793  {
        5794  --srcBlockIndex;
        5795  srcAllocIndex = SIZE_MAX;
        5796  }
        5797  }
        5798  else
        5799  {
        5800  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
        5801  }
        5802  }
        5803 
        5804  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
        5805  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
        5806 
        5807  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
        5808  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
        5809  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
        5810  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
        5811 
        5812  // 2. Try to find new place for this allocation in preceding or current block.
        5813  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
        5814  {
        5815  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
        5816  VmaAllocationRequest dstAllocRequest;
        5817  if(pDstBlockInfo->m_pBlock->CreateAllocationRequest(
        5818  m_CurrentFrameIndex,
        5819  m_pBlockVector->GetFrameInUseCount(),
        5820  m_pBlockVector->GetBufferImageGranularity(),
        5821  size,
        5822  alignment,
        5823  suballocType,
        5824  false, // canMakeOtherLost
        5825  &dstAllocRequest) &&
        5826  MoveMakesSense(
        5827  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
        5828  {
        5829  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
        5830 
        5831  // Reached limit on number of allocations or bytes to move.
        5832  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
        5833  (m_BytesMoved + size > maxBytesToMove))
        5834  {
        5835  return VK_INCOMPLETE;
        5836  }
        5837 
        5838  void* pDstMappedData = VMA_NULL;
        5839  VkResult res = pDstBlockInfo->EnsureMapping(m_hDevice, &pDstMappedData);
        5840  if(res != VK_SUCCESS)
        5841  {
        5842  return res;
        5843  }
        5844 
        5845  void* pSrcMappedData = VMA_NULL;
        5846  res = pSrcBlockInfo->EnsureMapping(m_hDevice, &pSrcMappedData);
        5847  if(res != VK_SUCCESS)
        5848  {
        5849  return res;
        5850  }
        5851 
        5852  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
        5853  memcpy(
        5854  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
        5855  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
        5856  static_cast<size_t>(size));
        5857 
        5858  pDstBlockInfo->m_pBlock->Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);
        5859  pSrcBlockInfo->m_pBlock->Free(allocInfo.m_hAllocation);
        5860 
        5861  allocInfo.m_hAllocation->ChangeBlockAllocation(pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
        5862 
        5863  if(allocInfo.m_pChanged != VMA_NULL)
        5864  {
        5865  *allocInfo.m_pChanged = VK_TRUE;
        5866  }
        5867 
        5868  ++m_AllocationsMoved;
        5869  m_BytesMoved += size;
        5870 
        5871  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
        5872 
        5873  break;
        5874  }
        5875  }
        5876 
        5877  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
        5878 
        5879  if(srcAllocIndex > 0)
        5880  {
        5881  --srcAllocIndex;
        5882  }
        5883  else
        5884  {
        5885  if(srcBlockIndex > 0)
        5886  {
        5887  --srcBlockIndex;
        5888  srcAllocIndex = SIZE_MAX;
        5889  }
        5890  else
        5891  {
        5892  return VK_SUCCESS;
        5893  }
        5894  }
        5895  }
        5896 }
        5897 
        5898 VkResult VmaDefragmentator::Defragment(
        5899  VkDeviceSize maxBytesToMove,
        5900  uint32_t maxAllocationsToMove)
        5901 {
        5902  if(m_Allocations.empty())
        5903  {
        5904  return VK_SUCCESS;
        5905  }
        5906 
        5907  // Create block info for each block.
        5908  const size_t blockCount = m_pBlockVector->m_Blocks.size();
        5909  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        5910  {
        5911  BlockInfo* pBlockInfo = vma_new(m_pAllocationCallbacks, BlockInfo)(m_pAllocationCallbacks);
        5912  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
        5913  m_Blocks.push_back(pBlockInfo);
        5914  }
        5915 
        5916  // Sort them by m_pBlock pointer value.
        5917  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
        5918 
        5919  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
        5920  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
        5921  {
        5922  AllocationInfo& allocInfo = m_Allocations[blockIndex];
        5923  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
        5924  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        5925  {
        5926  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
        5927  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
        5928  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
        5929  {
        5930  (*it)->m_Allocations.push_back(allocInfo);
        5931  }
        5932  else
        5933  {
        5934  VMA_ASSERT(0);
        5935  }
        5936  }
        5937  }
        5938  m_Allocations.clear();
        5939 
        5940  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        5941  {
        5942  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
        5943  pBlockInfo->CalcHasNonMovableAllocations();
        5944  pBlockInfo->SortAllocationsBySizeDescecnding();
        5945  }
        5946 
        5947  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
        5948  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
        5949 
        5950  // Execute defragmentation rounds (the main part).
        5951  VkResult result = VK_SUCCESS;
        5952  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
        5953  {
        5954  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
        5955  }
        5956 
        5957  // Unmap blocks that were mapped for defragmentation.
        5958  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        5959  {
        5960  m_Blocks[blockIndex]->Unmap(m_hDevice);
        5961  }
        5962 
        5963  return result;
        5964 }
        5965 
        5966 bool VmaDefragmentator::MoveMakesSense(
        5967  size_t dstBlockIndex, VkDeviceSize dstOffset,
        5968  size_t srcBlockIndex, VkDeviceSize srcOffset)
        5969 {
        5970  if(dstBlockIndex < srcBlockIndex)
        5971  {
        5972  return true;
        5973  }
        5974  if(dstBlockIndex > srcBlockIndex)
        5975  {
        5976  return false;
        5977  }
        5978  if(dstOffset < srcOffset)
        5979  {
        5980  return true;
        5981  }
        5982  return false;
        5983 }
        5984 
        5986 // VmaAllocator_T
        5987 
        5988 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
        5989  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        5990  m_PhysicalDevice(pCreateInfo->physicalDevice),
        5991  m_hDevice(pCreateInfo->device),
        5992  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
        5993  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        5994  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
        5995  m_UnmapPersistentlyMappedMemoryCounter(0),
        5996  m_PreferredLargeHeapBlockSize(0),
        5997  m_PreferredSmallHeapBlockSize(0),
        5998  m_CurrentFrameIndex(0),
        5999  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks()))
        6000 {
        6001  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
        6002 
        6003  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
        6004  memset(&m_MemProps, 0, sizeof(m_MemProps));
        6005  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        6006 
        6007  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
        6008  memset(&m_pOwnAllocations, 0, sizeof(m_pOwnAllocations));
        6009 
        6010  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        6011  {
        6012  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
        6013  }
        6014 
        6015  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
        6016  {
        6017  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        6018  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        6019  }
        6020 
        6021  vkGetPhysicalDeviceProperties(m_PhysicalDevice, &m_PhysicalDeviceProperties);
        6022  vkGetPhysicalDeviceMemoryProperties(m_PhysicalDevice, &m_MemProps);
        6023 
        6024  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        6025  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        6026  m_PreferredSmallHeapBlockSize = (pCreateInfo->preferredSmallHeapBlockSize != 0) ?
        6027  pCreateInfo->preferredSmallHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE);
        6028 
        6029  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
        6030  {
        6031  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        6032  {
        6033  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
        6034  if(limit != VK_WHOLE_SIZE)
        6035  {
        6036  m_HeapSizeLimit[heapIndex] = limit;
        6037  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
        6038  {
        6039  m_MemProps.memoryHeaps[heapIndex].size = limit;
        6040  }
        6041  }
        6042  }
        6043  }
        6044 
        6045  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6046  {
        6047  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
        6048 
        6049  for(size_t blockVectorTypeIndex = 0; blockVectorTypeIndex < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorTypeIndex)
        6050  {
        6051  m_pBlockVectors[memTypeIndex][blockVectorTypeIndex] = vma_new(this, VmaBlockVector)(
        6052  this,
        6053  memTypeIndex,
        6054  static_cast<VMA_BLOCK_VECTOR_TYPE>(blockVectorTypeIndex),
        6055  preferredBlockSize,
        6056  0,
        6057  SIZE_MAX,
        6058  GetBufferImageGranularity(),
        6059  pCreateInfo->frameInUseCount,
        6060  false); // isCustomPool
        6061  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
        6062  // becase minBlockCount is 0.
        6063  m_pOwnAllocations[memTypeIndex][blockVectorTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
        6064  }
        6065  }
        6066 }
        6067 
        6068 VmaAllocator_T::~VmaAllocator_T()
        6069 {
        6070  VMA_ASSERT(m_Pools.empty());
        6071 
        6072  for(size_t i = GetMemoryTypeCount(); i--; )
        6073  {
        6074  for(size_t j = VMA_BLOCK_VECTOR_TYPE_COUNT; j--; )
        6075  {
        6076  vma_delete(this, m_pOwnAllocations[i][j]);
        6077  vma_delete(this, m_pBlockVectors[i][j]);
        6078  }
        6079  }
        6080 }
        6081 
        6082 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
        6083 {
        6084  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        6085  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        6086  return (heapSize <= VMA_SMALL_HEAP_MAX_SIZE) ?
        6087  m_PreferredSmallHeapBlockSize : m_PreferredLargeHeapBlockSize;
        6088 }
        6089 
        6090 VkResult VmaAllocator_T::AllocateMemoryOfType(
        6091  const VkMemoryRequirements& vkMemReq,
        6092  const VmaAllocationCreateInfo& createInfo,
        6093  uint32_t memTypeIndex,
        6094  VmaSuballocationType suballocType,
        6095  VmaAllocation* pAllocation)
        6096 {
        6097  VMA_ASSERT(pAllocation != VMA_NULL);
        6098  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
        6099 
        6100  uint32_t blockVectorType = VmaAllocationCreateFlagsToBlockVectorType(createInfo.flags);
        6101  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex][blockVectorType];
        6102  VMA_ASSERT(blockVector);
        6103 
        6104  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        6105  // Heuristics: Allocate own memory if requested size if greater than half of preferred block size.
        6106  const bool ownMemory =
        6107  (createInfo.flags & VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT) != 0 ||
        6108  VMA_DEBUG_ALWAYS_OWN_MEMORY ||
        6109  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
        6110  vkMemReq.size > preferredBlockSize / 2);
        6111 
        6112  if(ownMemory)
        6113  {
        6114  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        6115  {
        6116  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6117  }
        6118  else
        6119  {
        6120  return AllocateOwnMemory(
        6121  vkMemReq.size,
        6122  suballocType,
        6123  memTypeIndex,
        6124  (createInfo.flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0,
        6125  createInfo.pUserData,
        6126  pAllocation);
        6127  }
        6128  }
        6129  else
        6130  {
        6131  VkResult res = blockVector->Allocate(
        6132  VK_NULL_HANDLE, // hCurrentPool
        6133  m_CurrentFrameIndex.load(),
        6134  vkMemReq,
        6135  createInfo,
        6136  suballocType,
        6137  pAllocation);
        6138  if(res == VK_SUCCESS)
        6139  {
        6140  return res;
        6141  }
        6142 
        6143  // 5. Try own memory.
        6144  res = AllocateOwnMemory(
        6145  vkMemReq.size,
        6146  suballocType,
        6147  memTypeIndex,
        6148  (createInfo.flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0,
        6149  createInfo.pUserData,
        6150  pAllocation);
        6151  if(res == VK_SUCCESS)
        6152  {
        6153  // Succeeded: AllocateOwnMemory function already filld pMemory, nothing more to do here.
        6154  VMA_DEBUG_LOG(" Allocated as OwnMemory");
        6155  return VK_SUCCESS;
        6156  }
        6157  else
        6158  {
        6159  // Everything failed: Return error code.
        6160  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        6161  return res;
        6162  }
        6163  }
        6164 }
        6165 
        6166 VkResult VmaAllocator_T::AllocateOwnMemory(
        6167  VkDeviceSize size,
        6168  VmaSuballocationType suballocType,
        6169  uint32_t memTypeIndex,
        6170  bool map,
        6171  void* pUserData,
        6172  VmaAllocation* pAllocation)
        6173 {
        6174  VMA_ASSERT(pAllocation);
        6175 
        6176  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        6177  allocInfo.memoryTypeIndex = memTypeIndex;
        6178  allocInfo.allocationSize = size;
        6179 
        6180  // Allocate VkDeviceMemory.
        6181  VkDeviceMemory hMemory = VK_NULL_HANDLE;
        6182  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
        6183  if(res < 0)
        6184  {
        6185  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        6186  return res;
        6187  }
        6188 
        6189  void* pMappedData = nullptr;
        6190  if(map)
        6191  {
        6192  if(m_UnmapPersistentlyMappedMemoryCounter == 0)
        6193  {
        6194  res = vkMapMemory(m_hDevice, hMemory, 0, VK_WHOLE_SIZE, 0, &pMappedData);
        6195  if(res < 0)
        6196  {
        6197  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        6198  FreeVulkanMemory(memTypeIndex, size, hMemory);
        6199  return res;
        6200  }
        6201  }
        6202  }
        6203 
        6204  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load());
        6205  (*pAllocation)->InitOwnAllocation(memTypeIndex, hMemory, suballocType, map, pMappedData, size, pUserData);
        6206 
        6207  // Register it in m_pOwnAllocations.
        6208  {
        6209  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6210  AllocationVectorType* pOwnAllocations = m_pOwnAllocations[memTypeIndex][map ? VMA_BLOCK_VECTOR_TYPE_MAPPED : VMA_BLOCK_VECTOR_TYPE_UNMAPPED];
        6211  VMA_ASSERT(pOwnAllocations);
        6212  VmaVectorInsertSorted<VmaPointerLess>(*pOwnAllocations, *pAllocation);
        6213  }
        6214 
        6215  VMA_DEBUG_LOG(" Allocated OwnMemory MemoryTypeIndex=#%u", memTypeIndex);
        6216 
        6217  return VK_SUCCESS;
        6218 }
        6219 
        6220 VkResult VmaAllocator_T::AllocateMemory(
        6221  const VkMemoryRequirements& vkMemReq,
        6222  const VmaAllocationCreateInfo& createInfo,
        6223  VmaSuballocationType suballocType,
        6224  VmaAllocation* pAllocation)
        6225 {
        6226  if((createInfo.flags & VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT) != 0 &&
        6227  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        6228  {
        6229  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        6230  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6231  }
        6232  if((createInfo.pool != VK_NULL_HANDLE) &&
        6233  ((createInfo.flags & (VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT)) != 0))
        6234  {
        6235  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT when pool != null is invalid.");
        6236  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6237  }
        6238 
        6239  if(createInfo.pool != VK_NULL_HANDLE)
        6240  {
        6241  return createInfo.pool->m_BlockVector.Allocate(
        6242  createInfo.pool,
        6243  m_CurrentFrameIndex.load(),
        6244  vkMemReq,
        6245  createInfo,
        6246  suballocType,
        6247  pAllocation);
        6248  }
        6249  else
        6250  {
        6251  // Bit mask of memory Vulkan types acceptable for this allocation.
        6252  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        6253  uint32_t memTypeIndex = UINT32_MAX;
        6254  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        6255  if(res == VK_SUCCESS)
        6256  {
        6257  res = AllocateMemoryOfType(vkMemReq, createInfo, memTypeIndex, suballocType, pAllocation);
        6258  // Succeeded on first try.
        6259  if(res == VK_SUCCESS)
        6260  {
        6261  return res;
        6262  }
        6263  // Allocation from this memory type failed. Try other compatible memory types.
        6264  else
        6265  {
        6266  for(;;)
        6267  {
        6268  // Remove old memTypeIndex from list of possibilities.
        6269  memoryTypeBits &= ~(1u << memTypeIndex);
        6270  // Find alternative memTypeIndex.
        6271  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        6272  if(res == VK_SUCCESS)
        6273  {
        6274  res = AllocateMemoryOfType(vkMemReq, createInfo, memTypeIndex, suballocType, pAllocation);
        6275  // Allocation from this alternative memory type succeeded.
        6276  if(res == VK_SUCCESS)
        6277  {
        6278  return res;
        6279  }
        6280  // else: Allocation from this memory type failed. Try next one - next loop iteration.
        6281  }
        6282  // No other matching memory type index could be found.
        6283  else
        6284  {
        6285  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        6286  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6287  }
        6288  }
        6289  }
        6290  }
        6291  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        6292  else
        6293  return res;
        6294  }
        6295 }
        6296 
        6297 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
        6298 {
        6299  VMA_ASSERT(allocation);
        6300 
        6301  if(allocation->CanBecomeLost() == false ||
        6302  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        6303  {
        6304  switch(allocation->GetType())
        6305  {
        6306  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        6307  {
        6308  VmaBlockVector* pBlockVector = VMA_NULL;
        6309  VmaPool hPool = allocation->GetPool();
        6310  if(hPool != VK_NULL_HANDLE)
        6311  {
        6312  pBlockVector = &hPool->m_BlockVector;
        6313  }
        6314  else
        6315  {
        6316  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        6317  const VMA_BLOCK_VECTOR_TYPE blockVectorType = allocation->GetBlockVectorType();
        6318  pBlockVector = m_pBlockVectors[memTypeIndex][blockVectorType];
        6319  }
        6320  pBlockVector->Free(allocation);
        6321  }
        6322  break;
        6323  case VmaAllocation_T::ALLOCATION_TYPE_OWN:
        6324  FreeOwnMemory(allocation);
        6325  break;
        6326  default:
        6327  VMA_ASSERT(0);
        6328  }
        6329  }
        6330 
        6331  vma_delete(this, allocation);
        6332 }
        6333 
        6334 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
        6335 {
        6336  // Initialize.
        6337  InitStatInfo(pStats->total);
        6338  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        6339  InitStatInfo(pStats->memoryType[i]);
        6340  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        6341  InitStatInfo(pStats->memoryHeap[i]);
        6342 
        6343  // Process default pools.
        6344  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6345  {
        6346  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        6347  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6348  {
        6349  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex][blockVectorType];
        6350  VMA_ASSERT(pBlockVector);
        6351  pBlockVector->AddStats(pStats);
        6352  }
        6353  }
        6354 
        6355  // Process custom pools.
        6356  {
        6357  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6358  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        6359  {
        6360  m_Pools[poolIndex]->GetBlockVector().AddStats(pStats);
        6361  }
        6362  }
        6363 
        6364  // Process own allocations.
        6365  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6366  {
        6367  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        6368  VmaMutexLock ownAllocationsLock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6369  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6370  {
        6371  AllocationVectorType* const pOwnAllocVector = m_pOwnAllocations[memTypeIndex][blockVectorType];
        6372  VMA_ASSERT(pOwnAllocVector);
        6373  for(size_t allocIndex = 0, allocCount = pOwnAllocVector->size(); allocIndex < allocCount; ++allocIndex)
        6374  {
        6375  VmaStatInfo allocationStatInfo;
        6376  (*pOwnAllocVector)[allocIndex]->OwnAllocCalcStatsInfo(allocationStatInfo);
        6377  VmaAddStatInfo(pStats->total, allocationStatInfo);
        6378  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        6379  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        6380  }
        6381  }
        6382  }
        6383 
        6384  // Postprocess.
        6385  VmaPostprocessCalcStatInfo(pStats->total);
        6386  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
        6387  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
        6388  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
        6389  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
        6390 }
        6391 
        6392 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
        6393 
        6394 void VmaAllocator_T::UnmapPersistentlyMappedMemory()
        6395 {
        6396  if(m_UnmapPersistentlyMappedMemoryCounter++ == 0)
        6397  {
        6398  if(m_PhysicalDeviceProperties.vendorID == VMA_VENDOR_ID_AMD)
        6399  {
        6400  for(uint32_t memTypeIndex = m_MemProps.memoryTypeCount; memTypeIndex--; )
        6401  {
        6402  const VkMemoryPropertyFlags memFlags = m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        6403  if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0 &&
        6404  (memFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        6405  {
        6406  // Process OwnAllocations.
        6407  {
        6408  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6409  AllocationVectorType* pOwnAllocationsVector = m_pOwnAllocations[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6410  for(size_t ownAllocIndex = pOwnAllocationsVector->size(); ownAllocIndex--; )
        6411  {
        6412  VmaAllocation hAlloc = (*pOwnAllocationsVector)[ownAllocIndex];
        6413  hAlloc->OwnAllocUnmapPersistentlyMappedMemory(m_hDevice);
        6414  }
        6415  }
        6416 
        6417  // Process normal Allocations.
        6418  {
        6419  VmaBlockVector* pBlockVector = m_pBlockVectors[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6420  pBlockVector->UnmapPersistentlyMappedMemory();
        6421  }
        6422  }
        6423  }
        6424 
        6425  // Process custom pools.
        6426  {
        6427  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6428  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        6429  {
        6430  m_Pools[poolIndex]->GetBlockVector().UnmapPersistentlyMappedMemory();
        6431  }
        6432  }
        6433  }
        6434  }
        6435 }
        6436 
        6437 VkResult VmaAllocator_T::MapPersistentlyMappedMemory()
        6438 {
        6439  VMA_ASSERT(m_UnmapPersistentlyMappedMemoryCounter > 0);
        6440  if(--m_UnmapPersistentlyMappedMemoryCounter == 0)
        6441  {
        6442  VkResult finalResult = VK_SUCCESS;
        6443  if(m_PhysicalDeviceProperties.vendorID == VMA_VENDOR_ID_AMD)
        6444  {
        6445  // Process custom pools.
        6446  {
        6447  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6448  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        6449  {
        6450  m_Pools[poolIndex]->GetBlockVector().MapPersistentlyMappedMemory();
        6451  }
        6452  }
        6453 
        6454  for(uint32_t memTypeIndex = 0; memTypeIndex < m_MemProps.memoryTypeCount; ++memTypeIndex)
        6455  {
        6456  const VkMemoryPropertyFlags memFlags = m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        6457  if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0 &&
        6458  (memFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        6459  {
        6460  // Process OwnAllocations.
        6461  {
        6462  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6463  AllocationVectorType* pAllocationsVector = m_pOwnAllocations[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6464  for(size_t ownAllocIndex = 0, ownAllocCount = pAllocationsVector->size(); ownAllocIndex < ownAllocCount; ++ownAllocIndex)
        6465  {
        6466  VmaAllocation hAlloc = (*pAllocationsVector)[ownAllocIndex];
        6467  hAlloc->OwnAllocMapPersistentlyMappedMemory(m_hDevice);
        6468  }
        6469  }
        6470 
        6471  // Process normal Allocations.
        6472  {
        6473  VmaBlockVector* pBlockVector = m_pBlockVectors[memTypeIndex][VMA_BLOCK_VECTOR_TYPE_MAPPED];
        6474  VkResult localResult = pBlockVector->MapPersistentlyMappedMemory();
        6475  if(localResult != VK_SUCCESS)
        6476  {
        6477  finalResult = localResult;
        6478  }
        6479  }
        6480  }
        6481  }
        6482  }
        6483  return finalResult;
        6484  }
        6485  else
        6486  return VK_SUCCESS;
        6487 }
        6488 
        6489 VkResult VmaAllocator_T::Defragment(
        6490  VmaAllocation* pAllocations,
        6491  size_t allocationCount,
        6492  VkBool32* pAllocationsChanged,
        6493  const VmaDefragmentationInfo* pDefragmentationInfo,
        6494  VmaDefragmentationStats* pDefragmentationStats)
        6495 {
        6496  if(pAllocationsChanged != VMA_NULL)
        6497  {
        6498  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
        6499  }
        6500  if(pDefragmentationStats != VMA_NULL)
        6501  {
        6502  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
        6503  }
        6504 
        6505  if(m_UnmapPersistentlyMappedMemoryCounter > 0)
        6506  {
        6507  VMA_DEBUG_LOG("ERROR: Cannot defragment when inside vmaUnmapPersistentlyMappedMemory.");
        6508  return VK_ERROR_MEMORY_MAP_FAILED;
        6509  }
        6510 
        6511  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
        6512 
        6513  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
        6514 
        6515  const size_t poolCount = m_Pools.size();
        6516 
        6517  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
        6518  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        6519  {
        6520  VmaAllocation hAlloc = pAllocations[allocIndex];
        6521  VMA_ASSERT(hAlloc);
        6522  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
        6523  // OwnAlloc cannot be defragmented.
        6524  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
        6525  // Only HOST_VISIBLE memory types can be defragmented.
        6526  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&
        6527  // Lost allocation cannot be defragmented.
        6528  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
        6529  {
        6530  VmaBlockVector* pAllocBlockVector = nullptr;
        6531 
        6532  const VmaPool hAllocPool = hAlloc->GetPool();
        6533  // This allocation belongs to custom pool.
        6534  if(hAllocPool != VK_NULL_HANDLE)
        6535  {
        6536  pAllocBlockVector = &hAllocPool->GetBlockVector();
        6537  }
        6538  // This allocation belongs to general pool.
        6539  else
        6540  {
        6541  pAllocBlockVector = m_pBlockVectors[memTypeIndex][hAlloc->GetBlockVectorType()];
        6542  }
        6543 
        6544  VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(
        6545  m_hDevice,
        6546  GetAllocationCallbacks(),
        6547  currentFrameIndex);
        6548 
        6549  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
        6550  &pAllocationsChanged[allocIndex] : VMA_NULL;
        6551  pDefragmentator->AddAllocation(hAlloc, pChanged);
        6552  }
        6553  }
        6554 
        6555  VkResult result = VK_SUCCESS;
        6556 
        6557  // ======== Main processing.
        6558 
        6559  VkDeviceSize maxBytesToMove = SIZE_MAX;
        6560  uint32_t maxAllocationsToMove = UINT32_MAX;
        6561  if(pDefragmentationInfo != VMA_NULL)
        6562  {
        6563  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
        6564  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
        6565  }
        6566 
        6567  // Process standard memory.
        6568  for(uint32_t memTypeIndex = 0;
        6569  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
        6570  ++memTypeIndex)
        6571  {
        6572  // Only HOST_VISIBLE memory types can be defragmented.
        6573  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        6574  {
        6575  for(uint32_t blockVectorType = 0;
        6576  (blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT) && (result == VK_SUCCESS);
        6577  ++blockVectorType)
        6578  {
        6579  result = m_pBlockVectors[memTypeIndex][blockVectorType]->Defragment(
        6580  pDefragmentationStats,
        6581  maxBytesToMove,
        6582  maxAllocationsToMove);
        6583  }
        6584  }
        6585  }
        6586 
        6587  // Process custom pools.
        6588  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
        6589  {
        6590  result = m_Pools[poolIndex]->GetBlockVector().Defragment(
        6591  pDefragmentationStats,
        6592  maxBytesToMove,
        6593  maxAllocationsToMove);
        6594  }
        6595 
        6596  // ======== Destroy defragmentators.
        6597 
        6598  // Process custom pools.
        6599  for(size_t poolIndex = poolCount; poolIndex--; )
        6600  {
        6601  m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();
        6602  }
        6603 
        6604  // Process standard memory.
        6605  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
        6606  {
        6607  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        6608  {
        6609  for(size_t blockVectorType = VMA_BLOCK_VECTOR_TYPE_COUNT; blockVectorType--; )
        6610  {
        6611  m_pBlockVectors[memTypeIndex][blockVectorType]->DestroyDefragmentator();
        6612  }
        6613  }
        6614  }
        6615 
        6616  return result;
        6617 }
        6618 
        6619 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
        6620 {
        6621  if(hAllocation->CanBecomeLost())
        6622  {
        6623  /*
        6624  Warning: This is a carefully designed algorithm.
        6625  Do not modify unless you really know what you're doing :)
        6626  */
        6627  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        6628  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        6629  for(;;)
        6630  {
        6631  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        6632  {
        6633  pAllocationInfo->memoryType = UINT32_MAX;
        6634  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
        6635  pAllocationInfo->offset = 0;
        6636  pAllocationInfo->size = hAllocation->GetSize();
        6637  pAllocationInfo->pMappedData = VMA_NULL;
        6638  pAllocationInfo->pUserData = hAllocation->GetUserData();
        6639  return;
        6640  }
        6641  else if(localLastUseFrameIndex == localCurrFrameIndex)
        6642  {
        6643  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        6644  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        6645  pAllocationInfo->offset = hAllocation->GetOffset();
        6646  pAllocationInfo->size = hAllocation->GetSize();
        6647  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        6648  pAllocationInfo->pUserData = hAllocation->GetUserData();
        6649  return;
        6650  }
        6651  else // Last use time earlier than current time.
        6652  {
        6653  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        6654  {
        6655  localLastUseFrameIndex = localCurrFrameIndex;
        6656  }
        6657  }
        6658  }
        6659  }
        6660  // We could use the same code here, but for performance reasons we don't need to use the hAllocation.LastUseFrameIndex atomic.
        6661  else
        6662  {
        6663  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        6664  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        6665  pAllocationInfo->offset = hAllocation->GetOffset();
        6666  pAllocationInfo->size = hAllocation->GetSize();
        6667  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        6668  pAllocationInfo->pUserData = hAllocation->GetUserData();
        6669  }
        6670 }
        6671 
        6672 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
        6673 {
        6674  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);
        6675 
        6676  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
        6677 
        6678  if(newCreateInfo.maxBlockCount == 0)
        6679  {
        6680  newCreateInfo.maxBlockCount = SIZE_MAX;
        6681  }
        6682  if(newCreateInfo.blockSize == 0)
        6683  {
        6684  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
        6685  }
        6686 
        6687  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
        6688 
        6689  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
        6690  if(res != VK_SUCCESS)
        6691  {
        6692  vma_delete(this, *pPool);
        6693  *pPool = VMA_NULL;
        6694  return res;
        6695  }
        6696 
        6697  // Add to m_Pools.
        6698  {
        6699  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6700  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
        6701  }
        6702 
        6703  return VK_SUCCESS;
        6704 }
        6705 
        6706 void VmaAllocator_T::DestroyPool(VmaPool pool)
        6707 {
        6708  // Remove from m_Pools.
        6709  {
        6710  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6711  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
        6712  VMA_ASSERT(success && "Pool not found in Allocator.");
        6713  }
        6714 
        6715  vma_delete(this, pool);
        6716 }
        6717 
        6718 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
        6719 {
        6720  pool->m_BlockVector.GetPoolStats(pPoolStats);
        6721 }
        6722 
        6723 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
        6724 {
        6725  m_CurrentFrameIndex.store(frameIndex);
        6726 }
        6727 
        6728 void VmaAllocator_T::MakePoolAllocationsLost(
        6729  VmaPool hPool,
        6730  size_t* pLostAllocationCount)
        6731 {
        6732  hPool->m_BlockVector.MakePoolAllocationsLost(
        6733  m_CurrentFrameIndex.load(),
        6734  pLostAllocationCount);
        6735 }
        6736 
        6737 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
        6738 {
        6739  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST);
        6740  (*pAllocation)->InitLost();
        6741 }
        6742 
        6743 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
        6744 {
        6745  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
        6746 
        6747  VkResult res;
        6748  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        6749  {
        6750  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
        6751  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
        6752  {
        6753  res = vkAllocateMemory(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        6754  if(res == VK_SUCCESS)
        6755  {
        6756  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
        6757  }
        6758  }
        6759  else
        6760  {
        6761  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
        6762  }
        6763  }
        6764  else
        6765  {
        6766  res = vkAllocateMemory(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        6767  }
        6768 
        6769  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        6770  {
        6771  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
        6772  }
        6773 
        6774  return res;
        6775 }
        6776 
        6777 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
        6778 {
        6779  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        6780  {
        6781  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
        6782  }
        6783 
        6784  vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks());
        6785 
        6786  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
        6787  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        6788  {
        6789  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
        6790  m_HeapSizeLimit[heapIndex] += size;
        6791  }
        6792 }
        6793 
        6794 void VmaAllocator_T::FreeOwnMemory(VmaAllocation allocation)
        6795 {
        6796  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_OWN);
        6797 
        6798  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        6799  {
        6800  VmaMutexLock lock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6801  AllocationVectorType* const pOwnAllocations = m_pOwnAllocations[memTypeIndex][allocation->GetBlockVectorType()];
        6802  VMA_ASSERT(pOwnAllocations);
        6803  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pOwnAllocations, allocation);
        6804  VMA_ASSERT(success);
        6805  }
        6806 
        6807  VkDeviceMemory hMemory = allocation->GetMemory();
        6808 
        6809  if(allocation->GetMappedData() != VMA_NULL)
        6810  {
        6811  vkUnmapMemory(m_hDevice, hMemory);
        6812  }
        6813 
        6814  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
        6815 
        6816  VMA_DEBUG_LOG(" Freed OwnMemory MemoryTypeIndex=%u", memTypeIndex);
        6817 }
        6818 
        6819 #if VMA_STATS_STRING_ENABLED
        6820 
        6821 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
        6822 {
        6823  bool ownAllocationsStarted = false;
        6824  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6825  {
        6826  VmaMutexLock ownAllocationsLock(m_OwnAllocationsMutex[memTypeIndex], m_UseMutex);
        6827  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6828  {
        6829  AllocationVectorType* const pOwnAllocVector = m_pOwnAllocations[memTypeIndex][blockVectorType];
        6830  VMA_ASSERT(pOwnAllocVector);
        6831  if(pOwnAllocVector->empty() == false)
        6832  {
        6833  if(ownAllocationsStarted == false)
        6834  {
        6835  ownAllocationsStarted = true;
        6836  json.WriteString("OwnAllocations");
        6837  json.BeginObject();
        6838  }
        6839 
        6840  json.BeginString("Type ");
        6841  json.ContinueString(memTypeIndex);
        6842  if(blockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED)
        6843  {
        6844  json.ContinueString(" Mapped");
        6845  }
        6846  json.EndString();
        6847 
        6848  json.BeginArray();
        6849 
        6850  for(size_t i = 0; i < pOwnAllocVector->size(); ++i)
        6851  {
        6852  const VmaAllocation hAlloc = (*pOwnAllocVector)[i];
        6853  json.BeginObject(true);
        6854 
        6855  json.WriteString("Size");
        6856  json.WriteNumber(hAlloc->GetSize());
        6857 
        6858  json.WriteString("Type");
        6859  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[hAlloc->GetSuballocationType()]);
        6860 
        6861  json.EndObject();
        6862  }
        6863 
        6864  json.EndArray();
        6865  }
        6866  }
        6867  }
        6868  if(ownAllocationsStarted)
        6869  {
        6870  json.EndObject();
        6871  }
        6872 
        6873  {
        6874  bool allocationsStarted = false;
        6875  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        6876  {
        6877  for(uint32_t blockVectorType = 0; blockVectorType < VMA_BLOCK_VECTOR_TYPE_COUNT; ++blockVectorType)
        6878  {
        6879  if(m_pBlockVectors[memTypeIndex][blockVectorType]->IsEmpty() == false)
        6880  {
        6881  if(allocationsStarted == false)
        6882  {
        6883  allocationsStarted = true;
        6884  json.WriteString("DefaultPools");
        6885  json.BeginObject();
        6886  }
        6887 
        6888  json.BeginString("Type ");
        6889  json.ContinueString(memTypeIndex);
        6890  if(blockVectorType == VMA_BLOCK_VECTOR_TYPE_MAPPED)
        6891  {
        6892  json.ContinueString(" Mapped");
        6893  }
        6894  json.EndString();
        6895 
        6896  m_pBlockVectors[memTypeIndex][blockVectorType]->PrintDetailedMap(json);
        6897  }
        6898  }
        6899  }
        6900  if(allocationsStarted)
        6901  {
        6902  json.EndObject();
        6903  }
        6904  }
        6905 
        6906  {
        6907  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        6908  const size_t poolCount = m_Pools.size();
        6909  if(poolCount > 0)
        6910  {
        6911  json.WriteString("Pools");
        6912  json.BeginArray();
        6913  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        6914  {
        6915  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
        6916  }
        6917  json.EndArray();
        6918  }
        6919  }
        6920 }
        6921 
        6922 #endif // #if VMA_STATS_STRING_ENABLED
        6923 
        6924 static VkResult AllocateMemoryForImage(
        6925  VmaAllocator allocator,
        6926  VkImage image,
        6927  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        6928  VmaSuballocationType suballocType,
        6929  VmaAllocation* pAllocation)
        6930 {
        6931  VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation);
        6932 
        6933  VkMemoryRequirements vkMemReq = {};
        6934  vkGetImageMemoryRequirements(allocator->m_hDevice, image, &vkMemReq);
        6935 
        6936  return allocator->AllocateMemory(
        6937  vkMemReq,
        6938  *pAllocationCreateInfo,
        6939  suballocType,
        6940  pAllocation);
        6941 }
        6942 
        6944 // Public interface
        6945 
        6946 VkResult vmaCreateAllocator(
        6947  const VmaAllocatorCreateInfo* pCreateInfo,
        6948  VmaAllocator* pAllocator)
        6949 {
        6950  VMA_ASSERT(pCreateInfo && pAllocator);
        6951  VMA_DEBUG_LOG("vmaCreateAllocator");
        6952  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
        6953  return VK_SUCCESS;
        6954 }
        6955 
        6956 void vmaDestroyAllocator(
        6957  VmaAllocator allocator)
        6958 {
        6959  if(allocator != VK_NULL_HANDLE)
        6960  {
        6961  VMA_DEBUG_LOG("vmaDestroyAllocator");
        6962  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
        6963  vma_delete(&allocationCallbacks, allocator);
        6964  }
        6965 }
        6966 
        6967 void vmaGetPhysicalDeviceProperties(
        6968  VmaAllocator allocator,
        6969  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        6970 {
        6971  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
        6972  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
        6973 }
        6974 
        6975 void vmaGetMemoryProperties(
        6976  VmaAllocator allocator,
        6977  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
        6978 {
        6979  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
        6980  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
        6981 }
        6982 
        6983 void vmaGetMemoryTypeProperties(
        6984  VmaAllocator allocator,
        6985  uint32_t memoryTypeIndex,
        6986  VkMemoryPropertyFlags* pFlags)
        6987 {
        6988  VMA_ASSERT(allocator && pFlags);
        6989  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
        6990  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
        6991 }
        6992 
        6993 void vmaSetCurrentFrameIndex(
        6994  VmaAllocator allocator,
        6995  uint32_t frameIndex)
        6996 {
        6997  VMA_ASSERT(allocator);
        6998  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
        6999 
        7000  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7001 
        7002  allocator->SetCurrentFrameIndex(frameIndex);
        7003 }
        7004 
        7005 void vmaCalculateStats(
        7006  VmaAllocator allocator,
        7007  VmaStats* pStats)
        7008 {
        7009  VMA_ASSERT(allocator && pStats);
        7010  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7011  allocator->CalculateStats(pStats);
        7012 }
        7013 
        7014 #if VMA_STATS_STRING_ENABLED
        7015 
        7016 void vmaBuildStatsString(
        7017  VmaAllocator allocator,
        7018  char** ppStatsString,
        7019  VkBool32 detailedMap)
        7020 {
        7021  VMA_ASSERT(allocator && ppStatsString);
        7022  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7023 
        7024  VmaStringBuilder sb(allocator);
        7025  {
        7026  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        7027  json.BeginObject();
        7028 
        7029  VmaStats stats;
        7030  allocator->CalculateStats(&stats);
        7031 
        7032  json.WriteString("Total");
        7033  VmaPrintStatInfo(json, stats.total);
        7034 
        7035  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
        7036  {
        7037  json.BeginString("Heap ");
        7038  json.ContinueString(heapIndex);
        7039  json.EndString();
        7040  json.BeginObject();
        7041 
        7042  json.WriteString("Size");
        7043  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
        7044 
        7045  json.WriteString("Flags");
        7046  json.BeginArray(true);
        7047  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
        7048  {
        7049  json.WriteString("DEVICE_LOCAL");
        7050  }
        7051  json.EndArray();
        7052 
        7053  if(stats.memoryHeap[heapIndex].BlockCount > 0)
        7054  {
        7055  json.WriteString("Stats");
        7056  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
        7057  }
        7058 
        7059  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
        7060  {
        7061  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
        7062  {
        7063  json.BeginString("Type ");
        7064  json.ContinueString(typeIndex);
        7065  json.EndString();
        7066 
        7067  json.BeginObject();
        7068 
        7069  json.WriteString("Flags");
        7070  json.BeginArray(true);
        7071  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
        7072  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        7073  {
        7074  json.WriteString("DEVICE_LOCAL");
        7075  }
        7076  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        7077  {
        7078  json.WriteString("HOST_VISIBLE");
        7079  }
        7080  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
        7081  {
        7082  json.WriteString("HOST_COHERENT");
        7083  }
        7084  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
        7085  {
        7086  json.WriteString("HOST_CACHED");
        7087  }
        7088  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        7089  {
        7090  json.WriteString("LAZILY_ALLOCATED");
        7091  }
        7092  json.EndArray();
        7093 
        7094  if(stats.memoryType[typeIndex].BlockCount > 0)
        7095  {
        7096  json.WriteString("Stats");
        7097  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
        7098  }
        7099 
        7100  json.EndObject();
        7101  }
        7102  }
        7103 
        7104  json.EndObject();
        7105  }
        7106  if(detailedMap == VK_TRUE)
        7107  {
        7108  allocator->PrintDetailedMap(json);
        7109  }
        7110 
        7111  json.EndObject();
        7112  }
        7113 
        7114  const size_t len = sb.GetLength();
        7115  char* const pChars = vma_new_array(allocator, char, len + 1);
        7116  if(len > 0)
        7117  {
        7118  memcpy(pChars, sb.GetData(), len);
        7119  }
        7120  pChars[len] = '\0';
        7121  *ppStatsString = pChars;
        7122 }
        7123 
        7124 void vmaFreeStatsString(
        7125  VmaAllocator allocator,
        7126  char* pStatsString)
        7127 {
        7128  if(pStatsString != VMA_NULL)
        7129  {
        7130  VMA_ASSERT(allocator);
        7131  size_t len = strlen(pStatsString);
        7132  vma_delete_array(allocator, pStatsString, len + 1);
        7133  }
        7134 }
        7135 
        7136 #endif // #if VMA_STATS_STRING_ENABLED
        7137 
        7140 VkResult vmaFindMemoryTypeIndex(
        7141  VmaAllocator allocator,
        7142  uint32_t memoryTypeBits,
        7143  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        7144  uint32_t* pMemoryTypeIndex)
        7145 {
        7146  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        7147  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        7148  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        7149 
        7150  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        7151  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
        7152  if(preferredFlags == 0)
        7153  {
        7154  preferredFlags = requiredFlags;
        7155  }
        7156  // preferredFlags, if not 0, must be a superset of requiredFlags.
        7157  VMA_ASSERT((requiredFlags & ~preferredFlags) == 0);
        7158 
        7159  // Convert usage to requiredFlags and preferredFlags.
        7160  switch(pAllocationCreateInfo->usage)
        7161  {
        7162  case VMA_MEMORY_USAGE_UNKNOWN:
        7163  break;
        7164  case VMA_MEMORY_USAGE_GPU_ONLY:
        7165  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        7166  break;
        7167  case VMA_MEMORY_USAGE_CPU_ONLY:
        7168  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        7169  break;
        7170  case VMA_MEMORY_USAGE_CPU_TO_GPU:
        7171  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        7172  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        7173  break;
        7174  case VMA_MEMORY_USAGE_GPU_TO_CPU:
        7175  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        7176  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        7177  break;
        7178  default:
        7179  break;
        7180  }
        7181 
        7182  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT) != 0)
        7183  {
        7184  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        7185  }
        7186 
        7187  *pMemoryTypeIndex = UINT32_MAX;
        7188  uint32_t minCost = UINT32_MAX;
        7189  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        7190  memTypeIndex < allocator->GetMemoryTypeCount();
        7191  ++memTypeIndex, memTypeBit <<= 1)
        7192  {
        7193  // This memory type is acceptable according to memoryTypeBits bitmask.
        7194  if((memTypeBit & memoryTypeBits) != 0)
        7195  {
        7196  const VkMemoryPropertyFlags currFlags =
        7197  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        7198  // This memory type contains requiredFlags.
        7199  if((requiredFlags & ~currFlags) == 0)
        7200  {
        7201  // Calculate cost as number of bits from preferredFlags not present in this memory type.
        7202  uint32_t currCost = CountBitsSet(preferredFlags & ~currFlags);
        7203  // Remember memory type with lowest cost.
        7204  if(currCost < minCost)
        7205  {
        7206  *pMemoryTypeIndex = memTypeIndex;
        7207  if(currCost == 0)
        7208  {
        7209  return VK_SUCCESS;
        7210  }
        7211  minCost = currCost;
        7212  }
        7213  }
        7214  }
        7215  }
        7216  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
        7217 }
        7218 
        7219 VkResult vmaCreatePool(
        7220  VmaAllocator allocator,
        7221  const VmaPoolCreateInfo* pCreateInfo,
        7222  VmaPool* pPool)
        7223 {
        7224  VMA_ASSERT(allocator && pCreateInfo && pPool);
        7225 
        7226  VMA_DEBUG_LOG("vmaCreatePool");
        7227 
        7228  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7229 
        7230  return allocator->CreatePool(pCreateInfo, pPool);
        7231 }
        7232 
        7233 void vmaDestroyPool(
        7234  VmaAllocator allocator,
        7235  VmaPool pool)
        7236 {
        7237  VMA_ASSERT(allocator && pool);
        7238 
        7239  VMA_DEBUG_LOG("vmaDestroyPool");
        7240 
        7241  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7242 
        7243  allocator->DestroyPool(pool);
        7244 }
        7245 
        7246 void vmaGetPoolStats(
        7247  VmaAllocator allocator,
        7248  VmaPool pool,
        7249  VmaPoolStats* pPoolStats)
        7250 {
        7251  VMA_ASSERT(allocator && pool && pPoolStats);
        7252 
        7253  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7254 
        7255  allocator->GetPoolStats(pool, pPoolStats);
        7256 }
        7257 
        7258 void vmaMakePoolAllocationsLost(
        7259  VmaAllocator allocator,
        7260  VmaPool pool,
        7261  size_t* pLostAllocationCount)
        7262 {
        7263  VMA_ASSERT(allocator && pool);
        7264 
        7265  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7266 
        7267  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
        7268 }
        7269 
        7270 VkResult vmaAllocateMemory(
        7271  VmaAllocator allocator,
        7272  const VkMemoryRequirements* pVkMemoryRequirements,
        7273  const VmaAllocationCreateInfo* pCreateInfo,
        7274  VmaAllocation* pAllocation,
        7275  VmaAllocationInfo* pAllocationInfo)
        7276 {
        7277  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
        7278 
        7279  VMA_DEBUG_LOG("vmaAllocateMemory");
        7280 
        7281  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7282 
        7283  VkResult result = allocator->AllocateMemory(
        7284  *pVkMemoryRequirements,
        7285  *pCreateInfo,
        7286  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        7287  pAllocation);
        7288 
        7289  if(pAllocationInfo && result == VK_SUCCESS)
        7290  {
        7291  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7292  }
        7293 
        7294  return result;
        7295 }
        7296 
        7297 VkResult vmaAllocateMemoryForBuffer(
        7298  VmaAllocator allocator,
        7299  VkBuffer buffer,
        7300  const VmaAllocationCreateInfo* pCreateInfo,
        7301  VmaAllocation* pAllocation,
        7302  VmaAllocationInfo* pAllocationInfo)
        7303 {
        7304  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        7305 
        7306  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
        7307 
        7308  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7309 
        7310  VkMemoryRequirements vkMemReq = {};
        7311  vkGetBufferMemoryRequirements(allocator->m_hDevice, buffer, &vkMemReq);
        7312 
        7313  VkResult result = allocator->AllocateMemory(
        7314  vkMemReq,
        7315  *pCreateInfo,
        7316  VMA_SUBALLOCATION_TYPE_BUFFER,
        7317  pAllocation);
        7318 
        7319  if(pAllocationInfo && result == VK_SUCCESS)
        7320  {
        7321  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7322  }
        7323 
        7324  return result;
        7325 }
        7326 
        7327 VkResult vmaAllocateMemoryForImage(
        7328  VmaAllocator allocator,
        7329  VkImage image,
        7330  const VmaAllocationCreateInfo* pCreateInfo,
        7331  VmaAllocation* pAllocation,
        7332  VmaAllocationInfo* pAllocationInfo)
        7333 {
        7334  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        7335 
        7336  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
        7337 
        7338  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7339 
        7340  VkResult result = AllocateMemoryForImage(
        7341  allocator,
        7342  image,
        7343  pCreateInfo,
        7344  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        7345  pAllocation);
        7346 
        7347  if(pAllocationInfo && result == VK_SUCCESS)
        7348  {
        7349  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7350  }
        7351 
        7352  return result;
        7353 }
        7354 
        7355 void vmaFreeMemory(
        7356  VmaAllocator allocator,
        7357  VmaAllocation allocation)
        7358 {
        7359  VMA_ASSERT(allocator && allocation);
        7360 
        7361  VMA_DEBUG_LOG("vmaFreeMemory");
        7362 
        7363  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7364 
        7365  allocator->FreeMemory(allocation);
        7366 }
        7367 
        7368 void vmaGetAllocationInfo(
        7369  VmaAllocator allocator,
        7370  VmaAllocation allocation,
        7371  VmaAllocationInfo* pAllocationInfo)
        7372 {
        7373  VMA_ASSERT(allocator && allocation && pAllocationInfo);
        7374 
        7375  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7376 
        7377  allocator->GetAllocationInfo(allocation, pAllocationInfo);
        7378 }
        7379 
        7380 void vmaSetAllocationUserData(
        7381  VmaAllocator allocator,
        7382  VmaAllocation allocation,
        7383  void* pUserData)
        7384 {
        7385  VMA_ASSERT(allocator && allocation);
        7386 
        7387  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7388 
        7389  allocation->SetUserData(pUserData);
        7390 }
        7391 
        7392 void vmaCreateLostAllocation(
        7393  VmaAllocator allocator,
        7394  VmaAllocation* pAllocation)
        7395 {
        7396  VMA_ASSERT(allocator && pAllocation);
        7397 
        7398  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        7399 
        7400  allocator->CreateLostAllocation(pAllocation);
        7401 }
        7402 
        7403 VkResult vmaMapMemory(
        7404  VmaAllocator allocator,
        7405  VmaAllocation allocation,
        7406  void** ppData)
        7407 {
        7408  VMA_ASSERT(allocator && allocation && ppData);
        7409 
        7410  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7411 
        7412  return vkMapMemory(allocator->m_hDevice, allocation->GetMemory(),
        7413  allocation->GetOffset(), allocation->GetSize(), 0, ppData);
        7414 }
        7415 
        7416 void vmaUnmapMemory(
        7417  VmaAllocator allocator,
        7418  VmaAllocation allocation)
        7419 {
        7420  VMA_ASSERT(allocator && allocation);
        7421 
        7422  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7423 
        7424  vkUnmapMemory(allocator->m_hDevice, allocation->GetMemory());
        7425 }
        7426 
        7427 void vmaUnmapPersistentlyMappedMemory(VmaAllocator allocator)
        7428 {
        7429  VMA_ASSERT(allocator);
        7430 
        7431  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7432 
        7433  allocator->UnmapPersistentlyMappedMemory();
        7434 }
        7435 
        7436 VkResult vmaMapPersistentlyMappedMemory(VmaAllocator allocator)
        7437 {
        7438  VMA_ASSERT(allocator);
        7439 
        7440  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7441 
        7442  return allocator->MapPersistentlyMappedMemory();
        7443 }
        7444 
        7445 VkResult vmaDefragment(
        7446  VmaAllocator allocator,
        7447  VmaAllocation* pAllocations,
        7448  size_t allocationCount,
        7449  VkBool32* pAllocationsChanged,
        7450  const VmaDefragmentationInfo *pDefragmentationInfo,
        7451  VmaDefragmentationStats* pDefragmentationStats)
        7452 {
        7453  VMA_ASSERT(allocator && pAllocations);
        7454 
        7455  VMA_DEBUG_LOG("vmaDefragment");
        7456 
        7457  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7458 
        7459  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
        7460 }
        7461 
        7462 VkResult vmaCreateBuffer(
        7463  VmaAllocator allocator,
        7464  const VkBufferCreateInfo* pBufferCreateInfo,
        7465  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        7466  VkBuffer* pBuffer,
        7467  VmaAllocation* pAllocation,
        7468  VmaAllocationInfo* pAllocationInfo)
        7469 {
        7470  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
        7471 
        7472  VMA_DEBUG_LOG("vmaCreateBuffer");
        7473 
        7474  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7475 
        7476  *pBuffer = VK_NULL_HANDLE;
        7477  *pAllocation = VK_NULL_HANDLE;
        7478 
        7479  // 1. Create VkBuffer.
        7480  VkResult res = vkCreateBuffer(allocator->m_hDevice, pBufferCreateInfo, allocator->GetAllocationCallbacks(), pBuffer);
        7481  if(res >= 0)
        7482  {
        7483  // 2. vkGetBufferMemoryRequirements.
        7484  VkMemoryRequirements vkMemReq = {};
        7485  vkGetBufferMemoryRequirements(allocator->m_hDevice, *pBuffer, &vkMemReq);
        7486 
        7487  // 3. Allocate memory using allocator.
        7488  res = allocator->AllocateMemory(
        7489  vkMemReq,
        7490  *pAllocationCreateInfo,
        7491  VMA_SUBALLOCATION_TYPE_BUFFER,
        7492  pAllocation);
        7493  if(res >= 0)
        7494  {
        7495  // 3. Bind buffer with memory.
        7496  res = vkBindBufferMemory(allocator->m_hDevice, *pBuffer, (*pAllocation)->GetMemory(), (*pAllocation)->GetOffset());
        7497  if(res >= 0)
        7498  {
        7499  // All steps succeeded.
        7500  if(pAllocationInfo != VMA_NULL)
        7501  {
        7502  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7503  }
        7504  return VK_SUCCESS;
        7505  }
        7506  allocator->FreeMemory(*pAllocation);
        7507  *pAllocation = VK_NULL_HANDLE;
        7508  return res;
        7509  }
        7510  vkDestroyBuffer(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        7511  *pBuffer = VK_NULL_HANDLE;
        7512  return res;
        7513  }
        7514  return res;
        7515 }
        7516 
        7517 void vmaDestroyBuffer(
        7518  VmaAllocator allocator,
        7519  VkBuffer buffer,
        7520  VmaAllocation allocation)
        7521 {
        7522  if(buffer != VK_NULL_HANDLE)
        7523  {
        7524  VMA_ASSERT(allocator);
        7525 
        7526  VMA_DEBUG_LOG("vmaDestroyBuffer");
        7527 
        7528  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7529 
        7530  vkDestroyBuffer(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        7531 
        7532  allocator->FreeMemory(allocation);
        7533  }
        7534 }
        7535 
        7536 VkResult vmaCreateImage(
        7537  VmaAllocator allocator,
        7538  const VkImageCreateInfo* pImageCreateInfo,
        7539  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        7540  VkImage* pImage,
        7541  VmaAllocation* pAllocation,
        7542  VmaAllocationInfo* pAllocationInfo)
        7543 {
        7544  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
        7545 
        7546  VMA_DEBUG_LOG("vmaCreateImage");
        7547 
        7548  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7549 
        7550  *pImage = VK_NULL_HANDLE;
        7551  *pAllocation = VK_NULL_HANDLE;
        7552 
        7553  // 1. Create VkImage.
        7554  VkResult res = vkCreateImage(allocator->m_hDevice, pImageCreateInfo, allocator->GetAllocationCallbacks(), pImage);
        7555  if(res >= 0)
        7556  {
        7557  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
        7558  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
        7559  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
        7560 
        7561  // 2. Allocate memory using allocator.
        7562  res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation);
        7563  if(res >= 0)
        7564  {
        7565  // 3. Bind image with memory.
        7566  res = vkBindImageMemory(allocator->m_hDevice, *pImage, (*pAllocation)->GetMemory(), (*pAllocation)->GetOffset());
        7567  if(res >= 0)
        7568  {
        7569  // All steps succeeded.
        7570  if(pAllocationInfo != VMA_NULL)
        7571  {
        7572  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        7573  }
        7574  return VK_SUCCESS;
        7575  }
        7576  allocator->FreeMemory(*pAllocation);
        7577  *pAllocation = VK_NULL_HANDLE;
        7578  return res;
        7579  }
        7580  vkDestroyImage(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        7581  *pImage = VK_NULL_HANDLE;
        7582  return res;
        7583  }
        7584  return res;
        7585 }
        7586 
        7587 void vmaDestroyImage(
        7588  VmaAllocator allocator,
        7589  VkImage image,
        7590  VmaAllocation allocation)
        7591 {
        7592  if(image != VK_NULL_HANDLE)
        7593  {
        7594  VMA_ASSERT(allocator);
        7595 
        7596  VMA_DEBUG_LOG("vmaDestroyImage");
        7597 
        7598  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        7599 
        7600  vkDestroyImage(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
        7601 
        7602  allocator->FreeMemory(allocation);
        7603  }
        7604 }
        7605 
        7606 #endif // #ifdef VMA_IMPLEMENTATION
        VmaAllocatorCreateInfo::physicalDevice
        VkPhysicalDevice physicalDevice
        Vulkan physical device.
        Definition: vk_mem_alloc.h:473
        +
        VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:790
        vmaGetPoolStats
        void vmaGetPoolStats(VmaAllocator allocator, VmaPool pool, VmaPoolStats *pPoolStats)
        Retrieves statistics of existing VmaPool object.
        -
        VmaStatInfo::BlockCount
        uint32_t BlockCount
        Number of VkDeviceMemory Vulkan memory blocks allocated.
        Definition: vk_mem_alloc.h:540
        -
        VMA_MEMORY_USAGE_GPU_TO_CPU
        Memory will be used for frequent writing on device and readback on host (download).
        Definition: vk_mem_alloc.h:607
        +
        VmaStatInfo::BlockCount
        uint32_t BlockCount
        Number of VkDeviceMemory Vulkan memory blocks allocated.
        Definition: vk_mem_alloc.h:574
        +
        VMA_MEMORY_USAGE_GPU_TO_CPU
        Memory will be used for frequent writing on device and readback on host (download).
        Definition: vk_mem_alloc.h:641
        vmaFindMemoryTypeIndex
        VkResult vmaFindMemoryTypeIndex(VmaAllocator allocator, uint32_t memoryTypeBits, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        -
        VmaAllocationInfo::deviceMemory
        VkDeviceMemory deviceMemory
        Handle to Vulkan memory object.
        Definition: vk_mem_alloc.h:877
        -
        VmaDefragmentationInfo::maxAllocationsToMove
        uint32_t maxAllocationsToMove
        Maximum number of allocations that can be moved to different place.
        Definition: vk_mem_alloc.h:1027
        +
        VmaAllocationInfo::deviceMemory
        VkDeviceMemory deviceMemory
        Handle to Vulkan memory object.
        Definition: vk_mem_alloc.h:911
        +
        VmaDefragmentationInfo::maxAllocationsToMove
        uint32_t maxAllocationsToMove
        Maximum number of allocations that can be moved to different place.
        Definition: vk_mem_alloc.h:1061
        vmaCreateImage
        VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        Function similar to vmaCreateBuffer().
        vmaGetAllocationInfo
        void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
        Returns current information about specified allocation.
        vmaUnmapPersistentlyMappedMemory
        void vmaUnmapPersistentlyMappedMemory(VmaAllocator allocator)
        Unmaps persistently mapped memory of types that are HOST_COHERENT and DEVICE_LOCAL.
        vmaDestroyImage
        void vmaDestroyImage(VmaAllocator allocator, VkImage image, VmaAllocation allocation)
        -
        VmaPoolStats::size
        VkDeviceSize size
        Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
        Definition: vk_mem_alloc.h:808
        +
        VmaPoolStats::size
        VkDeviceSize size
        Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
        Definition: vk_mem_alloc.h:842
        VmaDefragmentationInfo
        struct VmaDefragmentationInfo VmaDefragmentationInfo
        Optional configuration parameters to be passed to function vmaDefragment().
        -
        VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
        Definition: vk_mem_alloc.h:656
        -
        VmaAllocationCreateInfo::preferredFlags
        VkMemoryPropertyFlags preferredFlags
        Flags that preferably should be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:689
        -
        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:420
        +
        VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
        Definition: vk_mem_alloc.h:690
        +
        VmaAllocationCreateInfo::preferredFlags
        VkMemoryPropertyFlags preferredFlags
        Flags that preferably should be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:723
        +
        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:436
        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...
        -
        VmaAllocatorCreateInfo::pAllocationCallbacks
        const VkAllocationCallbacks * pAllocationCallbacks
        Custom CPU memory allocation callbacks.
        Definition: vk_mem_alloc.h:469
        -
        VmaPoolCreateFlags
        VkFlags VmaPoolCreateFlags
        Definition: vk_mem_alloc.h:758
        -
        VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        Definition: vk_mem_alloc.h:451
        -
        VmaAllocatorCreateInfo::preferredSmallHeapBlockSize
        VkDeviceSize preferredSmallHeapBlockSize
        Size of a single memory block to allocate for resources from a small heap <= 512 MB.
        Definition: vk_mem_alloc.h:466
        -
        VmaAllocatorFlags
        VkFlags VmaAllocatorFlags
        Definition: vk_mem_alloc.h:448
        -
        VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        Definition: vk_mem_alloc.h:1031
        -
        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:486
        -
        VmaStats::total
        VmaStatInfo total
        Definition: vk_mem_alloc.h:558
        -
        VmaDefragmentationStats::deviceMemoryBlocksFreed
        uint32_t deviceMemoryBlocksFreed
        Number of empty VkDeviceMemory objects that have been released to the system.
        Definition: vk_mem_alloc.h:1039
        -
        VmaAllocationCreateInfo::flags
        VmaAllocationCreateFlags flags
        Use VmaAllocationCreateFlagBits enum.
        Definition: vk_mem_alloc.h:672
        -
        VmaDefragmentationInfo::maxBytesToMove
        VkDeviceSize maxBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:1022
        +
        VmaAllocatorCreateInfo::pAllocationCallbacks
        const VkAllocationCallbacks * pAllocationCallbacks
        Custom CPU memory allocation callbacks.
        Definition: vk_mem_alloc.h:485
        +
        VmaPoolCreateFlags
        VkFlags VmaPoolCreateFlags
        Definition: vk_mem_alloc.h:792
        +
        VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        Definition: vk_mem_alloc.h:467
        +
        VmaAllocatorCreateInfo::preferredSmallHeapBlockSize
        VkDeviceSize preferredSmallHeapBlockSize
        Preferred size of a single VkDeviceMemory block to be allocated from small heaps <= 512 MB...
        Definition: vk_mem_alloc.h:482
        +
        VmaAllocatorFlags
        VkFlags VmaAllocatorFlags
        Definition: vk_mem_alloc.h:464
        +
        VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        Definition: vk_mem_alloc.h:1065
        +
        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:502
        +
        VmaStats::total
        VmaStatInfo total
        Definition: vk_mem_alloc.h:592
        +
        VmaDefragmentationStats::deviceMemoryBlocksFreed
        uint32_t deviceMemoryBlocksFreed
        Number of empty VkDeviceMemory objects that have been released to the system.
        Definition: vk_mem_alloc.h:1073
        +
        VmaAllocationCreateInfo::flags
        VmaAllocationCreateFlags flags
        Use VmaAllocationCreateFlagBits enum.
        Definition: vk_mem_alloc.h:706
        +
        VmaDefragmentationInfo::maxBytesToMove
        VkDeviceSize maxBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:1056
        vmaAllocateMemoryForBuffer
        VkResult vmaAllocateMemoryForBuffer(VmaAllocator allocator, VkBuffer buffer, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        -
        VmaAllocatorCreateInfo::device
        VkDevice device
        Vulkan device.
        Definition: vk_mem_alloc.h:460
        -
        VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        Definition: vk_mem_alloc.h:762
        +
        VmaAllocatorCreateInfo::device
        VkDevice device
        Vulkan device.
        Definition: vk_mem_alloc.h:476
        +
        VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        Definition: vk_mem_alloc.h:796
        VmaPoolStats
        struct VmaPoolStats VmaPoolStats
        Describes parameter of existing VmaPool.
        -
        VmaAllocationInfo::size
        VkDeviceSize size
        Size of this allocation, in bytes.
        Definition: vk_mem_alloc.h:887
        +
        VmaAllocationInfo::size
        VkDeviceSize size
        Size of this allocation, in bytes.
        Definition: vk_mem_alloc.h:921
        vmaFreeMemory
        void vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
        Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().
        vmaCreateBuffer
        VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        vmaAllocateMemory
        VkResult vmaAllocateMemory(VmaAllocator allocator, const VkMemoryRequirements *pVkMemoryRequirements, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        General purpose memory allocation.
        -
        VmaAllocationCreateInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
        Definition: vk_mem_alloc.h:691
        -
        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:778
        -
        VmaPoolStats::allocationCount
        size_t allocationCount
        Number of VmaAllocation objects created from this pool that were not destroyed or lost...
        Definition: vk_mem_alloc.h:814
        -
        VmaPoolCreateInfo::memoryTypeIndex
        uint32_t memoryTypeIndex
        Vulkan memory type index to allocate this pool from.
        Definition: vk_mem_alloc.h:765
        +
        VmaAllocationCreateInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
        Definition: vk_mem_alloc.h:725
        +
        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:812
        +
        VmaPoolStats::allocationCount
        size_t allocationCount
        Number of VmaAllocation objects created from this pool that were not destroyed or lost...
        Definition: vk_mem_alloc.h:848
        +
        VmaPoolCreateInfo::memoryTypeIndex
        uint32_t memoryTypeIndex
        Vulkan memory type index to allocate this pool from.
        Definition: vk_mem_alloc.h:799
        vmaBuildStatsString
        void vmaBuildStatsString(VmaAllocator allocator, char **ppStatsString, VkBool32 detailedMap)
        Builds and returns statistics as string in JSON format.
        -
        VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:665
        -
        VmaDefragmentationInfo
        Optional configuration parameters to be passed to function vmaDefragment().
        Definition: vk_mem_alloc.h:1017
        +
        VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:699
        +
        VmaDefragmentationInfo
        Optional configuration parameters to be passed to function vmaDefragment().
        Definition: vk_mem_alloc.h:1051
        vmaCreatePool
        VkResult vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
        Allocates Vulkan device memory and creates VmaPool object.
        -
        VmaStatInfo::AllocationSizeMax
        VkDeviceSize AllocationSizeMax
        Definition: vk_mem_alloc.h:549
        -
        VMA_POOL_CREATE_PERSISTENT_MAP_BIT
        Definition: vk_mem_alloc.h:736
        -
        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:1035
        +
        VmaStatInfo::AllocationSizeMax
        VkDeviceSize AllocationSizeMax
        Definition: vk_mem_alloc.h:583
        +
        VMA_POOL_CREATE_PERSISTENT_MAP_BIT
        Definition: vk_mem_alloc.h:770
        +
        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:1069
        vmaSetCurrentFrameIndex
        void vmaSetCurrentFrameIndex(VmaAllocator allocator, uint32_t frameIndex)
        Sets index of the current frame.
        -
        VmaStats
        General statistics from current state of Allocator.
        Definition: vk_mem_alloc.h:554
        +
        VmaStats
        General statistics from current state of Allocator.
        Definition: vk_mem_alloc.h:588
        vmaCreateAllocator
        VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
        Creates Allocator object.
        vmaAllocateMemoryForImage
        VkResult vmaAllocateMemoryForImage(VmaAllocator allocator, VkImage image, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        Function similar to vmaAllocateMemoryForBuffer().
        -
        VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT
        Set this flag to use a memory that will be persistently mapped and retrieve pointer to it...
        Definition: vk_mem_alloc.h:645
        -
        VmaDefragmentationStats::allocationsMoved
        uint32_t allocationsMoved
        Number of allocations that have been moved to different places.
        Definition: vk_mem_alloc.h:1037
        -
        VmaMemoryUsage
        VmaMemoryUsage
        Definition: vk_mem_alloc.h:593
        +
        VMA_ALLOCATION_CREATE_PERSISTENT_MAP_BIT
        Set this flag to use a memory that will be persistently mapped and retrieve pointer to it...
        Definition: vk_mem_alloc.h:679
        +
        VmaDefragmentationStats::allocationsMoved
        uint32_t allocationsMoved
        Number of allocations that have been moved to different places.
        Definition: vk_mem_alloc.h:1071
        +
        VmaMemoryUsage
        VmaMemoryUsage
        Definition: vk_mem_alloc.h:627
        vmaDestroyAllocator
        void vmaDestroyAllocator(VmaAllocator allocator)
        Destroys allocator object.
        -
        VmaAllocationCreateInfo::requiredFlags
        VkMemoryPropertyFlags requiredFlags
        Flags that must be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:683
        -
        VMA_ALLOCATOR_EXTERNALLY_SYNCHRONIZED_BIT
        Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
        Definition: vk_mem_alloc.h:444
        +
        VmaAllocationCreateInfo::requiredFlags
        VkMemoryPropertyFlags requiredFlags
        Flags that must be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:717
        +
        VMA_ALLOCATOR_EXTERNALLY_SYNCHRONIZED_BIT
        Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
        Definition: vk_mem_alloc.h:460
        vmaCalculateStats
        void vmaCalculateStats(VmaAllocator allocator, VmaStats *pStats)
        Retrieves statistics from current state of the Allocator.
        -
        VmaAllocatorFlagBits
        VmaAllocatorFlagBits
        Flags for created VmaAllocator.
        Definition: vk_mem_alloc.h:439
        +
        VmaAllocatorFlagBits
        VmaAllocatorFlagBits
        Flags for created VmaAllocator.
        Definition: vk_mem_alloc.h:455
        vmaSetAllocationUserData
        void vmaSetAllocationUserData(VmaAllocator allocator, VmaAllocation allocation, void *pUserData)
        Sets pUserData in given allocation to new value.
        -
        VmaStatInfo
        Definition: vk_mem_alloc.h:537
        -
        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:773
        -
        VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        Definition: vk_mem_alloc.h:431
        -
        VmaDeviceMemoryCallbacks::pfnFree
        PFN_vmaFreeDeviceMemoryFunction pfnFree
        Optional, can be null.
        Definition: vk_mem_alloc.h:435
        +
        VmaStatInfo
        Definition: vk_mem_alloc.h:571
        +
        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:807
        +
        VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        Definition: vk_mem_alloc.h:447
        +
        VmaDeviceMemoryCallbacks::pfnFree
        PFN_vmaFreeDeviceMemoryFunction pfnFree
        Optional, can be null.
        Definition: vk_mem_alloc.h:451
        vmaMapPersistentlyMappedMemory
        VkResult vmaMapPersistentlyMappedMemory(VmaAllocator allocator)
        Maps back persistently mapped memory of types that are HOST_COHERENT and DEVICE_LOCAL.
        -
        VmaPoolCreateInfo::flags
        VmaPoolCreateFlags flags
        Use combination of VmaPoolCreateFlagBits.
        Definition: vk_mem_alloc.h:768
        -
        VmaStatInfo::UnusedRangeSizeMax
        VkDeviceSize UnusedRangeSizeMax
        Definition: vk_mem_alloc.h:550
        +
        VmaPoolCreateInfo::flags
        VmaPoolCreateFlags flags
        Use combination of VmaPoolCreateFlagBits.
        Definition: vk_mem_alloc.h:802
        +
        VmaStatInfo::UnusedRangeSizeMax
        VkDeviceSize UnusedRangeSizeMax
        Definition: vk_mem_alloc.h:584
        VmaAllocatorCreateInfo
        struct VmaAllocatorCreateInfo VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        -
        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:414
        -
        VmaAllocationCreateInfo::usage
        VmaMemoryUsage usage
        Intended usage of memory.
        Definition: vk_mem_alloc.h:678
        -
        VmaAllocationCreateInfo
        Definition: vk_mem_alloc.h:669
        -
        VmaPoolCreateInfo::maxBlockCount
        size_t maxBlockCount
        Maximum number of blocks that can be allocated in this pool.
        Definition: vk_mem_alloc.h:786
        -
        VmaStatInfo::AllocationSizeMin
        VkDeviceSize AllocationSizeMin
        Definition: vk_mem_alloc.h:549
        -
        VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
        const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
        Informative callbacks for vkAllocateMemory, vkFreeMemory.
        Definition: vk_mem_alloc.h:472
        -
        VmaPoolStats::unusedRangeCount
        size_t unusedRangeCount
        Number of continuous memory ranges in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:817
        -
        VmaAllocationCreateInfo::pool
        VmaPool pool
        Pool that this allocation should be created in.
        Definition: vk_mem_alloc.h:696
        -
        VmaStats::memoryType
        VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
        Definition: vk_mem_alloc.h:556
        -
        VmaStatInfo::AllocationSizeAvg
        VkDeviceSize AllocationSizeAvg
        Definition: vk_mem_alloc.h:549
        +
        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:430
        +
        VmaAllocationCreateInfo::usage
        VmaMemoryUsage usage
        Intended usage of memory.
        Definition: vk_mem_alloc.h:712
        +
        VmaAllocationCreateInfo
        Definition: vk_mem_alloc.h:703
        +
        VmaPoolCreateInfo::maxBlockCount
        size_t maxBlockCount
        Maximum number of blocks that can be allocated in this pool.
        Definition: vk_mem_alloc.h:820
        +
        VmaStatInfo::AllocationSizeMin
        VkDeviceSize AllocationSizeMin
        Definition: vk_mem_alloc.h:583
        +
        VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
        const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
        Informative callbacks for vkAllocateMemory, vkFreeMemory.
        Definition: vk_mem_alloc.h:488
        +
        VmaPoolStats::unusedRangeCount
        size_t unusedRangeCount
        Number of continuous memory ranges in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:851
        +
        VmaAllocationCreateInfo::pool
        VmaPool pool
        Pool that this allocation should be created in.
        Definition: vk_mem_alloc.h:730
        +
        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:520
        +
        VmaStats::memoryType
        VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
        Definition: vk_mem_alloc.h:590
        +
        VmaStatInfo::AllocationSizeAvg
        VkDeviceSize AllocationSizeAvg
        Definition: vk_mem_alloc.h:583
        VmaAllocationCreateInfo
        struct VmaAllocationCreateInfo VmaAllocationCreateInfo
        -
        VmaStatInfo::AllocationCount
        uint32_t AllocationCount
        Number of VmaAllocation allocation objects allocated.
        Definition: vk_mem_alloc.h:542
        +
        VmaStatInfo::AllocationCount
        uint32_t AllocationCount
        Number of VmaAllocation allocation objects allocated.
        Definition: vk_mem_alloc.h:576
        vmaMapMemory
        VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
        -
        VmaDeviceMemoryCallbacks::pfnAllocate
        PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
        Optional, can be null.
        Definition: vk_mem_alloc.h:433
        -
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
        Definition: vk_mem_alloc.h:663
        -
        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:800
        -
        VmaAllocatorCreateInfo::flags
        VmaAllocatorFlags flags
        Flags for created allocator. Use VmaAllocatorFlagBits enum.
        Definition: vk_mem_alloc.h:454
        +
        VmaDeviceMemoryCallbacks::pfnAllocate
        PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
        Optional, can be null.
        Definition: vk_mem_alloc.h:449
        +
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
        Definition: vk_mem_alloc.h:697
        +
        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:834
        +
        VmaAllocatorCreateInfo::flags
        VmaAllocatorFlags flags
        Flags for created allocator. Use VmaAllocatorFlagBits enum.
        Definition: vk_mem_alloc.h:470
        vmaGetPhysicalDeviceProperties
        void vmaGetPhysicalDeviceProperties(VmaAllocator allocator, const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        -
        VmaStatInfo::UsedBytes
        VkDeviceSize UsedBytes
        Total number of bytes occupied by all allocations.
        Definition: vk_mem_alloc.h:546
        -
        VmaAllocationInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
        Definition: vk_mem_alloc.h:898
        -
        VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT
        Set this flag if the allocation should have its own memory block.
        Definition: vk_mem_alloc.h:624
        -
        VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
        VkDeviceSize preferredLargeHeapBlockSize
        Size of a single memory block to allocate for resources.
        Definition: vk_mem_alloc.h:463
        -
        VmaStatInfo::UnusedRangeCount
        uint32_t UnusedRangeCount
        Number of free ranges of memory between allocations.
        Definition: vk_mem_alloc.h:544
        -
        VmaPoolStats
        Describes parameter of existing VmaPool.
        Definition: vk_mem_alloc.h:805
        -
        VMA_MEMORY_USAGE_CPU_ONLY
        Memory will be mapped on host. Could be used for transfer to/from device.
        Definition: vk_mem_alloc.h:601
        +
        VmaStatInfo::UsedBytes
        VkDeviceSize UsedBytes
        Total number of bytes occupied by all allocations.
        Definition: vk_mem_alloc.h:580
        +
        VmaAllocationInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
        Definition: vk_mem_alloc.h:932
        +
        VMA_ALLOCATION_CREATE_OWN_MEMORY_BIT
        Set this flag if the allocation should have its own memory block.
        Definition: vk_mem_alloc.h:658
        +
        VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
        VkDeviceSize preferredLargeHeapBlockSize
        Preferred size of a single VkDeviceMemory block to be allocated from large heaps. ...
        Definition: vk_mem_alloc.h:479
        +
        VmaStatInfo::UnusedRangeCount
        uint32_t UnusedRangeCount
        Number of free ranges of memory between allocations.
        Definition: vk_mem_alloc.h:578
        +
        VmaPoolStats
        Describes parameter of existing VmaPool.
        Definition: vk_mem_alloc.h:839
        +
        VMA_MEMORY_USAGE_CPU_ONLY
        Memory will be mapped on host. Could be used for transfer to/from device.
        Definition: vk_mem_alloc.h:635
        vmaGetMemoryProperties
        void vmaGetMemoryProperties(VmaAllocator allocator, const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
        -
        VmaStatInfo::UnusedRangeSizeAvg
        VkDeviceSize UnusedRangeSizeAvg
        Definition: vk_mem_alloc.h:550
        -
        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:882
        -
        VmaDefragmentationStats::bytesMoved
        VkDeviceSize bytesMoved
        Total number of bytes that have been copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:1033
        +
        VmaStatInfo::UnusedRangeSizeAvg
        VkDeviceSize UnusedRangeSizeAvg
        Definition: vk_mem_alloc.h:584
        +
        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:916
        +
        VmaDefragmentationStats::bytesMoved
        VkDeviceSize bytesMoved
        Total number of bytes that have been copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:1067
        vmaDefragment
        VkResult vmaDefragment(VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
        Compacts memory by moving allocations.
        VmaDeviceMemoryCallbacks
        struct VmaDeviceMemoryCallbacks VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        -
        VmaAllocationCreateFlags
        VkFlags VmaAllocationCreateFlags
        Definition: vk_mem_alloc.h:667
        -
        VmaPoolCreateFlagBits
        VmaPoolCreateFlagBits
        Flags to be passed as VmaPoolCreateInfo::flags.
        Definition: vk_mem_alloc.h:727
        -
        VmaAllocationInfo::pMappedData
        void * pMappedData
        Pointer to the beginning of this allocation as mapped data. Null if this alloaction is not persistent...
        Definition: vk_mem_alloc.h:893
        +
        VmaAllocationCreateFlags
        VkFlags VmaAllocationCreateFlags
        Definition: vk_mem_alloc.h:701
        +
        VmaPoolCreateFlagBits
        VmaPoolCreateFlagBits
        Flags to be passed as VmaPoolCreateInfo::flags.
        Definition: vk_mem_alloc.h:761
        +
        VmaAllocationInfo::pMappedData
        void * pMappedData
        Pointer to the beginning of this allocation as mapped data. Null if this alloaction is not persistent...
        Definition: vk_mem_alloc.h:927
        vmaFreeStatsString
        void vmaFreeStatsString(VmaAllocator allocator, char *pStatsString)
        -
        VMA_MEMORY_USAGE_UNKNOWN
        No intended memory usage specified.
        Definition: vk_mem_alloc.h:596
        +
        VMA_MEMORY_USAGE_UNKNOWN
        No intended memory usage specified.
        Definition: vk_mem_alloc.h:630
        vmaCreateLostAllocation
        void vmaCreateLostAllocation(VmaAllocator allocator, VmaAllocation *pAllocation)
        Creates new allocation that is in lost state from the beginning.
        -
        VMA_MEMORY_USAGE_MAX_ENUM
        Definition: vk_mem_alloc.h:608
        -
        VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        Definition: vk_mem_alloc.h:863
        -
        VMA_MEMORY_USAGE_CPU_TO_GPU
        Memory will be used for frequent (dynamic) updates from host and reads on device (upload).
        Definition: vk_mem_alloc.h:604
        -
        VmaAllocationCreateFlagBits
        VmaAllocationCreateFlagBits
        Flags to be passed as VmaAllocationCreateInfo::flags.
        Definition: vk_mem_alloc.h:612
        -
        VMA_ALLOCATOR_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:446
        +
        VMA_MEMORY_USAGE_MAX_ENUM
        Definition: vk_mem_alloc.h:642
        +
        VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        Definition: vk_mem_alloc.h:897
        +
        VMA_MEMORY_USAGE_CPU_TO_GPU
        Memory will be used for frequent (dynamic) updates from host and reads on device (upload).
        Definition: vk_mem_alloc.h:638
        +
        VmaAllocationCreateFlagBits
        VmaAllocationCreateFlagBits
        Flags to be passed as VmaAllocationCreateInfo::flags.
        Definition: vk_mem_alloc.h:646
        +
        VMA_ALLOCATOR_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:462
        VmaAllocationInfo
        struct VmaAllocationInfo VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        vmaGetMemoryTypeProperties
        void vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
        Given Memory Type Index, returns Property Flags of this memory type.
        -
        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:635
        -
        VMA_MEMORY_USAGE_GPU_ONLY
        Memory will be used on device only, so faster access from the device is preferred. No need to be mappable on host.
        Definition: vk_mem_alloc.h:598
        +
        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:669
        +
        VMA_MEMORY_USAGE_GPU_ONLY
        Memory will be used on device only, so faster access from the device is preferred. No need to be mappable on host.
        Definition: vk_mem_alloc.h:632
        VmaStatInfo
        struct VmaStatInfo VmaStatInfo
        -
        VmaStatInfo::UnusedBytes
        VkDeviceSize UnusedBytes
        Total number of bytes occupied by unused ranges.
        Definition: vk_mem_alloc.h:548
        +
        VmaStatInfo::UnusedBytes
        VkDeviceSize UnusedBytes
        Total number of bytes occupied by unused ranges.
        Definition: vk_mem_alloc.h:582
        vmaUnmapMemory
        void vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
        -
        VmaStats::memoryHeap
        VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
        Definition: vk_mem_alloc.h:557
        +
        VmaStats::memoryHeap
        VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
        Definition: vk_mem_alloc.h:591
        VmaDefragmentationStats
        struct VmaDefragmentationStats VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        vmaDestroyPool
        void vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
        Destroys VmaPool object and frees Vulkan device memory.
        -
        VmaPoolStats::unusedSize
        VkDeviceSize unusedSize
        Total number of bytes in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:811
        -
        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:754
        +
        VmaPoolStats::unusedSize
        VkDeviceSize unusedSize
        Total number of bytes in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:845
        +
        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:788
        vmaDestroyBuffer
        void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
        -
        VmaStatInfo::UnusedRangeSizeMin
        VkDeviceSize UnusedRangeSizeMin
        Definition: vk_mem_alloc.h:550
        -
        VmaAllocationInfo::memoryType
        uint32_t memoryType
        Memory type index that this allocation was allocated from.
        Definition: vk_mem_alloc.h:868
        +
        VmaStatInfo::UnusedRangeSizeMin
        VkDeviceSize UnusedRangeSizeMin
        Definition: vk_mem_alloc.h:584
        +
        VmaAllocationInfo::memoryType
        uint32_t memoryType
        Memory type index that this allocation was allocated from.
        Definition: vk_mem_alloc.h:902
        VmaPoolCreateInfo
        struct VmaPoolCreateInfo VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        diff --git a/src/vk_mem_alloc.h b/src/vk_mem_alloc.h index 24655f1..474035d 100644 --- a/src/vk_mem_alloc.h +++ b/src/vk_mem_alloc.h @@ -374,15 +374,31 @@ The library uses following algorithm for allocation, in order: Please check "CONFIGURATION SECTION" in the code to find macros that you can define before each `#include` of this file or change directly in this file to provide -your own implementation of basic facilities like assert, min and max functions, +your own implementation of basic facilities like assert, `min()` and `max()` functions, mutex etc. C++ STL is used by default, but changing these allows you to get rid of any STL usage if you want, as many game developers tend to do. -\subsection custom_memory_allocator Custom memory allocator +\subsection custom_memory_allocator Custom host memory allocator -You can use custom memory allocator by filling optional member -VmaAllocatorCreateInfo::pAllocationCallbacks. These functions will be passed to -Vulkan, as well as used by the library itself to make any CPU-side allocations. +If you use custom allocator for CPU memory rather than default operator `new` +and `delete` from C++, you can make this library using your allocator as well +by filling optional member VmaAllocatorCreateInfo::pAllocationCallbacks. These +functions will be passed to Vulkan, as well as used by the library itself to +make any CPU-side allocations. + +\subsection allocation_callbacks Device memory allocation callbacks + +The library makes calls to `vkAllocateMemory()` and `vkFreeMemory()` internally. +You can setup callbacks to be informed about these calls, e.g. for the purpose +of gathering some statistics. To do it, fill optional member +VmaAllocatorCreateInfo::pDeviceMemoryCallbacks. + +\subsection heap_memory_limit Device heap memory limit + +If you want to test how your program behaves with limited amount of Vulkan device +memory available (without switching your graphics card to one that really has +smaller VRAM), you can use a feature of this library intended for this purpose. +To do it, fill optional member VmaAllocatorCreateInfo::pHeapSizeLimit. \section thread_safety Thread safety @@ -458,10 +474,10 @@ typedef struct VmaAllocatorCreateInfo /// Vulkan device. /** It must be valid throughout whole lifetime of created allocator. */ VkDevice device; - /// Size of a single memory block to allocate for resources. + /// Preferred size of a single `VkDeviceMemory` block to be allocated from large heaps. /** Set to 0 to use default, which is currently 256 MB. */ VkDeviceSize preferredLargeHeapBlockSize; - /// Size of a single memory block to allocate for resources from a small heap <= 512 MB. + /// Preferred size of a single `VkDeviceMemory` block to be allocated from small heaps <= 512 MB. /** Set to 0 to use default, which is currently 64 MB. */ VkDeviceSize preferredSmallHeapBlockSize; /// Custom CPU memory allocation callbacks. @@ -484,6 +500,24 @@ typedef struct VmaAllocatorCreateInfo become lost, set this value to 0. */ uint32_t frameInUseCount; + /** \brief Either NULL or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap. + + If not NULL, it must be a pointer to an array of + `VkPhysicalDeviceMemoryProperties::memoryHeapCount` elements, defining limit on + maximum number of bytes that can be allocated out of particular Vulkan memory + heap. + + Any of the elements may be equal to `VK_WHOLE_SIZE`, which means no limit on that + heap. This is also the default in case of `pHeapSizeLimit` = NULL. + + If there is a limit defined for a heap: + + - If user tries to allocate more memory from that heap using this allocator, + the allocation fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`. + - If the limit is smaller than heap size reported in `VkMemoryHeap::size`, the + value of this limit will be reported instead when using vmaGetMemoryProperties(). + */ + const VkDeviceSize* pHeapSizeLimit; } VmaAllocatorCreateInfo; /// Creates Allocator object. @@ -3372,6 +3406,10 @@ struct VmaAllocator_T // Non-zero when we are inside UnmapPersistentlyMappedMemory...MapPersistentlyMappedMemory. // Counter to allow nested calls to these functions. uint32_t m_UnmapPersistentlyMappedMemoryCounter; + + // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap. + VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS]; + VMA_MUTEX m_HeapSizeLimitMutex; VkPhysicalDeviceProperties m_PhysicalDeviceProperties; VkPhysicalDeviceMemoryProperties m_MemProps; @@ -3448,6 +3486,9 @@ struct VmaAllocator_T void CreateLostAllocation(VmaAllocation* pAllocation); + VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory); + void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory); + private: VkDeviceSize m_PreferredLargeHeapBlockSize; VkDeviceSize m_PreferredSmallHeapBlockSize; @@ -4129,13 +4170,7 @@ void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator) m_pMappedData = VMA_NULL; } - // Callback. - if(allocator->m_DeviceMemoryCallbacks.pfnFree != VMA_NULL) - { - (*allocator->m_DeviceMemoryCallbacks.pfnFree)(allocator, m_MemoryTypeIndex, m_hMemory, m_Size); - } - - vkFreeMemory(allocator->m_hDevice, m_hMemory, allocator->GetAllocationCallbacks()); + allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Size, m_hMemory); m_hMemory = VK_NULL_HANDLE; } @@ -5436,7 +5471,7 @@ VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIn allocInfo.allocationSize = blockSize; const VkDevice hDevice = m_hAllocator->m_hDevice; VkDeviceMemory mem = VK_NULL_HANDLE; - VkResult res = vkAllocateMemory(hDevice, &allocInfo, m_hAllocator->GetAllocationCallbacks(), &mem); + VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem); if(res < 0) { return res; @@ -5453,17 +5488,11 @@ VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIn if(res < 0) { VMA_DEBUG_LOG(" vkMapMemory FAILED"); - vkFreeMemory(hDevice, mem, m_hAllocator->GetAllocationCallbacks()); + m_hAllocator->FreeVulkanMemory(m_MemoryTypeIndex, blockSize, mem); return res; } } - // Callback. - if(m_hAllocator->m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL) - { - (*m_hAllocator->m_DeviceMemoryCallbacks.pfnAllocate)(m_hAllocator, m_MemoryTypeIndex, mem, allocInfo.allocationSize); - } - // Create new Allocation for it. VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator); pBlock->Init( @@ -5978,6 +6007,11 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) : memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors)); memset(&m_pOwnAllocations, 0, sizeof(m_pOwnAllocations)); + for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) + { + m_HeapSizeLimit[i] = VK_WHOLE_SIZE; + } + if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL) { m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate; @@ -5992,6 +6026,22 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) : m_PreferredSmallHeapBlockSize = (pCreateInfo->preferredSmallHeapBlockSize != 0) ? pCreateInfo->preferredSmallHeapBlockSize : static_cast(VMA_DEFAULT_SMALL_HEAP_BLOCK_SIZE); + if(pCreateInfo->pHeapSizeLimit != VMA_NULL) + { + for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex) + { + const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex]; + if(limit != VK_WHOLE_SIZE) + { + m_HeapSizeLimit[heapIndex] = limit; + if(limit < m_MemProps.memoryHeaps[heapIndex].size) + { + m_MemProps.memoryHeaps[heapIndex].size = limit; + } + } + } + } + for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex) { const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex); @@ -6031,7 +6081,8 @@ VmaAllocator_T::~VmaAllocator_T() VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex) { - const VkDeviceSize heapSize = m_MemProps.memoryHeaps[MemoryTypeIndexToHeapIndex(memTypeIndex)].size; + const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex); + const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size; return (heapSize <= VMA_SMALL_HEAP_MAX_SIZE) ? m_PreferredSmallHeapBlockSize : m_PreferredLargeHeapBlockSize; } @@ -6128,7 +6179,7 @@ VkResult VmaAllocator_T::AllocateOwnMemory( // Allocate VkDeviceMemory. VkDeviceMemory hMemory = VK_NULL_HANDLE; - VkResult res = vkAllocateMemory(m_hDevice, &allocInfo, GetAllocationCallbacks(), &hMemory); + VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory); if(res < 0) { VMA_DEBUG_LOG(" vkAllocateMemory FAILED"); @@ -6144,18 +6195,12 @@ VkResult VmaAllocator_T::AllocateOwnMemory( if(res < 0) { VMA_DEBUG_LOG(" vkMapMemory FAILED"); - vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks()); + FreeVulkanMemory(memTypeIndex, size, hMemory); return res; } } } - // Callback. - if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL) - { - (*m_DeviceMemoryCallbacks.pfnAllocate)(this, memTypeIndex, hMemory, size); - } - *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load()); (*pAllocation)->InitOwnAllocation(memTypeIndex, hMemory, suballocType, map, pMappedData, size, pUserData); @@ -6695,6 +6740,57 @@ void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation) (*pAllocation)->InitLost(); } +VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory) +{ + const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex); + + VkResult res; + if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE) + { + VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex); + if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize) + { + res = vkAllocateMemory(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory); + if(res == VK_SUCCESS) + { + m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize; + } + } + else + { + res = VK_ERROR_OUT_OF_DEVICE_MEMORY; + } + } + else + { + res = vkAllocateMemory(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory); + } + + if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL) + { + (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize); + } + + return res; +} + +void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory) +{ + if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL) + { + (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size); + } + + vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks()); + + const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType); + if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE) + { + VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex); + m_HeapSizeLimit[heapIndex] += size; + } +} + void VmaAllocator_T::FreeOwnMemory(VmaAllocation allocation) { VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_OWN); @@ -6710,18 +6806,12 @@ void VmaAllocator_T::FreeOwnMemory(VmaAllocation allocation) VkDeviceMemory hMemory = allocation->GetMemory(); - // Callback. - if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL) - { - (*m_DeviceMemoryCallbacks.pfnFree)(this, memTypeIndex, hMemory, allocation->GetSize()); - } - if(allocation->GetMappedData() != VMA_NULL) { vkUnmapMemory(m_hDevice, hMemory); } - vkFreeMemory(m_hDevice, hMemory, GetAllocationCallbacks()); + FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory); VMA_DEBUG_LOG(" Freed OwnMemory MemoryTypeIndex=%u", memTypeIndex); }