From a5d5ffafe2a38ceb6a8f8c3f36336d7cd75ccd25 Mon Sep 17 00:00:00 2001 From: Adam Sawicki Date: Mon, 27 Aug 2018 11:05:24 +0200 Subject: [PATCH] Updated CHANGELOG.md. Recompiled binaries and Doxygen documentation. --- CHANGELOG.md | 4 +- bin/VmaReplay_Release_vs2015.exe | Bin 163328 -> 163840 bytes bin/VulkanSample_Release_vs2015.exe | Bin 210944 -> 212480 bytes docs/html/custom_memory_pools.html | 9 +- docs/html/functions.html | 3 +- docs/html/functions_vars.html | 3 +- docs/html/index.html | 2 +- docs/html/lost_allocations.html | 2 +- docs/html/quick_start.html | 1 + docs/html/search/all_1.js | 2 +- docs/html/search/variables_1.js | 2 +- docs/html/struct_vma_pool_create_info.html | 9 +- docs/html/struct_vma_pool_stats-members.html | 9 +- docs/html/struct_vma_pool_stats.html | 23 +- docs/html/vk__mem__alloc_8h_source.html | 241 ++++++++++--------- 15 files changed, 170 insertions(+), 140 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2795689..57472de 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,7 +26,9 @@ Major changes: Minor changes: -- Changed behavior of custom pools: `VmaPoolCreateInfo::blockSize` = 0 (default) now means that pool may use variable block sizes, just like default pools do. +- Changes in custom pools: + - Added new structure member `VmaPoolStats::blockCount`. + - Changed behavior of `VmaPoolCreateInfo::blockSize` = 0 (default) - it now means that pool may use variable block sizes, just like default pools do. - Improved logic of `vmaFindMemoryTypeIndex` for some cases, especially integrated GPUs. - VulkanSample application: Removed dependency on external library MathFu. Added own vector and matrix structures. - Code changes that improve compatibility with various platforms, including: Visual Studio 2012, 32-bit code, C compilers. diff --git a/bin/VmaReplay_Release_vs2015.exe b/bin/VmaReplay_Release_vs2015.exe index 6613d41c594736c0c7f674c50443ddf479dfd4d7..ab644a5dbe45da50bcc90197e8488932a019182e 100644 GIT binary patch delta 31888 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 z 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 diff --git a/bin/VulkanSample_Release_vs2015.exe b/bin/VulkanSample_Release_vs2015.exe index 104e15fa6a56b19c6d1233d0e74446a5559ac202..a8b201435f3fb6746c3896cbf4dd7b5250d27458 100644 GIT binary patch delta 71193 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 ATmS$7 delta 69461 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 Linear allocation algorithm

With this one flag, you can create a custom pool that can be used in many ways: free-at-once, stack, double stack, and ring buffer. See below for details.

-

Pools with linear algorithm must have only one memory block - VmaPoolCreateInfo::maxBlockCount must be 1.

Free-at-once

In a pool that uses linear algorithm, you still need to free all the allocations individually, e.g. by using vmaFreeMemory() or vmaDestroyBuffer(). You can free them in any order. New allocations are always made after last one - free space in the middle is not reused. However, when you release all the allocation and the pool becomes empty, allocation starts from the beginning again. This way you can use linear algorithm to speed up creation of allocations that you are going to release all at once.

Free-at-once
+

This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount value that allows multiple memory blocks.

Stack

When you free an allocation that was created last, its space can be reused. Thanks to this, if you always release allocations in the order opposite to their creation (LIFO - Last In First Out), you can achieve behavior of a stack.

Stack
+

This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount value that allows multiple memory blocks.

Double stack

The space reserved by a custom pool with linear algorithm may be used by two stacks:

@@ -122,10 +123,11 @@ Double stack
  • Second, "upper" one, growing down from the end towards lower offsets.

    • To make allocation from upper stack, add flag VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT to VmaAllocationCreateInfo::flags.

    -

    When the two stacks' ends meet so there is not enough space between them for a new allocation, such allocation fails with usual VK_ERROR_OUT_OF_DEVICE_MEMORY error.

    Double stack
    +

    Double stack is available only in pools with one memory block - VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.

    +

    When the two stacks' ends meet so there is not enough space between them for a new allocation, such allocation fails with usual VK_ERROR_OUT_OF_DEVICE_MEMORY error.

    Ring buffer

    When you free some allocations from the beginning and there is not enough free space for a new one at the end of a pool, allocator's "cursor" wraps around to the beginning and starts allocation there. Thanks to this, if you always release allocations in the same order as you created them (FIFO - First In First Out), you can achieve behavior of a ring buffer / queue.

    @@ -136,7 +138,8 @@ Ring buffer
    Ring buffer with lost allocations
    - +

    Ring buffer is available only in pools with one memory block - VmaPoolCreateInfo::maxBlockCount must be 1. Otherwise behavior is undefined.

    +
    Generated by   diff --git a/docs/html/functions.html b/docs/html/functions.html index c8ce62d..efb1f35 100644 --- a/docs/html/functions.html +++ b/docs/html/functions.html @@ -82,7 +82,8 @@ $(function() {

    - b -

    • blockCount -: VmaStatInfo +: VmaPoolStats +, VmaStatInfo
    • blockSize : VmaPoolCreateInfo diff --git a/docs/html/functions_vars.html b/docs/html/functions_vars.html index de9e9a0..bb5c24c 100644 --- a/docs/html/functions_vars.html +++ b/docs/html/functions_vars.html @@ -82,7 +82,8 @@ $(function() {

      - b -

      • blockCount -: VmaStatInfo +: VmaPoolStats +, VmaStatInfo
      • blockSize : VmaPoolCreateInfo diff --git a/docs/html/index.html b/docs/html/index.html index 8cf6408..298454e 100644 --- a/docs/html/index.html +++ b/docs/html/index.html @@ -62,7 +62,7 @@ $(function() {
        Vulkan Memory Allocator
        -

        Version 2.1.0-beta.1 (2018-08-24)

        +

        Version 2.1.0-beta.1 (2018-08-27)

        Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved.
        License: MIT

        Documentation of all members: vk_mem_alloc.h

        diff --git a/docs/html/lost_allocations.html b/docs/html/lost_allocations.html index 72e063d..b001774 100644 --- a/docs/html/lost_allocations.html +++ b/docs/html/lost_allocations.html @@ -77,7 +77,7 @@ $(function() {

        Q: How do you inform the library when new frame starts?

        You need to call function vmaSetCurrentFrameIndex().

        Example code:

        -
        struct MyBuffer
        {
        VkBuffer m_Buf = nullptr;
        VmaAllocation m_Alloc = nullptr;
        // Called when the buffer is really needed in the current frame.
        void EnsureBuffer();
        };
        void MyBuffer::EnsureBuffer()
        {
        // Buffer has been created.
        if(m_Buf != VK_NULL_HANDLE)
        {
        // Check if its allocation is not lost + mark it as used in current frame.
        if(vmaTouchAllocation(allocator, m_Alloc))
        {
        // It's all OK - safe to use m_Buf.
        return;
        }
        }
        // Buffer not yet exists or lost - destroy and recreate it.
        vmaDestroyBuffer(allocator, m_Buf, m_Alloc);
        VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
        bufCreateInfo.size = 1024;
        bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        VmaAllocationCreateInfo allocCreateInfo = {};
        allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
        allocCreateInfo.flags = VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT |
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
        vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &m_Buf, &m_Alloc, nullptr);
        }

        When using lost allocations, you may see some Vulkan validation layer warnings about overlapping regions of memory bound to different kinds of buffers and images. This is still valid as long as you implement proper handling of lost allocations (like in the example above) and don't use them.

        +
        struct MyBuffer
        {
        VkBuffer m_Buf = nullptr;
        VmaAllocation m_Alloc = nullptr;
        // Called when the buffer is really needed in the current frame.
        void EnsureBuffer();
        };
        void MyBuffer::EnsureBuffer()
        {
        // Buffer has been created.
        if(m_Buf != VK_NULL_HANDLE)
        {
        // Check if its allocation is not lost + mark it as used in current frame.
        if(vmaTouchAllocation(allocator, m_Alloc))
        {
        // It's all OK - safe to use m_Buf.
        return;
        }
        }
        // Buffer not yet exists or lost - destroy and recreate it.
        vmaDestroyBuffer(allocator, m_Buf, m_Alloc);
        VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
        bufCreateInfo.size = 1024;
        bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        VmaAllocationCreateInfo allocCreateInfo = {};
        allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
        allocCreateInfo.flags = VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT |
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
        vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &m_Buf, &m_Alloc, nullptr);
        }

        When using lost allocations, you may see some Vulkan validation layer warnings about overlapping regions of memory bound to different kinds of buffers and images. This is still valid as long as you implement proper handling of lost allocations (like in the example above) and don't use them.

        You can create an allocation that is already in lost state from the beginning using function vmaCreateLostAllocation(). It may be useful if you need a "dummy" allocation that is not null.

        You can call function vmaMakePoolAllocationsLost() to set all eligible allocations in a specified custom pool to lost state. Allocations that have been "touched" in current frame or VmaPoolCreateInfo::frameInUseCount frames back cannot become lost.

        Q: Can I touch allocation that cannot become lost?

        diff --git a/docs/html/quick_start.html b/docs/html/quick_start.html index ae0bc59..517eca2 100644 --- a/docs/html/quick_start.html +++ b/docs/html/quick_start.html @@ -76,6 +76,7 @@ Project setup
      • In exacly one CPP file define following macro before this include. It enables also internal definitions.
        • #define VMA_IMPLEMENTATION
        #include "vk_mem_alloc.h"

        It may be a good idea to create dedicated CPP file just for this purpose.

        +

        Please note that this library includes header <vulkan/vulkan.h>, which in turn includes <windows.h> on Windows. If you need some specific macros defined before including these headers (like NOMINMAX, WIN32_LEAN_AND_MEAN, or WINVER for Windows, VK_USE_PLATFORM_WIN32_KHR for Vulkan), you must define them before every #include of this library.

        Initialization

        At program startup:

        diff --git a/docs/html/search/all_1.js b/docs/html/search/all_1.js index cff2c47..7ae997e 100644 --- a/docs/html/search/all_1.js +++ b/docs/html/search/all_1.js @@ -1,6 +1,6 @@ var searchData= [ - ['blockcount',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo']]], + ['blockcount',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo::blockCount()'],['../struct_vma_pool_stats.html#aa0b5cb45cef6f18571cefb03b9a230e7',1,'VmaPoolStats::blockCount()']]], ['blocksize',['blockSize',['../struct_vma_pool_create_info.html#aa4265160536cdb9be821b7686c16c676',1,'VmaPoolCreateInfo']]], ['bytesfreed',['bytesFreed',['../struct_vma_defragmentation_stats.html#ab0cb9ac0dbc106c77e384ea676422f28',1,'VmaDefragmentationStats']]], ['bytesmoved',['bytesMoved',['../struct_vma_defragmentation_stats.html#a36f9d5df2a10ba2a36b16e126d60572d',1,'VmaDefragmentationStats']]] diff --git a/docs/html/search/variables_1.js b/docs/html/search/variables_1.js index cff2c47..7ae997e 100644 --- a/docs/html/search/variables_1.js +++ b/docs/html/search/variables_1.js @@ -1,6 +1,6 @@ var searchData= [ - ['blockcount',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo']]], + ['blockcount',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo::blockCount()'],['../struct_vma_pool_stats.html#aa0b5cb45cef6f18571cefb03b9a230e7',1,'VmaPoolStats::blockCount()']]], ['blocksize',['blockSize',['../struct_vma_pool_create_info.html#aa4265160536cdb9be821b7686c16c676',1,'VmaPoolCreateInfo']]], ['bytesfreed',['bytesFreed',['../struct_vma_defragmentation_stats.html#ab0cb9ac0dbc106c77e384ea676422f28',1,'VmaDefragmentationStats']]], ['bytesmoved',['bytesMoved',['../struct_vma_defragmentation_stats.html#a36f9d5df2a10ba2a36b16e126d60572d',1,'VmaDefragmentationStats']]] diff --git a/docs/html/struct_vma_pool_create_info.html b/docs/html/struct_vma_pool_create_info.html index aa5ba2a..d0bbc42 100644 --- a/docs/html/struct_vma_pool_create_info.html +++ b/docs/html/struct_vma_pool_create_info.html @@ -80,7 +80,7 @@ Public Attributes  Use combination of VmaPoolCreateFlagBits. More...
          VkDeviceSize blockSize - Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes. More...
        + Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes. Optional. More...
          size_t minBlockCount  Minimum number of blocks to be always allocated in this pool, even if they stay empty. More...
        @@ -107,8 +107,9 @@ Public Attributes
        -

        Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes.

        -

        Optional. Leave 0 to use default.

        +

        Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes. Optional.

        +

        Specify nonzero to set explicit, constant size of memory blocks used by this pool.

        +

        Leave 0 to use default and let the library manage block sizes automatically. Sizes of particular blocks may vary.

        @@ -160,7 +161,7 @@ Public Attributes

        Maximum number of blocks that can be allocated in this pool. Optional.

        -

        Set to 0 to use default, which is SIZE_MAX, which means no limit. When VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT is used, default is 1.

        +

        Set to 0 to use default, which is SIZE_MAX, which means no limit.

        Set to same value as VmaPoolCreateInfo::minBlockCount to have fixed amount of memory allocated throughout whole lifetime of this pool.

        diff --git a/docs/html/struct_vma_pool_stats-members.html b/docs/html/struct_vma_pool_stats-members.html index 66df81b..f73f53c 100644 --- a/docs/html/struct_vma_pool_stats-members.html +++ b/docs/html/struct_vma_pool_stats-members.html @@ -66,10 +66,11 @@ $(function() {

        This is the complete list of members for VmaPoolStats, including all inherited members.

        - - - - + + + + +
        allocationCountVmaPoolStats
        sizeVmaPoolStats
        unusedRangeCountVmaPoolStats
        unusedRangeSizeMaxVmaPoolStats
        unusedSizeVmaPoolStats
        blockCountVmaPoolStats
        sizeVmaPoolStats
        unusedRangeCountVmaPoolStats
        unusedRangeSizeMaxVmaPoolStats
        unusedSizeVmaPoolStats
        diff --git a/docs/html/struct_vma_pool_stats.html b/docs/html/struct_vma_pool_stats.html index 3ee189b..93866b3 100644 --- a/docs/html/struct_vma_pool_stats.html +++ b/docs/html/struct_vma_pool_stats.html @@ -86,8 +86,11 @@ Public Attributes  Number of continuous memory ranges in the pool not used by any VmaAllocation. More...
          VkDeviceSize unusedRangeSizeMax - Size of the largest continuous free memory region. More...
        + Size of the largest continuous free memory region available for new allocation. More...
          +size_t blockCount + Number of VkDeviceMemory blocks allocated for this pool. More...
        + 

        Detailed Description

        Describes parameter of existing VmaPool.

        @@ -106,6 +109,22 @@ Public Attributes

        Number of VmaAllocation objects created from this pool that were not destroyed or lost.

        +
        + + +

        ◆ blockCount

        + +
        +
        + + + + +
        size_t VmaPoolStats::blockCount
        +
        + +

        Number of VkDeviceMemory blocks allocated for this pool.

        +
        @@ -152,7 +171,7 @@ Public Attributes
        -

        Size of the largest continuous free memory region.

        +

        Size of the largest continuous free memory region available for new allocation.

        Making a new allocation of that size is not guaranteed to succeed because of possible additional margin required to respect alignment and buffer/image granularity.

        diff --git a/docs/html/vk__mem__alloc_8h_source.html b/docs/html/vk__mem__alloc_8h_source.html index bbbc16f..95cdbf9 100644 --- a/docs/html/vk__mem__alloc_8h_source.html +++ b/docs/html/vk__mem__alloc_8h_source.html @@ -62,178 +62,179 @@ $(function() {
        vk_mem_alloc.h
        -Go to the documentation of this file.
        1 //
        2 // Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved.
        3 //
        4 // Permission is hereby granted, free of charge, to any person obtaining a copy
        5 // of this software and associated documentation files (the "Software"), to deal
        6 // in the Software without restriction, including without limitation the rights
        7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        8 // copies of the Software, and to permit persons to whom the Software is
        9 // furnished to do so, subject to the following conditions:
        10 //
        11 // The above copyright notice and this permission notice shall be included in
        12 // all copies or substantial portions of the Software.
        13 //
        14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        20 // THE SOFTWARE.
        21 //
        22 
        23 #ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
        24 #define AMD_VULKAN_MEMORY_ALLOCATOR_H
        25 
        26 #ifdef __cplusplus
        27 extern "C" {
        28 #endif
        29 
        1343 #include <vulkan/vulkan.h>
        1344 
        1345 #if !defined(VMA_DEDICATED_ALLOCATION)
        1346  #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
        1347  #define VMA_DEDICATED_ALLOCATION 1
        1348  #else
        1349  #define VMA_DEDICATED_ALLOCATION 0
        1350  #endif
        1351 #endif
        1352 
        1362 VK_DEFINE_HANDLE(VmaAllocator)
        1363 
        1364 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
        1366  VmaAllocator allocator,
        1367  uint32_t memoryType,
        1368  VkDeviceMemory memory,
        1369  VkDeviceSize size);
        1371 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
        1372  VmaAllocator allocator,
        1373  uint32_t memoryType,
        1374  VkDeviceMemory memory,
        1375  VkDeviceSize size);
        1376 
        1384 typedef struct VmaDeviceMemoryCallbacks {
        1386  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
        1388  PFN_vmaFreeDeviceMemoryFunction pfnFree;
        1389 } VmaDeviceMemoryCallbacks;
        1390 
        1392 typedef enum VmaAllocatorCreateFlagBits {
        1397  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
        1419  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
        1420 
        1421  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1422 } VmaAllocatorCreateFlagBits;
        1423 typedef VkFlags VmaAllocatorCreateFlags;
        1424 
        1429 typedef struct VmaVulkanFunctions {
        1430  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
        1431  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
        1432  PFN_vkAllocateMemory vkAllocateMemory;
        1433  PFN_vkFreeMemory vkFreeMemory;
        1434  PFN_vkMapMemory vkMapMemory;
        1435  PFN_vkUnmapMemory vkUnmapMemory;
        1436  PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
        1437  PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
        1438  PFN_vkBindBufferMemory vkBindBufferMemory;
        1439  PFN_vkBindImageMemory vkBindImageMemory;
        1440  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
        1441  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
        1442  PFN_vkCreateBuffer vkCreateBuffer;
        1443  PFN_vkDestroyBuffer vkDestroyBuffer;
        1444  PFN_vkCreateImage vkCreateImage;
        1445  PFN_vkDestroyImage vkDestroyImage;
        1446 #if VMA_DEDICATED_ALLOCATION
        1447  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
        1448  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
        1449 #endif
        1450 } VmaVulkanFunctions;
        1451 
        1453 typedef enum VmaRecordFlagBits {
        1459  VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,
        1460 
        1461  VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1462 } VmaRecordFlagBits;
        1463 typedef VkFlags VmaRecordFlags;
        1464 
        1465 /*
        1466 Define this macro to 0/1 to disable/enable support for recording functionality,
        1467 available through VmaAllocatorCreateInfo::pRecordSettings.
        1468 */
        1469 #ifndef VMA_RECORDING_ENABLED
        1470  #ifdef _WIN32
        1471  #define VMA_RECORDING_ENABLED 1
        1472  #else
        1473  #define VMA_RECORDING_ENABLED 0
        1474  #endif
        1475 #endif
        1476 
        1478 typedef struct VmaRecordSettings
        1479 {
        1481  VmaRecordFlags flags;
        1489  const char* pFilePath;
        1490 } VmaRecordSettings;
        1491 
        1493 typedef struct VmaAllocatorCreateInfo
        1494 {
        1496  VmaAllocatorCreateFlags flags;
        1498 
        1499  VkPhysicalDevice physicalDevice;
        1501 
        1502  VkDevice device;
        1504 
        1505  VkDeviceSize preferredLargeHeapBlockSize;
        1507 
        1508  const VkAllocationCallbacks* pAllocationCallbacks;
        1510 
        1511  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
        1525  uint32_t frameInUseCount;
        1549  const VkDeviceSize* pHeapSizeLimit;
        1561  const VmaVulkanFunctions* pVulkanFunctions;
        1568  const VmaRecordSettings* pRecordSettings;
        1569 } VmaAllocatorCreateInfo;
        1570 
        1572 VkResult vmaCreateAllocator(
        1573  const VmaAllocatorCreateInfo* pCreateInfo,
        1574  VmaAllocator* pAllocator);
        1575 
        1577 void vmaDestroyAllocator(
        1578  VmaAllocator allocator);
        1579 
        1584 void vmaGetPhysicalDeviceProperties(
        1585  VmaAllocator allocator,
        1586  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
        1587 
        1592 void vmaGetMemoryProperties(
        1593  VmaAllocator allocator,
        1594  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
        1595 
        1602 void vmaGetMemoryTypeProperties(
        1603  VmaAllocator allocator,
        1604  uint32_t memoryTypeIndex,
        1605  VkMemoryPropertyFlags* pFlags);
        1606 
        1615 void vmaSetCurrentFrameIndex(
        1616  VmaAllocator allocator,
        1617  uint32_t frameIndex);
        1618 
        1621 typedef struct VmaStatInfo
        1622 {
        1624  uint32_t blockCount;
        1626  uint32_t allocationCount;
        1628  uint32_t unusedRangeCount;
        1630  VkDeviceSize usedBytes;
        1632  VkDeviceSize unusedBytes;
        1633  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
        1634  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
        1635 } VmaStatInfo;
        1636 
        1638 typedef struct VmaStats
        1639 {
        1640  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
        1641  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
        1642  VmaStatInfo total;
        1643 } VmaStats;
        1644 
        1646 void vmaCalculateStats(
        1647  VmaAllocator allocator,
        1648  VmaStats* pStats);
        1649 
        1650 #define VMA_STATS_STRING_ENABLED 1
        1651 
        1652 #if VMA_STATS_STRING_ENABLED
        1653 
        1655 
        1657 void vmaBuildStatsString(
        1658  VmaAllocator allocator,
        1659  char** ppStatsString,
        1660  VkBool32 detailedMap);
        1661 
        1662 void vmaFreeStatsString(
        1663  VmaAllocator allocator,
        1664  char* pStatsString);
        1665 
        1666 #endif // #if VMA_STATS_STRING_ENABLED
        1667 
        1676 VK_DEFINE_HANDLE(VmaPool)
        1677 
        1678 typedef enum VmaMemoryUsage
        1679 {
        1683  VMA_MEMORY_USAGE_UNKNOWN = 0,
        1700  VMA_MEMORY_USAGE_GPU_ONLY = 1,
        1710  VMA_MEMORY_USAGE_CPU_ONLY = 2,
        1717  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
        1726  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
        1727  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
        1728 } VmaMemoryUsage;
        1729 
        1731 typedef enum VmaAllocationCreateFlagBits {
        1743  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
        1744 
        1754  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
        1767  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
        1780  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
        1787  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
        1793  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
        1798  VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
        1799 
        1800  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1801 } VmaAllocationCreateFlagBits;
        1802 typedef VkFlags VmaAllocationCreateFlags;
        1803 
        1804 typedef struct VmaAllocationCreateInfo
        1805 {
        1807  VmaAllocationCreateFlags flags;
        1813  VmaMemoryUsage usage;
        1818  VkMemoryPropertyFlags requiredFlags;
        1823  VkMemoryPropertyFlags preferredFlags;
        1831  uint32_t memoryTypeBits;
        1837  VmaPool pool;
        1844  void* pUserData;
        1845 } VmaAllocationCreateInfo;
        1846 
        1863 VkResult vmaFindMemoryTypeIndex(
        1864  VmaAllocator allocator,
        1865  uint32_t memoryTypeBits,
        1866  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1867  uint32_t* pMemoryTypeIndex);
        1868 
        1881 VkResult vmaFindMemoryTypeIndexForBufferInfo(
        1882  VmaAllocator allocator,
        1883  const VkBufferCreateInfo* pBufferCreateInfo,
        1884  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1885  uint32_t* pMemoryTypeIndex);
        1886 
        1899 VkResult vmaFindMemoryTypeIndexForImageInfo(
        1900  VmaAllocator allocator,
        1901  const VkImageCreateInfo* pImageCreateInfo,
        1902  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1903  uint32_t* pMemoryTypeIndex);
        1904 
        1906 typedef enum VmaPoolCreateFlagBits {
        1924  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
        1925 
        1939  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
        1940 
        1941  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1942 } VmaPoolCreateFlagBits;
        1943 typedef VkFlags VmaPoolCreateFlags;
        1944 
        1947 typedef struct VmaPoolCreateInfo {
        1950  uint32_t memoryTypeIndex;
        1953  VmaPoolCreateFlags flags;
        1958  VkDeviceSize blockSize;
        1963  size_t minBlockCount;
        1972  size_t maxBlockCount;
        1986  uint32_t frameInUseCount;
        1987 } VmaPoolCreateInfo;
        1988 
        1991 typedef struct VmaPoolStats {
        1994  VkDeviceSize size;
        1997  VkDeviceSize unusedSize;
        2000  size_t allocationCount;
        2003  size_t unusedRangeCount;
        2010  VkDeviceSize unusedRangeSizeMax;
        2011 } VmaPoolStats;
        2012 
        2019 VkResult vmaCreatePool(
        2020  VmaAllocator allocator,
        2021  const VmaPoolCreateInfo* pCreateInfo,
        2022  VmaPool* pPool);
        2023 
        2026 void vmaDestroyPool(
        2027  VmaAllocator allocator,
        2028  VmaPool pool);
        2029 
        2036 void vmaGetPoolStats(
        2037  VmaAllocator allocator,
        2038  VmaPool pool,
        2039  VmaPoolStats* pPoolStats);
        2040 
        2047 void vmaMakePoolAllocationsLost(
        2048  VmaAllocator allocator,
        2049  VmaPool pool,
        2050  size_t* pLostAllocationCount);
        2051 
        2066 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
        2067 
        2092 VK_DEFINE_HANDLE(VmaAllocation)
        2093 
        2094 
        2096 typedef struct VmaAllocationInfo {
        2101  uint32_t memoryType;
        2110  VkDeviceMemory deviceMemory;
        2115  VkDeviceSize offset;
        2120  VkDeviceSize size;
        2129  void* pMappedData;
        2134  void* pUserData;
        2135 } VmaAllocationInfo;
        2136 
        2147 VkResult vmaAllocateMemory(
        2148  VmaAllocator allocator,
        2149  const VkMemoryRequirements* pVkMemoryRequirements,
        2150  const VmaAllocationCreateInfo* pCreateInfo,
        2151  VmaAllocation* pAllocation,
        2152  VmaAllocationInfo* pAllocationInfo);
        2153 
        2160 VkResult vmaAllocateMemoryForBuffer(
        2161  VmaAllocator allocator,
        2162  VkBuffer buffer,
        2163  const VmaAllocationCreateInfo* pCreateInfo,
        2164  VmaAllocation* pAllocation,
        2165  VmaAllocationInfo* pAllocationInfo);
        2166 
        2168 VkResult vmaAllocateMemoryForImage(
        2169  VmaAllocator allocator,
        2170  VkImage image,
        2171  const VmaAllocationCreateInfo* pCreateInfo,
        2172  VmaAllocation* pAllocation,
        2173  VmaAllocationInfo* pAllocationInfo);
        2174 
        2176 void vmaFreeMemory(
        2177  VmaAllocator allocator,
        2178  VmaAllocation allocation);
        2179 
        2196 void vmaGetAllocationInfo(
        2197  VmaAllocator allocator,
        2198  VmaAllocation allocation,
        2199  VmaAllocationInfo* pAllocationInfo);
        2200 
        2215 VkBool32 vmaTouchAllocation(
        2216  VmaAllocator allocator,
        2217  VmaAllocation allocation);
        2218 
        2232 void vmaSetAllocationUserData(
        2233  VmaAllocator allocator,
        2234  VmaAllocation allocation,
        2235  void* pUserData);
        2236 
        2247 void vmaCreateLostAllocation(
        2248  VmaAllocator allocator,
        2249  VmaAllocation* pAllocation);
        2250 
        2285 VkResult vmaMapMemory(
        2286  VmaAllocator allocator,
        2287  VmaAllocation allocation,
        2288  void** ppData);
        2289 
        2294 void vmaUnmapMemory(
        2295  VmaAllocator allocator,
        2296  VmaAllocation allocation);
        2297 
        2310 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        2311 
        2324 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        2325 
        2342 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
        2343 
        2345 typedef struct VmaDefragmentationInfo {
        2350  VkDeviceSize maxBytesToMove;
        2355  uint32_t maxAllocationsToMove;
        2356 } VmaDefragmentationInfo;
        2357 
        2359 typedef struct VmaDefragmentationStats {
        2361  VkDeviceSize bytesMoved;
        2363  VkDeviceSize bytesFreed;
        2365  uint32_t allocationsMoved;
        2367  uint32_t deviceMemoryBlocksFreed;
        2368 } VmaDefragmentationStats;
        2369 
        2456 VkResult vmaDefragment(
        2457  VmaAllocator allocator,
        2458  VmaAllocation* pAllocations,
        2459  size_t allocationCount,
        2460  VkBool32* pAllocationsChanged,
        2461  const VmaDefragmentationInfo *pDefragmentationInfo,
        2462  VmaDefragmentationStats* pDefragmentationStats);
        2463 
        2476 VkResult vmaBindBufferMemory(
        2477  VmaAllocator allocator,
        2478  VmaAllocation allocation,
        2479  VkBuffer buffer);
        2480 
        2493 VkResult vmaBindImageMemory(
        2494  VmaAllocator allocator,
        2495  VmaAllocation allocation,
        2496  VkImage image);
        2497 
        2524 VkResult vmaCreateBuffer(
        2525  VmaAllocator allocator,
        2526  const VkBufferCreateInfo* pBufferCreateInfo,
        2527  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        2528  VkBuffer* pBuffer,
        2529  VmaAllocation* pAllocation,
        2530  VmaAllocationInfo* pAllocationInfo);
        2531 
        2543 void vmaDestroyBuffer(
        2544  VmaAllocator allocator,
        2545  VkBuffer buffer,
        2546  VmaAllocation allocation);
        2547 
        2549 VkResult vmaCreateImage(
        2550  VmaAllocator allocator,
        2551  const VkImageCreateInfo* pImageCreateInfo,
        2552  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        2553  VkImage* pImage,
        2554  VmaAllocation* pAllocation,
        2555  VmaAllocationInfo* pAllocationInfo);
        2556 
        2568 void vmaDestroyImage(
        2569  VmaAllocator allocator,
        2570  VkImage image,
        2571  VmaAllocation allocation);
        2572 
        2573 #ifdef __cplusplus
        2574 }
        2575 #endif
        2576 
        2577 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
        2578 
        2579 // For Visual Studio IntelliSense.
        2580 #if defined(__cplusplus) && defined(__INTELLISENSE__)
        2581 #define VMA_IMPLEMENTATION
        2582 #endif
        2583 
        2584 #ifdef VMA_IMPLEMENTATION
        2585 #undef VMA_IMPLEMENTATION
        2586 
        2587 #include <cstdint>
        2588 #include <cstdlib>
        2589 #include <cstring>
        2590 
        2591 /*******************************************************************************
        2592 CONFIGURATION SECTION
        2593 
        2594 Define some of these macros before each #include of this header or change them
        2595 here if you need other then default behavior depending on your environment.
        2596 */
        2597 
        2598 /*
        2599 Define this macro to 1 to make the library fetch pointers to Vulkan functions
        2600 internally, like:
        2601 
        2602  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
        2603 
        2604 Define to 0 if you are going to provide you own pointers to Vulkan functions via
        2605 VmaAllocatorCreateInfo::pVulkanFunctions.
        2606 */
        2607 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
        2608 #define VMA_STATIC_VULKAN_FUNCTIONS 1
        2609 #endif
        2610 
        2611 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
        2612 //#define VMA_USE_STL_CONTAINERS 1
        2613 
        2614 /* Set this macro to 1 to make the library including and using STL containers:
        2615 std::pair, std::vector, std::list, std::unordered_map.
        2616 
        2617 Set it to 0 or undefined to make the library using its own implementation of
        2618 the containers.
        2619 */
        2620 #if VMA_USE_STL_CONTAINERS
        2621  #define VMA_USE_STL_VECTOR 1
        2622  #define VMA_USE_STL_UNORDERED_MAP 1
        2623  #define VMA_USE_STL_LIST 1
        2624 #endif
        2625 
        2626 #if VMA_USE_STL_VECTOR
        2627  #include <vector>
        2628 #endif
        2629 
        2630 #if VMA_USE_STL_UNORDERED_MAP
        2631  #include <unordered_map>
        2632 #endif
        2633 
        2634 #if VMA_USE_STL_LIST
        2635  #include <list>
        2636 #endif
        2637 
        2638 /*
        2639 Following headers are used in this CONFIGURATION section only, so feel free to
        2640 remove them if not needed.
        2641 */
        2642 #include <cassert> // for assert
        2643 #include <algorithm> // for min, max
        2644 #include <mutex> // for std::mutex
        2645 #include <atomic> // for std::atomic
        2646 
        2647 #ifndef VMA_NULL
        2648  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
        2649  #define VMA_NULL nullptr
        2650 #endif
        2651 
        2652 #if defined(__APPLE__) || defined(__ANDROID__)
        2653 #include <cstdlib>
        2654 void *aligned_alloc(size_t alignment, size_t size)
        2655 {
        2656  // alignment must be >= sizeof(void*)
        2657  if(alignment < sizeof(void*))
        2658  {
        2659  alignment = sizeof(void*);
        2660  }
        2661 
        2662  void *pointer;
        2663  if(posix_memalign(&pointer, alignment, size) == 0)
        2664  return pointer;
        2665  return VMA_NULL;
        2666 }
        2667 #endif
        2668 
        2669 // If your compiler is not compatible with C++11 and definition of
        2670 // aligned_alloc() function is missing, uncommeting following line may help:
        2671 
        2672 //#include <malloc.h>
        2673 
        2674 // Normal assert to check for programmer's errors, especially in Debug configuration.
        2675 #ifndef VMA_ASSERT
        2676  #ifdef _DEBUG
        2677  #define VMA_ASSERT(expr) assert(expr)
        2678  #else
        2679  #define VMA_ASSERT(expr)
        2680  #endif
        2681 #endif
        2682 
        2683 // Assert that will be called very often, like inside data structures e.g. operator[].
        2684 // Making it non-empty can make program slow.
        2685 #ifndef VMA_HEAVY_ASSERT
        2686  #ifdef _DEBUG
        2687  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
        2688  #else
        2689  #define VMA_HEAVY_ASSERT(expr)
        2690  #endif
        2691 #endif
        2692 
        2693 #ifndef VMA_ALIGN_OF
        2694  #define VMA_ALIGN_OF(type) (__alignof(type))
        2695 #endif
        2696 
        2697 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
        2698  #if defined(_WIN32)
        2699  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
        2700  #else
        2701  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
        2702  #endif
        2703 #endif
        2704 
        2705 #ifndef VMA_SYSTEM_FREE
        2706  #if defined(_WIN32)
        2707  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
        2708  #else
        2709  #define VMA_SYSTEM_FREE(ptr) free(ptr)
        2710  #endif
        2711 #endif
        2712 
        2713 #ifndef VMA_MIN
        2714  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
        2715 #endif
        2716 
        2717 #ifndef VMA_MAX
        2718  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
        2719 #endif
        2720 
        2721 #ifndef VMA_SWAP
        2722  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
        2723 #endif
        2724 
        2725 #ifndef VMA_SORT
        2726  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
        2727 #endif
        2728 
        2729 #ifndef VMA_DEBUG_LOG
        2730  #define VMA_DEBUG_LOG(format, ...)
        2731  /*
        2732  #define VMA_DEBUG_LOG(format, ...) do { \
        2733  printf(format, __VA_ARGS__); \
        2734  printf("\n"); \
        2735  } while(false)
        2736  */
        2737 #endif
        2738 
        2739 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
        2740 #if VMA_STATS_STRING_ENABLED
        2741  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
        2742  {
        2743  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
        2744  }
        2745  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
        2746  {
        2747  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
        2748  }
        2749  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
        2750  {
        2751  snprintf(outStr, strLen, "%p", ptr);
        2752  }
        2753 #endif
        2754 
        2755 #ifndef VMA_MUTEX
        2756  class VmaMutex
        2757  {
        2758  public:
        2759  VmaMutex() { }
        2760  ~VmaMutex() { }
        2761  void Lock() { m_Mutex.lock(); }
        2762  void Unlock() { m_Mutex.unlock(); }
        2763  private:
        2764  std::mutex m_Mutex;
        2765  };
        2766  #define VMA_MUTEX VmaMutex
        2767 #endif
        2768 
        2769 /*
        2770 If providing your own implementation, you need to implement a subset of std::atomic:
        2771 
        2772 - Constructor(uint32_t desired)
        2773 - uint32_t load() const
        2774 - void store(uint32_t desired)
        2775 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
        2776 */
        2777 #ifndef VMA_ATOMIC_UINT32
        2778  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
        2779 #endif
        2780 
        2781 #ifndef VMA_BEST_FIT
        2782 
        2794  #define VMA_BEST_FIT (1)
        2795 #endif
        2796 
        2797 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
        2798 
        2802  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
        2803 #endif
        2804 
        2805 #ifndef VMA_DEBUG_ALIGNMENT
        2806 
        2810  #define VMA_DEBUG_ALIGNMENT (1)
        2811 #endif
        2812 
        2813 #ifndef VMA_DEBUG_MARGIN
        2814 
        2818  #define VMA_DEBUG_MARGIN (0)
        2819 #endif
        2820 
        2821 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
        2822 
        2826  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
        2827 #endif
        2828 
        2829 #ifndef VMA_DEBUG_DETECT_CORRUPTION
        2830 
        2835  #define VMA_DEBUG_DETECT_CORRUPTION (0)
        2836 #endif
        2837 
        2838 #ifndef VMA_DEBUG_GLOBAL_MUTEX
        2839 
        2843  #define VMA_DEBUG_GLOBAL_MUTEX (0)
        2844 #endif
        2845 
        2846 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
        2847 
        2851  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
        2852 #endif
        2853 
        2854 #ifndef VMA_SMALL_HEAP_MAX_SIZE
        2855  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
        2857 #endif
        2858 
        2859 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
        2860  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
        2862 #endif
        2863 
        2864 #ifndef VMA_CLASS_NO_COPY
        2865  #define VMA_CLASS_NO_COPY(className) \
        2866  private: \
        2867  className(const className&) = delete; \
        2868  className& operator=(const className&) = delete;
        2869 #endif
        2870 
        2871 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
        2872 
        2873 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
        2874 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
        2875 
        2876 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
        2877 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
        2878 
        2879 /*******************************************************************************
        2880 END OF CONFIGURATION
        2881 */
        2882 
        2883 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
        2884  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
        2885 
        2886 // Returns number of bits set to 1 in (v).
        2887 static inline uint32_t VmaCountBitsSet(uint32_t v)
        2888 {
        2889  uint32_t c = v - ((v >> 1) & 0x55555555);
        2890  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
        2891  c = ((c >> 4) + c) & 0x0F0F0F0F;
        2892  c = ((c >> 8) + c) & 0x00FF00FF;
        2893  c = ((c >> 16) + c) & 0x0000FFFF;
        2894  return c;
        2895 }
        2896 
        2897 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
        2898 // Use types like uint32_t, uint64_t as T.
        2899 template <typename T>
        2900 static inline T VmaAlignUp(T val, T align)
        2901 {
        2902  return (val + align - 1) / align * align;
        2903 }
        2904 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
        2905 // Use types like uint32_t, uint64_t as T.
        2906 template <typename T>
        2907 static inline T VmaAlignDown(T val, T align)
        2908 {
        2909  return val / align * align;
        2910 }
        2911 
        2912 // Division with mathematical rounding to nearest number.
        2913 template <typename T>
        2914 inline T VmaRoundDiv(T x, T y)
        2915 {
        2916  return (x + (y / (T)2)) / y;
        2917 }
        2918 
        2919 static inline bool VmaStrIsEmpty(const char* pStr)
        2920 {
        2921  return pStr == VMA_NULL || *pStr == '\0';
        2922 }
        2923 
        2924 #ifndef VMA_SORT
        2925 
        2926 template<typename Iterator, typename Compare>
        2927 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
        2928 {
        2929  Iterator centerValue = end; --centerValue;
        2930  Iterator insertIndex = beg;
        2931  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
        2932  {
        2933  if(cmp(*memTypeIndex, *centerValue))
        2934  {
        2935  if(insertIndex != memTypeIndex)
        2936  {
        2937  VMA_SWAP(*memTypeIndex, *insertIndex);
        2938  }
        2939  ++insertIndex;
        2940  }
        2941  }
        2942  if(insertIndex != centerValue)
        2943  {
        2944  VMA_SWAP(*insertIndex, *centerValue);
        2945  }
        2946  return insertIndex;
        2947 }
        2948 
        2949 template<typename Iterator, typename Compare>
        2950 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
        2951 {
        2952  if(beg < end)
        2953  {
        2954  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
        2955  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
        2956  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
        2957  }
        2958 }
        2959 
        2960 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
        2961 
        2962 #endif // #ifndef VMA_SORT
        2963 
        2964 /*
        2965 Returns true if two memory blocks occupy overlapping pages.
        2966 ResourceA must be in less memory offset than ResourceB.
        2967 
        2968 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
        2969 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
        2970 */
        2971 static inline bool VmaBlocksOnSamePage(
        2972  VkDeviceSize resourceAOffset,
        2973  VkDeviceSize resourceASize,
        2974  VkDeviceSize resourceBOffset,
        2975  VkDeviceSize pageSize)
        2976 {
        2977  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
        2978  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
        2979  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
        2980  VkDeviceSize resourceBStart = resourceBOffset;
        2981  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
        2982  return resourceAEndPage == resourceBStartPage;
        2983 }
        2984 
        2985 enum VmaSuballocationType
        2986 {
        2987  VMA_SUBALLOCATION_TYPE_FREE = 0,
        2988  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
        2989  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
        2990  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        2991  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        2992  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        2993  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
        2994 };
        2995 
        2996 /*
        2997 Returns true if given suballocation types could conflict and must respect
        2998 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
        2999 or linear image and another one is optimal image. If type is unknown, behave
        3000 conservatively.
        3001 */
        3002 static inline bool VmaIsBufferImageGranularityConflict(
        3003  VmaSuballocationType suballocType1,
        3004  VmaSuballocationType suballocType2)
        3005 {
        3006  if(suballocType1 > suballocType2)
        3007  {
        3008  VMA_SWAP(suballocType1, suballocType2);
        3009  }
        3010 
        3011  switch(suballocType1)
        3012  {
        3013  case VMA_SUBALLOCATION_TYPE_FREE:
        3014  return false;
        3015  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        3016  return true;
        3017  case VMA_SUBALLOCATION_TYPE_BUFFER:
        3018  return
        3019  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        3020  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        3021  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        3022  return
        3023  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        3024  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
        3025  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        3026  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        3027  return
        3028  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        3029  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        3030  return false;
        3031  default:
        3032  VMA_ASSERT(0);
        3033  return true;
        3034  }
        3035 }
        3036 
        3037 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
        3038 {
        3039  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
        3040  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        3041  for(size_t i = 0; i < numberCount; ++i, ++pDst)
        3042  {
        3043  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
        3044  }
        3045 }
        3046 
        3047 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
        3048 {
        3049  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
        3050  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        3051  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
        3052  {
        3053  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
        3054  {
        3055  return false;
        3056  }
        3057  }
        3058  return true;
        3059 }
        3060 
        3061 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
        3062 struct VmaMutexLock
        3063 {
        3064  VMA_CLASS_NO_COPY(VmaMutexLock)
        3065 public:
        3066  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
        3067  m_pMutex(useMutex ? &mutex : VMA_NULL)
        3068  {
        3069  if(m_pMutex)
        3070  {
        3071  m_pMutex->Lock();
        3072  }
        3073  }
        3074 
        3075  ~VmaMutexLock()
        3076  {
        3077  if(m_pMutex)
        3078  {
        3079  m_pMutex->Unlock();
        3080  }
        3081  }
        3082 
        3083 private:
        3084  VMA_MUTEX* m_pMutex;
        3085 };
        3086 
        3087 #if VMA_DEBUG_GLOBAL_MUTEX
        3088  static VMA_MUTEX gDebugGlobalMutex;
        3089  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
        3090 #else
        3091  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
        3092 #endif
        3093 
        3094 // Minimum size of a free suballocation to register it in the free suballocation collection.
        3095 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
        3096 
        3097 /*
        3098 Performs binary search and returns iterator to first element that is greater or
        3099 equal to (key), according to comparison (cmp).
        3100 
        3101 Cmp should return true if first argument is less than second argument.
        3102 
        3103 Returned value is the found element, if present in the collection or place where
        3104 new element with value (key) should be inserted.
        3105 */
        3106 template <typename CmpLess, typename IterT, typename KeyT>
        3107 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpLess cmp)
        3108 {
        3109  size_t down = 0, up = (end - beg);
        3110  while(down < up)
        3111  {
        3112  const size_t mid = (down + up) / 2;
        3113  if(cmp(*(beg+mid), key))
        3114  {
        3115  down = mid + 1;
        3116  }
        3117  else
        3118  {
        3119  up = mid;
        3120  }
        3121  }
        3122  return beg + down;
        3123 }
        3124 
        3126 // Memory allocation
        3127 
        3128 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
        3129 {
        3130  if((pAllocationCallbacks != VMA_NULL) &&
        3131  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
        3132  {
        3133  return (*pAllocationCallbacks->pfnAllocation)(
        3134  pAllocationCallbacks->pUserData,
        3135  size,
        3136  alignment,
        3137  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        3138  }
        3139  else
        3140  {
        3141  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
        3142  }
        3143 }
        3144 
        3145 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
        3146 {
        3147  if((pAllocationCallbacks != VMA_NULL) &&
        3148  (pAllocationCallbacks->pfnFree != VMA_NULL))
        3149  {
        3150  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
        3151  }
        3152  else
        3153  {
        3154  VMA_SYSTEM_FREE(ptr);
        3155  }
        3156 }
        3157 
        3158 template<typename T>
        3159 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
        3160 {
        3161  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
        3162 }
        3163 
        3164 template<typename T>
        3165 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
        3166 {
        3167  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
        3168 }
        3169 
        3170 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
        3171 
        3172 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
        3173 
        3174 template<typename T>
        3175 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
        3176 {
        3177  ptr->~T();
        3178  VmaFree(pAllocationCallbacks, ptr);
        3179 }
        3180 
        3181 template<typename T>
        3182 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
        3183 {
        3184  if(ptr != VMA_NULL)
        3185  {
        3186  for(size_t i = count; i--; )
        3187  {
        3188  ptr[i].~T();
        3189  }
        3190  VmaFree(pAllocationCallbacks, ptr);
        3191  }
        3192 }
        3193 
        3194 // STL-compatible allocator.
        3195 template<typename T>
        3196 class VmaStlAllocator
        3197 {
        3198 public:
        3199  const VkAllocationCallbacks* const m_pCallbacks;
        3200  typedef T value_type;
        3201 
        3202  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
        3203  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
        3204 
        3205  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
        3206  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
        3207 
        3208  template<typename U>
        3209  bool operator==(const VmaStlAllocator<U>& rhs) const
        3210  {
        3211  return m_pCallbacks == rhs.m_pCallbacks;
        3212  }
        3213  template<typename U>
        3214  bool operator!=(const VmaStlAllocator<U>& rhs) const
        3215  {
        3216  return m_pCallbacks != rhs.m_pCallbacks;
        3217  }
        3218 
        3219  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
        3220 };
        3221 
        3222 #if VMA_USE_STL_VECTOR
        3223 
        3224 #define VmaVector std::vector
        3225 
        3226 template<typename T, typename allocatorT>
        3227 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
        3228 {
        3229  vec.insert(vec.begin() + index, item);
        3230 }
        3231 
        3232 template<typename T, typename allocatorT>
        3233 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
        3234 {
        3235  vec.erase(vec.begin() + index);
        3236 }
        3237 
        3238 #else // #if VMA_USE_STL_VECTOR
        3239 
        3240 /* Class with interface compatible with subset of std::vector.
        3241 T must be POD because constructors and destructors are not called and memcpy is
        3242 used for these objects. */
        3243 template<typename T, typename AllocatorT>
        3244 class VmaVector
        3245 {
        3246 public:
        3247  typedef T value_type;
        3248 
        3249  VmaVector(const AllocatorT& allocator) :
        3250  m_Allocator(allocator),
        3251  m_pArray(VMA_NULL),
        3252  m_Count(0),
        3253  m_Capacity(0)
        3254  {
        3255  }
        3256 
        3257  VmaVector(size_t count, const AllocatorT& allocator) :
        3258  m_Allocator(allocator),
        3259  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
        3260  m_Count(count),
        3261  m_Capacity(count)
        3262  {
        3263  }
        3264 
        3265  VmaVector(const VmaVector<T, AllocatorT>& src) :
        3266  m_Allocator(src.m_Allocator),
        3267  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
        3268  m_Count(src.m_Count),
        3269  m_Capacity(src.m_Count)
        3270  {
        3271  if(m_Count != 0)
        3272  {
        3273  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
        3274  }
        3275  }
        3276 
        3277  ~VmaVector()
        3278  {
        3279  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        3280  }
        3281 
        3282  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
        3283  {
        3284  if(&rhs != this)
        3285  {
        3286  resize(rhs.m_Count);
        3287  if(m_Count != 0)
        3288  {
        3289  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        3290  }
        3291  }
        3292  return *this;
        3293  }
        3294 
        3295  bool empty() const { return m_Count == 0; }
        3296  size_t size() const { return m_Count; }
        3297  T* data() { return m_pArray; }
        3298  const T* data() const { return m_pArray; }
        3299 
        3300  T& operator[](size_t index)
        3301  {
        3302  VMA_HEAVY_ASSERT(index < m_Count);
        3303  return m_pArray[index];
        3304  }
        3305  const T& operator[](size_t index) const
        3306  {
        3307  VMA_HEAVY_ASSERT(index < m_Count);
        3308  return m_pArray[index];
        3309  }
        3310 
        3311  T& front()
        3312  {
        3313  VMA_HEAVY_ASSERT(m_Count > 0);
        3314  return m_pArray[0];
        3315  }
        3316  const T& front() const
        3317  {
        3318  VMA_HEAVY_ASSERT(m_Count > 0);
        3319  return m_pArray[0];
        3320  }
        3321  T& back()
        3322  {
        3323  VMA_HEAVY_ASSERT(m_Count > 0);
        3324  return m_pArray[m_Count - 1];
        3325  }
        3326  const T& back() const
        3327  {
        3328  VMA_HEAVY_ASSERT(m_Count > 0);
        3329  return m_pArray[m_Count - 1];
        3330  }
        3331 
        3332  void reserve(size_t newCapacity, bool freeMemory = false)
        3333  {
        3334  newCapacity = VMA_MAX(newCapacity, m_Count);
        3335 
        3336  if((newCapacity < m_Capacity) && !freeMemory)
        3337  {
        3338  newCapacity = m_Capacity;
        3339  }
        3340 
        3341  if(newCapacity != m_Capacity)
        3342  {
        3343  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        3344  if(m_Count != 0)
        3345  {
        3346  memcpy(newArray, m_pArray, m_Count * sizeof(T));
        3347  }
        3348  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        3349  m_Capacity = newCapacity;
        3350  m_pArray = newArray;
        3351  }
        3352  }
        3353 
        3354  void resize(size_t newCount, bool freeMemory = false)
        3355  {
        3356  size_t newCapacity = m_Capacity;
        3357  if(newCount > m_Capacity)
        3358  {
        3359  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
        3360  }
        3361  else if(freeMemory)
        3362  {
        3363  newCapacity = newCount;
        3364  }
        3365 
        3366  if(newCapacity != m_Capacity)
        3367  {
        3368  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        3369  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        3370  if(elementsToCopy != 0)
        3371  {
        3372  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        3373  }
        3374  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        3375  m_Capacity = newCapacity;
        3376  m_pArray = newArray;
        3377  }
        3378 
        3379  m_Count = newCount;
        3380  }
        3381 
        3382  void clear(bool freeMemory = false)
        3383  {
        3384  resize(0, freeMemory);
        3385  }
        3386 
        3387  void insert(size_t index, const T& src)
        3388  {
        3389  VMA_HEAVY_ASSERT(index <= m_Count);
        3390  const size_t oldCount = size();
        3391  resize(oldCount + 1);
        3392  if(index < oldCount)
        3393  {
        3394  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
        3395  }
        3396  m_pArray[index] = src;
        3397  }
        3398 
        3399  void remove(size_t index)
        3400  {
        3401  VMA_HEAVY_ASSERT(index < m_Count);
        3402  const size_t oldCount = size();
        3403  if(index < oldCount - 1)
        3404  {
        3405  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
        3406  }
        3407  resize(oldCount - 1);
        3408  }
        3409 
        3410  void push_back(const T& src)
        3411  {
        3412  const size_t newIndex = size();
        3413  resize(newIndex + 1);
        3414  m_pArray[newIndex] = src;
        3415  }
        3416 
        3417  void pop_back()
        3418  {
        3419  VMA_HEAVY_ASSERT(m_Count > 0);
        3420  resize(size() - 1);
        3421  }
        3422 
        3423  void push_front(const T& src)
        3424  {
        3425  insert(0, src);
        3426  }
        3427 
        3428  void pop_front()
        3429  {
        3430  VMA_HEAVY_ASSERT(m_Count > 0);
        3431  remove(0);
        3432  }
        3433 
        3434  typedef T* iterator;
        3435 
        3436  iterator begin() { return m_pArray; }
        3437  iterator end() { return m_pArray + m_Count; }
        3438 
        3439 private:
        3440  AllocatorT m_Allocator;
        3441  T* m_pArray;
        3442  size_t m_Count;
        3443  size_t m_Capacity;
        3444 };
        3445 
        3446 template<typename T, typename allocatorT>
        3447 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
        3448 {
        3449  vec.insert(index, item);
        3450 }
        3451 
        3452 template<typename T, typename allocatorT>
        3453 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
        3454 {
        3455  vec.remove(index);
        3456 }
        3457 
        3458 #endif // #if VMA_USE_STL_VECTOR
        3459 
        3460 template<typename CmpLess, typename VectorT>
        3461 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
        3462 {
        3463  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        3464  vector.data(),
        3465  vector.data() + vector.size(),
        3466  value,
        3467  CmpLess()) - vector.data();
        3468  VmaVectorInsert(vector, indexToInsert, value);
        3469  return indexToInsert;
        3470 }
        3471 
        3472 template<typename CmpLess, typename VectorT>
        3473 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
        3474 {
        3475  CmpLess comparator;
        3476  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        3477  vector.begin(),
        3478  vector.end(),
        3479  value,
        3480  comparator);
        3481  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        3482  {
        3483  size_t indexToRemove = it - vector.begin();
        3484  VmaVectorRemove(vector, indexToRemove);
        3485  return true;
        3486  }
        3487  return false;
        3488 }
        3489 
        3490 template<typename CmpLess, typename IterT, typename KeyT>
        3491 IterT VmaVectorFindSorted(const IterT& beg, const IterT& end, const KeyT& value)
        3492 {
        3493  CmpLess comparator;
        3494  typename IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
        3495  beg, end, value, comparator);
        3496  if(it == end ||
        3497  !comparator(*it, value) && !comparator(value, *it))
        3498  {
        3499  return it;
        3500  }
        3501  return end;
        3502 }
        3503 
        3505 // class VmaPoolAllocator
        3506 
        3507 /*
        3508 Allocator for objects of type T using a list of arrays (pools) to speed up
        3509 allocation. Number of elements that can be allocated is not bounded because
        3510 allocator can create multiple blocks.
        3511 */
        3512 template<typename T>
        3513 class VmaPoolAllocator
        3514 {
        3515  VMA_CLASS_NO_COPY(VmaPoolAllocator)
        3516 public:
        3517  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
        3518  ~VmaPoolAllocator();
        3519  void Clear();
        3520  T* Alloc();
        3521  void Free(T* ptr);
        3522 
        3523 private:
        3524  union Item
        3525  {
        3526  uint32_t NextFreeIndex;
        3527  T Value;
        3528  };
        3529 
        3530  struct ItemBlock
        3531  {
        3532  Item* pItems;
        3533  uint32_t FirstFreeIndex;
        3534  };
        3535 
        3536  const VkAllocationCallbacks* m_pAllocationCallbacks;
        3537  size_t m_ItemsPerBlock;
        3538  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
        3539 
        3540  ItemBlock& CreateNewBlock();
        3541 };
        3542 
        3543 template<typename T>
        3544 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
        3545  m_pAllocationCallbacks(pAllocationCallbacks),
        3546  m_ItemsPerBlock(itemsPerBlock),
        3547  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
        3548 {
        3549  VMA_ASSERT(itemsPerBlock > 0);
        3550 }
        3551 
        3552 template<typename T>
        3553 VmaPoolAllocator<T>::~VmaPoolAllocator()
        3554 {
        3555  Clear();
        3556 }
        3557 
        3558 template<typename T>
        3559 void VmaPoolAllocator<T>::Clear()
        3560 {
        3561  for(size_t i = m_ItemBlocks.size(); i--; )
        3562  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
        3563  m_ItemBlocks.clear();
        3564 }
        3565 
        3566 template<typename T>
        3567 T* VmaPoolAllocator<T>::Alloc()
        3568 {
        3569  for(size_t i = m_ItemBlocks.size(); i--; )
        3570  {
        3571  ItemBlock& block = m_ItemBlocks[i];
        3572  // This block has some free items: Use first one.
        3573  if(block.FirstFreeIndex != UINT32_MAX)
        3574  {
        3575  Item* const pItem = &block.pItems[block.FirstFreeIndex];
        3576  block.FirstFreeIndex = pItem->NextFreeIndex;
        3577  return &pItem->Value;
        3578  }
        3579  }
        3580 
        3581  // No block has free item: Create new one and use it.
        3582  ItemBlock& newBlock = CreateNewBlock();
        3583  Item* const pItem = &newBlock.pItems[0];
        3584  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
        3585  return &pItem->Value;
        3586 }
        3587 
        3588 template<typename T>
        3589 void VmaPoolAllocator<T>::Free(T* ptr)
        3590 {
        3591  // Search all memory blocks to find ptr.
        3592  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
        3593  {
        3594  ItemBlock& block = m_ItemBlocks[i];
        3595 
        3596  // Casting to union.
        3597  Item* pItemPtr;
        3598  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
        3599 
        3600  // Check if pItemPtr is in address range of this block.
        3601  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
        3602  {
        3603  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
        3604  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
        3605  block.FirstFreeIndex = index;
        3606  return;
        3607  }
        3608  }
        3609  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
        3610 }
        3611 
        3612 template<typename T>
        3613 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
        3614 {
        3615  ItemBlock newBlock = {
        3616  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
        3617 
        3618  m_ItemBlocks.push_back(newBlock);
        3619 
        3620  // Setup singly-linked list of all free items in this block.
        3621  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
        3622  newBlock.pItems[i].NextFreeIndex = i + 1;
        3623  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
        3624  return m_ItemBlocks.back();
        3625 }
        3626 
        3628 // class VmaRawList, VmaList
        3629 
        3630 #if VMA_USE_STL_LIST
        3631 
        3632 #define VmaList std::list
        3633 
        3634 #else // #if VMA_USE_STL_LIST
        3635 
        3636 template<typename T>
        3637 struct VmaListItem
        3638 {
        3639  VmaListItem* pPrev;
        3640  VmaListItem* pNext;
        3641  T Value;
        3642 };
        3643 
        3644 // Doubly linked list.
        3645 template<typename T>
        3646 class VmaRawList
        3647 {
        3648  VMA_CLASS_NO_COPY(VmaRawList)
        3649 public:
        3650  typedef VmaListItem<T> ItemType;
        3651 
        3652  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
        3653  ~VmaRawList();
        3654  void Clear();
        3655 
        3656  size_t GetCount() const { return m_Count; }
        3657  bool IsEmpty() const { return m_Count == 0; }
        3658 
        3659  ItemType* Front() { return m_pFront; }
        3660  const ItemType* Front() const { return m_pFront; }
        3661  ItemType* Back() { return m_pBack; }
        3662  const ItemType* Back() const { return m_pBack; }
        3663 
        3664  ItemType* PushBack();
        3665  ItemType* PushFront();
        3666  ItemType* PushBack(const T& value);
        3667  ItemType* PushFront(const T& value);
        3668  void PopBack();
        3669  void PopFront();
        3670 
        3671  // Item can be null - it means PushBack.
        3672  ItemType* InsertBefore(ItemType* pItem);
        3673  // Item can be null - it means PushFront.
        3674  ItemType* InsertAfter(ItemType* pItem);
        3675 
        3676  ItemType* InsertBefore(ItemType* pItem, const T& value);
        3677  ItemType* InsertAfter(ItemType* pItem, const T& value);
        3678 
        3679  void Remove(ItemType* pItem);
        3680 
        3681 private:
        3682  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        3683  VmaPoolAllocator<ItemType> m_ItemAllocator;
        3684  ItemType* m_pFront;
        3685  ItemType* m_pBack;
        3686  size_t m_Count;
        3687 };
        3688 
        3689 template<typename T>
        3690 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
        3691  m_pAllocationCallbacks(pAllocationCallbacks),
        3692  m_ItemAllocator(pAllocationCallbacks, 128),
        3693  m_pFront(VMA_NULL),
        3694  m_pBack(VMA_NULL),
        3695  m_Count(0)
        3696 {
        3697 }
        3698 
        3699 template<typename T>
        3700 VmaRawList<T>::~VmaRawList()
        3701 {
        3702  // Intentionally not calling Clear, because that would be unnecessary
        3703  // computations to return all items to m_ItemAllocator as free.
        3704 }
        3705 
        3706 template<typename T>
        3707 void VmaRawList<T>::Clear()
        3708 {
        3709  if(IsEmpty() == false)
        3710  {
        3711  ItemType* pItem = m_pBack;
        3712  while(pItem != VMA_NULL)
        3713  {
        3714  ItemType* const pPrevItem = pItem->pPrev;
        3715  m_ItemAllocator.Free(pItem);
        3716  pItem = pPrevItem;
        3717  }
        3718  m_pFront = VMA_NULL;
        3719  m_pBack = VMA_NULL;
        3720  m_Count = 0;
        3721  }
        3722 }
        3723 
        3724 template<typename T>
        3725 VmaListItem<T>* VmaRawList<T>::PushBack()
        3726 {
        3727  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        3728  pNewItem->pNext = VMA_NULL;
        3729  if(IsEmpty())
        3730  {
        3731  pNewItem->pPrev = VMA_NULL;
        3732  m_pFront = pNewItem;
        3733  m_pBack = pNewItem;
        3734  m_Count = 1;
        3735  }
        3736  else
        3737  {
        3738  pNewItem->pPrev = m_pBack;
        3739  m_pBack->pNext = pNewItem;
        3740  m_pBack = pNewItem;
        3741  ++m_Count;
        3742  }
        3743  return pNewItem;
        3744 }
        3745 
        3746 template<typename T>
        3747 VmaListItem<T>* VmaRawList<T>::PushFront()
        3748 {
        3749  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        3750  pNewItem->pPrev = VMA_NULL;
        3751  if(IsEmpty())
        3752  {
        3753  pNewItem->pNext = VMA_NULL;
        3754  m_pFront = pNewItem;
        3755  m_pBack = pNewItem;
        3756  m_Count = 1;
        3757  }
        3758  else
        3759  {
        3760  pNewItem->pNext = m_pFront;
        3761  m_pFront->pPrev = pNewItem;
        3762  m_pFront = pNewItem;
        3763  ++m_Count;
        3764  }
        3765  return pNewItem;
        3766 }
        3767 
        3768 template<typename T>
        3769 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
        3770 {
        3771  ItemType* const pNewItem = PushBack();
        3772  pNewItem->Value = value;
        3773  return pNewItem;
        3774 }
        3775 
        3776 template<typename T>
        3777 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
        3778 {
        3779  ItemType* const pNewItem = PushFront();
        3780  pNewItem->Value = value;
        3781  return pNewItem;
        3782 }
        3783 
        3784 template<typename T>
        3785 void VmaRawList<T>::PopBack()
        3786 {
        3787  VMA_HEAVY_ASSERT(m_Count > 0);
        3788  ItemType* const pBackItem = m_pBack;
        3789  ItemType* const pPrevItem = pBackItem->pPrev;
        3790  if(pPrevItem != VMA_NULL)
        3791  {
        3792  pPrevItem->pNext = VMA_NULL;
        3793  }
        3794  m_pBack = pPrevItem;
        3795  m_ItemAllocator.Free(pBackItem);
        3796  --m_Count;
        3797 }
        3798 
        3799 template<typename T>
        3800 void VmaRawList<T>::PopFront()
        3801 {
        3802  VMA_HEAVY_ASSERT(m_Count > 0);
        3803  ItemType* const pFrontItem = m_pFront;
        3804  ItemType* const pNextItem = pFrontItem->pNext;
        3805  if(pNextItem != VMA_NULL)
        3806  {
        3807  pNextItem->pPrev = VMA_NULL;
        3808  }
        3809  m_pFront = pNextItem;
        3810  m_ItemAllocator.Free(pFrontItem);
        3811  --m_Count;
        3812 }
        3813 
        3814 template<typename T>
        3815 void VmaRawList<T>::Remove(ItemType* pItem)
        3816 {
        3817  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
        3818  VMA_HEAVY_ASSERT(m_Count > 0);
        3819 
        3820  if(pItem->pPrev != VMA_NULL)
        3821  {
        3822  pItem->pPrev->pNext = pItem->pNext;
        3823  }
        3824  else
        3825  {
        3826  VMA_HEAVY_ASSERT(m_pFront == pItem);
        3827  m_pFront = pItem->pNext;
        3828  }
        3829 
        3830  if(pItem->pNext != VMA_NULL)
        3831  {
        3832  pItem->pNext->pPrev = pItem->pPrev;
        3833  }
        3834  else
        3835  {
        3836  VMA_HEAVY_ASSERT(m_pBack == pItem);
        3837  m_pBack = pItem->pPrev;
        3838  }
        3839 
        3840  m_ItemAllocator.Free(pItem);
        3841  --m_Count;
        3842 }
        3843 
        3844 template<typename T>
        3845 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
        3846 {
        3847  if(pItem != VMA_NULL)
        3848  {
        3849  ItemType* const prevItem = pItem->pPrev;
        3850  ItemType* const newItem = m_ItemAllocator.Alloc();
        3851  newItem->pPrev = prevItem;
        3852  newItem->pNext = pItem;
        3853  pItem->pPrev = newItem;
        3854  if(prevItem != VMA_NULL)
        3855  {
        3856  prevItem->pNext = newItem;
        3857  }
        3858  else
        3859  {
        3860  VMA_HEAVY_ASSERT(m_pFront == pItem);
        3861  m_pFront = newItem;
        3862  }
        3863  ++m_Count;
        3864  return newItem;
        3865  }
        3866  else
        3867  return PushBack();
        3868 }
        3869 
        3870 template<typename T>
        3871 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
        3872 {
        3873  if(pItem != VMA_NULL)
        3874  {
        3875  ItemType* const nextItem = pItem->pNext;
        3876  ItemType* const newItem = m_ItemAllocator.Alloc();
        3877  newItem->pNext = nextItem;
        3878  newItem->pPrev = pItem;
        3879  pItem->pNext = newItem;
        3880  if(nextItem != VMA_NULL)
        3881  {
        3882  nextItem->pPrev = newItem;
        3883  }
        3884  else
        3885  {
        3886  VMA_HEAVY_ASSERT(m_pBack == pItem);
        3887  m_pBack = newItem;
        3888  }
        3889  ++m_Count;
        3890  return newItem;
        3891  }
        3892  else
        3893  return PushFront();
        3894 }
        3895 
        3896 template<typename T>
        3897 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
        3898 {
        3899  ItemType* const newItem = InsertBefore(pItem);
        3900  newItem->Value = value;
        3901  return newItem;
        3902 }
        3903 
        3904 template<typename T>
        3905 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
        3906 {
        3907  ItemType* const newItem = InsertAfter(pItem);
        3908  newItem->Value = value;
        3909  return newItem;
        3910 }
        3911 
        3912 template<typename T, typename AllocatorT>
        3913 class VmaList
        3914 {
        3915  VMA_CLASS_NO_COPY(VmaList)
        3916 public:
        3917  class iterator
        3918  {
        3919  public:
        3920  iterator() :
        3921  m_pList(VMA_NULL),
        3922  m_pItem(VMA_NULL)
        3923  {
        3924  }
        3925 
        3926  T& operator*() const
        3927  {
        3928  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        3929  return m_pItem->Value;
        3930  }
        3931  T* operator->() const
        3932  {
        3933  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        3934  return &m_pItem->Value;
        3935  }
        3936 
        3937  iterator& operator++()
        3938  {
        3939  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        3940  m_pItem = m_pItem->pNext;
        3941  return *this;
        3942  }
        3943  iterator& operator--()
        3944  {
        3945  if(m_pItem != VMA_NULL)
        3946  {
        3947  m_pItem = m_pItem->pPrev;
        3948  }
        3949  else
        3950  {
        3951  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        3952  m_pItem = m_pList->Back();
        3953  }
        3954  return *this;
        3955  }
        3956 
        3957  iterator operator++(int)
        3958  {
        3959  iterator result = *this;
        3960  ++*this;
        3961  return result;
        3962  }
        3963  iterator operator--(int)
        3964  {
        3965  iterator result = *this;
        3966  --*this;
        3967  return result;
        3968  }
        3969 
        3970  bool operator==(const iterator& rhs) const
        3971  {
        3972  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        3973  return m_pItem == rhs.m_pItem;
        3974  }
        3975  bool operator!=(const iterator& rhs) const
        3976  {
        3977  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        3978  return m_pItem != rhs.m_pItem;
        3979  }
        3980 
        3981  private:
        3982  VmaRawList<T>* m_pList;
        3983  VmaListItem<T>* m_pItem;
        3984 
        3985  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
        3986  m_pList(pList),
        3987  m_pItem(pItem)
        3988  {
        3989  }
        3990 
        3991  friend class VmaList<T, AllocatorT>;
        3992  };
        3993 
        3994  class const_iterator
        3995  {
        3996  public:
        3997  const_iterator() :
        3998  m_pList(VMA_NULL),
        3999  m_pItem(VMA_NULL)
        4000  {
        4001  }
        4002 
        4003  const_iterator(const iterator& src) :
        4004  m_pList(src.m_pList),
        4005  m_pItem(src.m_pItem)
        4006  {
        4007  }
        4008 
        4009  const T& operator*() const
        4010  {
        4011  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        4012  return m_pItem->Value;
        4013  }
        4014  const T* operator->() const
        4015  {
        4016  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        4017  return &m_pItem->Value;
        4018  }
        4019 
        4020  const_iterator& operator++()
        4021  {
        4022  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        4023  m_pItem = m_pItem->pNext;
        4024  return *this;
        4025  }
        4026  const_iterator& operator--()
        4027  {
        4028  if(m_pItem != VMA_NULL)
        4029  {
        4030  m_pItem = m_pItem->pPrev;
        4031  }
        4032  else
        4033  {
        4034  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        4035  m_pItem = m_pList->Back();
        4036  }
        4037  return *this;
        4038  }
        4039 
        4040  const_iterator operator++(int)
        4041  {
        4042  const_iterator result = *this;
        4043  ++*this;
        4044  return result;
        4045  }
        4046  const_iterator operator--(int)
        4047  {
        4048  const_iterator result = *this;
        4049  --*this;
        4050  return result;
        4051  }
        4052 
        4053  bool operator==(const const_iterator& rhs) const
        4054  {
        4055  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        4056  return m_pItem == rhs.m_pItem;
        4057  }
        4058  bool operator!=(const const_iterator& rhs) const
        4059  {
        4060  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        4061  return m_pItem != rhs.m_pItem;
        4062  }
        4063 
        4064  private:
        4065  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
        4066  m_pList(pList),
        4067  m_pItem(pItem)
        4068  {
        4069  }
        4070 
        4071  const VmaRawList<T>* m_pList;
        4072  const VmaListItem<T>* m_pItem;
        4073 
        4074  friend class VmaList<T, AllocatorT>;
        4075  };
        4076 
        4077  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
        4078 
        4079  bool empty() const { return m_RawList.IsEmpty(); }
        4080  size_t size() const { return m_RawList.GetCount(); }
        4081 
        4082  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
        4083  iterator end() { return iterator(&m_RawList, VMA_NULL); }
        4084 
        4085  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
        4086  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
        4087 
        4088  void clear() { m_RawList.Clear(); }
        4089  void push_back(const T& value) { m_RawList.PushBack(value); }
        4090  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
        4091  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
        4092 
        4093 private:
        4094  VmaRawList<T> m_RawList;
        4095 };
        4096 
        4097 #endif // #if VMA_USE_STL_LIST
        4098 
        4100 // class VmaMap
        4101 
        4102 // Unused in this version.
        4103 #if 0
        4104 
        4105 #if VMA_USE_STL_UNORDERED_MAP
        4106 
        4107 #define VmaPair std::pair
        4108 
        4109 #define VMA_MAP_TYPE(KeyT, ValueT) \
        4110  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
        4111 
        4112 #else // #if VMA_USE_STL_UNORDERED_MAP
        4113 
        4114 template<typename T1, typename T2>
        4115 struct VmaPair
        4116 {
        4117  T1 first;
        4118  T2 second;
        4119 
        4120  VmaPair() : first(), second() { }
        4121  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
        4122 };
        4123 
        4124 /* Class compatible with subset of interface of std::unordered_map.
        4125 KeyT, ValueT must be POD because they will be stored in VmaVector.
        4126 */
        4127 template<typename KeyT, typename ValueT>
        4128 class VmaMap
        4129 {
        4130 public:
        4131  typedef VmaPair<KeyT, ValueT> PairType;
        4132  typedef PairType* iterator;
        4133 
        4134  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
        4135 
        4136  iterator begin() { return m_Vector.begin(); }
        4137  iterator end() { return m_Vector.end(); }
        4138 
        4139  void insert(const PairType& pair);
        4140  iterator find(const KeyT& key);
        4141  void erase(iterator it);
        4142 
        4143 private:
        4144  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
        4145 };
        4146 
        4147 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
        4148 
        4149 template<typename FirstT, typename SecondT>
        4150 struct VmaPairFirstLess
        4151 {
        4152  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
        4153  {
        4154  return lhs.first < rhs.first;
        4155  }
        4156  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
        4157  {
        4158  return lhs.first < rhsFirst;
        4159  }
        4160 };
        4161 
        4162 template<typename KeyT, typename ValueT>
        4163 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
        4164 {
        4165  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        4166  m_Vector.data(),
        4167  m_Vector.data() + m_Vector.size(),
        4168  pair,
        4169  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
        4170  VmaVectorInsert(m_Vector, indexToInsert, pair);
        4171 }
        4172 
        4173 template<typename KeyT, typename ValueT>
        4174 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
        4175 {
        4176  PairType* it = VmaBinaryFindFirstNotLess(
        4177  m_Vector.data(),
        4178  m_Vector.data() + m_Vector.size(),
        4179  key,
        4180  VmaPairFirstLess<KeyT, ValueT>());
        4181  if((it != m_Vector.end()) && (it->first == key))
        4182  {
        4183  return it;
        4184  }
        4185  else
        4186  {
        4187  return m_Vector.end();
        4188  }
        4189 }
        4190 
        4191 template<typename KeyT, typename ValueT>
        4192 void VmaMap<KeyT, ValueT>::erase(iterator it)
        4193 {
        4194  VmaVectorRemove(m_Vector, it - m_Vector.begin());
        4195 }
        4196 
        4197 #endif // #if VMA_USE_STL_UNORDERED_MAP
        4198 
        4199 #endif // #if 0
        4200 
        4202 
        4203 class VmaDeviceMemoryBlock;
        4204 
        4205 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
        4206 
        4207 struct VmaAllocation_T
        4208 {
        4209  VMA_CLASS_NO_COPY(VmaAllocation_T)
        4210 private:
        4211  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
        4212 
        4213  enum FLAGS
        4214  {
        4215  FLAG_USER_DATA_STRING = 0x01,
        4216  };
        4217 
        4218 public:
        4219  enum ALLOCATION_TYPE
        4220  {
        4221  ALLOCATION_TYPE_NONE,
        4222  ALLOCATION_TYPE_BLOCK,
        4223  ALLOCATION_TYPE_DEDICATED,
        4224  };
        4225 
        4226  VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
        4227  m_Alignment(1),
        4228  m_Size(0),
        4229  m_pUserData(VMA_NULL),
        4230  m_LastUseFrameIndex(currentFrameIndex),
        4231  m_Type((uint8_t)ALLOCATION_TYPE_NONE),
        4232  m_SuballocationType((uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN),
        4233  m_MapCount(0),
        4234  m_Flags(userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0)
        4235  {
        4236 #if VMA_STATS_STRING_ENABLED
        4237  m_CreationFrameIndex = currentFrameIndex;
        4238  m_BufferImageUsage = 0;
        4239 #endif
        4240  }
        4241 
        4242  ~VmaAllocation_T()
        4243  {
        4244  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
        4245 
        4246  // Check if owned string was freed.
        4247  VMA_ASSERT(m_pUserData == VMA_NULL);
        4248  }
        4249 
        4250  void InitBlockAllocation(
        4251  VmaPool hPool,
        4252  VmaDeviceMemoryBlock* block,
        4253  VkDeviceSize offset,
        4254  VkDeviceSize alignment,
        4255  VkDeviceSize size,
        4256  VmaSuballocationType suballocationType,
        4257  bool mapped,
        4258  bool canBecomeLost)
        4259  {
        4260  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        4261  VMA_ASSERT(block != VMA_NULL);
        4262  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        4263  m_Alignment = alignment;
        4264  m_Size = size;
        4265  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        4266  m_SuballocationType = (uint8_t)suballocationType;
        4267  m_BlockAllocation.m_hPool = hPool;
        4268  m_BlockAllocation.m_Block = block;
        4269  m_BlockAllocation.m_Offset = offset;
        4270  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
        4271  }
        4272 
        4273  void InitLost()
        4274  {
        4275  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        4276  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
        4277  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        4278  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
        4279  m_BlockAllocation.m_Block = VMA_NULL;
        4280  m_BlockAllocation.m_Offset = 0;
        4281  m_BlockAllocation.m_CanBecomeLost = true;
        4282  }
        4283 
        4284  void ChangeBlockAllocation(
        4285  VmaAllocator hAllocator,
        4286  VmaDeviceMemoryBlock* block,
        4287  VkDeviceSize offset);
        4288 
        4289  // pMappedData not null means allocation is created with MAPPED flag.
        4290  void InitDedicatedAllocation(
        4291  uint32_t memoryTypeIndex,
        4292  VkDeviceMemory hMemory,
        4293  VmaSuballocationType suballocationType,
        4294  void* pMappedData,
        4295  VkDeviceSize size)
        4296  {
        4297  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        4298  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
        4299  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
        4300  m_Alignment = 0;
        4301  m_Size = size;
        4302  m_SuballocationType = (uint8_t)suballocationType;
        4303  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        4304  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
        4305  m_DedicatedAllocation.m_hMemory = hMemory;
        4306  m_DedicatedAllocation.m_pMappedData = pMappedData;
        4307  }
        4308 
        4309  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
        4310  VkDeviceSize GetAlignment() const { return m_Alignment; }
        4311  VkDeviceSize GetSize() const { return m_Size; }
        4312  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
        4313  void* GetUserData() const { return m_pUserData; }
        4314  void SetUserData(VmaAllocator hAllocator, void* pUserData);
        4315  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
        4316 
        4317  VmaDeviceMemoryBlock* GetBlock() const
        4318  {
        4319  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        4320  return m_BlockAllocation.m_Block;
        4321  }
        4322  VkDeviceSize GetOffset() const;
        4323  VkDeviceMemory GetMemory() const;
        4324  uint32_t GetMemoryTypeIndex() const;
        4325  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
        4326  void* GetMappedData() const;
        4327  bool CanBecomeLost() const;
        4328  VmaPool GetPool() const;
        4329 
        4330  uint32_t GetLastUseFrameIndex() const
        4331  {
        4332  return m_LastUseFrameIndex.load();
        4333  }
        4334  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
        4335  {
        4336  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
        4337  }
        4338  /*
        4339  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
        4340  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
        4341  - Else, returns false.
        4342 
        4343  If hAllocation is already lost, assert - you should not call it then.
        4344  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
        4345  */
        4346  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        4347 
        4348  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
        4349  {
        4350  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
        4351  outInfo.blockCount = 1;
        4352  outInfo.allocationCount = 1;
        4353  outInfo.unusedRangeCount = 0;
        4354  outInfo.usedBytes = m_Size;
        4355  outInfo.unusedBytes = 0;
        4356  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
        4357  outInfo.unusedRangeSizeMin = UINT64_MAX;
        4358  outInfo.unusedRangeSizeMax = 0;
        4359  }
        4360 
        4361  void BlockAllocMap();
        4362  void BlockAllocUnmap();
        4363  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
        4364  void DedicatedAllocUnmap(VmaAllocator hAllocator);
        4365 
        4366 #if VMA_STATS_STRING_ENABLED
        4367  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
        4368  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
        4369 
        4370  void InitBufferImageUsage(uint32_t bufferImageUsage)
        4371  {
        4372  VMA_ASSERT(m_BufferImageUsage == 0);
        4373  m_BufferImageUsage = bufferImageUsage;
        4374  }
        4375 
        4376  void PrintParameters(class VmaJsonWriter& json) const;
        4377 #endif
        4378 
        4379 private:
        4380  VkDeviceSize m_Alignment;
        4381  VkDeviceSize m_Size;
        4382  void* m_pUserData;
        4383  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
        4384  uint8_t m_Type; // ALLOCATION_TYPE
        4385  uint8_t m_SuballocationType; // VmaSuballocationType
        4386  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
        4387  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
        4388  uint8_t m_MapCount;
        4389  uint8_t m_Flags; // enum FLAGS
        4390 
        4391  // Allocation out of VmaDeviceMemoryBlock.
        4392  struct BlockAllocation
        4393  {
        4394  VmaPool m_hPool; // Null if belongs to general memory.
        4395  VmaDeviceMemoryBlock* m_Block;
        4396  VkDeviceSize m_Offset;
        4397  bool m_CanBecomeLost;
        4398  };
        4399 
        4400  // Allocation for an object that has its own private VkDeviceMemory.
        4401  struct DedicatedAllocation
        4402  {
        4403  uint32_t m_MemoryTypeIndex;
        4404  VkDeviceMemory m_hMemory;
        4405  void* m_pMappedData; // Not null means memory is mapped.
        4406  };
        4407 
        4408  union
        4409  {
        4410  // Allocation out of VmaDeviceMemoryBlock.
        4411  BlockAllocation m_BlockAllocation;
        4412  // Allocation for an object that has its own private VkDeviceMemory.
        4413  DedicatedAllocation m_DedicatedAllocation;
        4414  };
        4415 
        4416 #if VMA_STATS_STRING_ENABLED
        4417  uint32_t m_CreationFrameIndex;
        4418  uint32_t m_BufferImageUsage; // 0 if unknown.
        4419 #endif
        4420 
        4421  void FreeUserDataString(VmaAllocator hAllocator);
        4422 };
        4423 
        4424 /*
        4425 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
        4426 allocated memory block or free.
        4427 */
        4428 struct VmaSuballocation
        4429 {
        4430  VkDeviceSize offset;
        4431  VkDeviceSize size;
        4432  VmaAllocation hAllocation;
        4433  VmaSuballocationType type;
        4434 };
        4435 
        4436 // Comparator for offsets.
        4437 struct VmaSuballocationOffsetLess
        4438 {
        4439  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        4440  {
        4441  return lhs.offset < rhs.offset;
        4442  }
        4443 };
        4444 struct VmaSuballocationOffsetGreater
        4445 {
        4446  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        4447  {
        4448  return lhs.offset > rhs.offset;
        4449  }
        4450 };
        4451 
        4452 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
        4453 
        4454 // Cost of one additional allocation lost, as equivalent in bytes.
        4455 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
        4456 
        4457 /*
        4458 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
        4459 
        4460 If canMakeOtherLost was false:
        4461 - item points to a FREE suballocation.
        4462 - itemsToMakeLostCount is 0.
        4463 
        4464 If canMakeOtherLost was true:
        4465 - item points to first of sequence of suballocations, which are either FREE,
        4466  or point to VmaAllocations that can become lost.
        4467 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
        4468  the requested allocation to succeed.
        4469 */
        4470 struct VmaAllocationRequest
        4471 {
        4472  VkDeviceSize offset;
        4473  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
        4474  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
        4475  VmaSuballocationList::iterator item;
        4476  size_t itemsToMakeLostCount;
        4477 
        4478  VkDeviceSize CalcCost() const
        4479  {
        4480  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
        4481  }
        4482 };
        4483 
        4484 /*
        4485 Data structure used for bookkeeping of allocations and unused ranges of memory
        4486 in a single VkDeviceMemory block.
        4487 */
        4488 class VmaBlockMetadata
        4489 {
        4490 public:
        4491  VmaBlockMetadata() : m_Size(0) { }
        4492  virtual ~VmaBlockMetadata() { }
        4493  virtual void Init(VkDeviceSize size) { m_Size = size; }
        4494 
        4495  // Validates all data structures inside this object. If not valid, returns false.
        4496  virtual bool Validate() const = 0;
        4497  VkDeviceSize GetSize() const { return m_Size; }
        4498  virtual size_t GetAllocationCount() const = 0;
        4499  virtual VkDeviceSize GetSumFreeSize() const = 0;
        4500  virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
        4501  // Returns true if this block is empty - contains only single free suballocation.
        4502  virtual bool IsEmpty() const = 0;
        4503 
        4504  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
        4505  virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
        4506 
        4507 #if VMA_STATS_STRING_ENABLED
        4508  virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
        4509 #endif
        4510 
        4511  // Tries to find a place for suballocation with given parameters inside this block.
        4512  // If succeeded, fills pAllocationRequest and returns true.
        4513  // If failed, returns false.
        4514  virtual bool CreateAllocationRequest(
        4515  uint32_t currentFrameIndex,
        4516  uint32_t frameInUseCount,
        4517  VkDeviceSize bufferImageGranularity,
        4518  VkDeviceSize allocSize,
        4519  VkDeviceSize allocAlignment,
        4520  bool upperAddress,
        4521  VmaSuballocationType allocType,
        4522  bool canMakeOtherLost,
        4523  VmaAllocationRequest* pAllocationRequest) = 0;
        4524 
        4525  virtual bool MakeRequestedAllocationsLost(
        4526  uint32_t currentFrameIndex,
        4527  uint32_t frameInUseCount,
        4528  VmaAllocationRequest* pAllocationRequest) = 0;
        4529 
        4530  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
        4531 
        4532  virtual VkResult CheckCorruption(const void* pBlockData) = 0;
        4533 
        4534  // Makes actual allocation based on request. Request must already be checked and valid.
        4535  virtual void Alloc(
        4536  const VmaAllocationRequest& request,
        4537  VmaSuballocationType type,
        4538  VkDeviceSize allocSize,
        4539  bool upperAddress,
        4540  VmaAllocation hAllocation) = 0;
        4541 
        4542  // Frees suballocation assigned to given memory region.
        4543  virtual void Free(const VmaAllocation allocation) = 0;
        4544  virtual void FreeAtOffset(VkDeviceSize offset) = 0;
        4545 
        4546 protected:
        4547 #if VMA_STATS_STRING_ENABLED
        4548  void PrintDetailedMap_Begin(class VmaJsonWriter& json,
        4549  VkDeviceSize unusedBytes,
        4550  size_t allocationCount,
        4551  size_t unusedRangeCount) const;
        4552  void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        4553  VkDeviceSize offset,
        4554  VmaAllocation hAllocation) const;
        4555  void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        4556  VkDeviceSize offset,
        4557  VkDeviceSize size) const;
        4558  void PrintDetailedMap_End(class VmaJsonWriter& json) const;
        4559 #endif
        4560 
        4561 private:
        4562  VkDeviceSize m_Size;
        4563 };
        4564 
        4565 class VmaBlockMetadata_Generic : public VmaBlockMetadata
        4566 {
        4567  VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
        4568 public:
        4569  VmaBlockMetadata_Generic(VmaAllocator hAllocator);
        4570  virtual ~VmaBlockMetadata_Generic();
        4571  virtual void Init(VkDeviceSize size);
        4572 
        4573  virtual bool Validate() const;
        4574  virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
        4575  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        4576  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        4577  virtual bool IsEmpty() const;
        4578 
        4579  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        4580  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        4581 
        4582 #if VMA_STATS_STRING_ENABLED
        4583  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        4584 #endif
        4585 
        4586  virtual bool CreateAllocationRequest(
        4587  uint32_t currentFrameIndex,
        4588  uint32_t frameInUseCount,
        4589  VkDeviceSize bufferImageGranularity,
        4590  VkDeviceSize allocSize,
        4591  VkDeviceSize allocAlignment,
        4592  bool upperAddress,
        4593  VmaSuballocationType allocType,
        4594  bool canMakeOtherLost,
        4595  VmaAllocationRequest* pAllocationRequest);
        4596 
        4597  virtual bool MakeRequestedAllocationsLost(
        4598  uint32_t currentFrameIndex,
        4599  uint32_t frameInUseCount,
        4600  VmaAllocationRequest* pAllocationRequest);
        4601 
        4602  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        4603 
        4604  virtual VkResult CheckCorruption(const void* pBlockData);
        4605 
        4606  virtual void Alloc(
        4607  const VmaAllocationRequest& request,
        4608  VmaSuballocationType type,
        4609  VkDeviceSize allocSize,
        4610  bool upperAddress,
        4611  VmaAllocation hAllocation);
        4612 
        4613  virtual void Free(const VmaAllocation allocation);
        4614  virtual void FreeAtOffset(VkDeviceSize offset);
        4615 
        4616 private:
        4617  uint32_t m_FreeCount;
        4618  VkDeviceSize m_SumFreeSize;
        4619  VmaSuballocationList m_Suballocations;
        4620  // Suballocations that are free and have size greater than certain threshold.
        4621  // Sorted by size, ascending.
        4622  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
        4623 
        4624  bool ValidateFreeSuballocationList() const;
        4625 
        4626  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
        4627  // If yes, fills pOffset and returns true. If no, returns false.
        4628  bool CheckAllocation(
        4629  uint32_t currentFrameIndex,
        4630  uint32_t frameInUseCount,
        4631  VkDeviceSize bufferImageGranularity,
        4632  VkDeviceSize allocSize,
        4633  VkDeviceSize allocAlignment,
        4634  VmaSuballocationType allocType,
        4635  VmaSuballocationList::const_iterator suballocItem,
        4636  bool canMakeOtherLost,
        4637  VkDeviceSize* pOffset,
        4638  size_t* itemsToMakeLostCount,
        4639  VkDeviceSize* pSumFreeSize,
        4640  VkDeviceSize* pSumItemSize) const;
        4641  // Given free suballocation, it merges it with following one, which must also be free.
        4642  void MergeFreeWithNext(VmaSuballocationList::iterator item);
        4643  // Releases given suballocation, making it free.
        4644  // Merges it with adjacent free suballocations if applicable.
        4645  // Returns iterator to new free suballocation at this place.
        4646  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
        4647  // Given free suballocation, it inserts it into sorted list of
        4648  // m_FreeSuballocationsBySize if it's suitable.
        4649  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
        4650  // Given free suballocation, it removes it from sorted list of
        4651  // m_FreeSuballocationsBySize if it's suitable.
        4652  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
        4653 };
        4654 
        4655 /*
        4656 Allocations and their references in internal data structure look like this:
        4657 
        4658 if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
        4659 
        4660  0 +-------+
        4661  | |
        4662  | |
        4663  | |
        4664  +-------+
        4665  | Alloc | 1st[m_1stNullItemsBeginCount]
        4666  +-------+
        4667  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        4668  +-------+
        4669  | ... |
        4670  +-------+
        4671  | Alloc | 1st[1st.size() - 1]
        4672  +-------+
        4673  | |
        4674  | |
        4675  | |
        4676 GetSize() +-------+
        4677 
        4678 if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
        4679 
        4680  0 +-------+
        4681  | Alloc | 2nd[0]
        4682  +-------+
        4683  | Alloc | 2nd[1]
        4684  +-------+
        4685  | ... |
        4686  +-------+
        4687  | Alloc | 2nd[2nd.size() - 1]
        4688  +-------+
        4689  | |
        4690  | |
        4691  | |
        4692  +-------+
        4693  | Alloc | 1st[m_1stNullItemsBeginCount]
        4694  +-------+
        4695  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        4696  +-------+
        4697  | ... |
        4698  +-------+
        4699  | Alloc | 1st[1st.size() - 1]
        4700  +-------+
        4701  | |
        4702 GetSize() +-------+
        4703 
        4704 if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
        4705 
        4706  0 +-------+
        4707  | |
        4708  | |
        4709  | |
        4710  +-------+
        4711  | Alloc | 1st[m_1stNullItemsBeginCount]
        4712  +-------+
        4713  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        4714  +-------+
        4715  | ... |
        4716  +-------+
        4717  | Alloc | 1st[1st.size() - 1]
        4718  +-------+
        4719  | |
        4720  | |
        4721  | |
        4722  +-------+
        4723  | Alloc | 2nd[2nd.size() - 1]
        4724  +-------+
        4725  | ... |
        4726  +-------+
        4727  | Alloc | 2nd[1]
        4728  +-------+
        4729  | Alloc | 2nd[0]
        4730 GetSize() +-------+
        4731 
        4732 */
        4733 class VmaBlockMetadata_Linear : public VmaBlockMetadata
        4734 {
        4735  VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
        4736 public:
        4737  VmaBlockMetadata_Linear(VmaAllocator hAllocator);
        4738  virtual ~VmaBlockMetadata_Linear();
        4739  virtual void Init(VkDeviceSize size);
        4740 
        4741  virtual bool Validate() const;
        4742  virtual size_t GetAllocationCount() const;
        4743  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        4744  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        4745  virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
        4746 
        4747  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        4748  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        4749 
        4750 #if VMA_STATS_STRING_ENABLED
        4751  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        4752 #endif
        4753 
        4754  virtual bool CreateAllocationRequest(
        4755  uint32_t currentFrameIndex,
        4756  uint32_t frameInUseCount,
        4757  VkDeviceSize bufferImageGranularity,
        4758  VkDeviceSize allocSize,
        4759  VkDeviceSize allocAlignment,
        4760  bool upperAddress,
        4761  VmaSuballocationType allocType,
        4762  bool canMakeOtherLost,
        4763  VmaAllocationRequest* pAllocationRequest);
        4764 
        4765  virtual bool MakeRequestedAllocationsLost(
        4766  uint32_t currentFrameIndex,
        4767  uint32_t frameInUseCount,
        4768  VmaAllocationRequest* pAllocationRequest);
        4769 
        4770  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        4771 
        4772  virtual VkResult CheckCorruption(const void* pBlockData);
        4773 
        4774  virtual void Alloc(
        4775  const VmaAllocationRequest& request,
        4776  VmaSuballocationType type,
        4777  VkDeviceSize allocSize,
        4778  bool upperAddress,
        4779  VmaAllocation hAllocation);
        4780 
        4781  virtual void Free(const VmaAllocation allocation);
        4782  virtual void FreeAtOffset(VkDeviceSize offset);
        4783 
        4784 private:
        4785  /*
        4786  There are two suballocation vectors, used in ping-pong way.
        4787  The one with index m_1stVectorIndex is called 1st.
        4788  The one with index (m_1stVectorIndex ^ 1) is called 2nd.
        4789  2nd can be non-empty only when 1st is not empty.
        4790  When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
        4791  */
        4792  typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
        4793 
        4794  enum SECOND_VECTOR_MODE
        4795  {
        4796  SECOND_VECTOR_EMPTY,
        4797  /*
        4798  Suballocations in 2nd vector are created later than the ones in 1st, but they
        4799  all have smaller offset.
        4800  */
        4801  SECOND_VECTOR_RING_BUFFER,
        4802  /*
        4803  Suballocations in 2nd vector are upper side of double stack.
        4804  They all have offsets higher than those in 1st vector.
        4805  Top of this stack means smaller offsets, but higher indices in this vector.
        4806  */
        4807  SECOND_VECTOR_DOUBLE_STACK,
        4808  };
        4809 
        4810  VkDeviceSize m_SumFreeSize;
        4811  SuballocationVectorType m_Suballocations0, m_Suballocations1;
        4812  uint32_t m_1stVectorIndex;
        4813  SECOND_VECTOR_MODE m_2ndVectorMode;
        4814 
        4815  SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        4816  SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        4817  const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        4818  const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        4819 
        4820  // Number of items in 1st vector with hAllocation = null at the beginning.
        4821  size_t m_1stNullItemsBeginCount;
        4822  // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
        4823  size_t m_1stNullItemsMiddleCount;
        4824  // Number of items in 2nd vector with hAllocation = null.
        4825  size_t m_2ndNullItemsCount;
        4826 
        4827  bool ShouldCompact1st() const;
        4828  void CleanupAfterFree();
        4829 };
        4830 
        4831 /*
        4832 Represents a single block of device memory (`VkDeviceMemory`) with all the
        4833 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
        4834 
        4835 Thread-safety: This class must be externally synchronized.
        4836 */
        4837 class VmaDeviceMemoryBlock
        4838 {
        4839  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
        4840 public:
        4841  VmaBlockMetadata* m_pMetadata;
        4842 
        4843  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
        4844 
        4845  ~VmaDeviceMemoryBlock()
        4846  {
        4847  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
        4848  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        4849  }
        4850 
        4851  // Always call after construction.
        4852  void Init(
        4853  VmaAllocator hAllocator,
        4854  uint32_t newMemoryTypeIndex,
        4855  VkDeviceMemory newMemory,
        4856  VkDeviceSize newSize,
        4857  uint32_t id,
        4858  bool linearAlgorithm);
        4859  // Always call before destruction.
        4860  void Destroy(VmaAllocator allocator);
        4861 
        4862  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
        4863  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        4864  uint32_t GetId() const { return m_Id; }
        4865  void* GetMappedData() const { return m_pMappedData; }
        4866 
        4867  // Validates all data structures inside this object. If not valid, returns false.
        4868  bool Validate() const;
        4869 
        4870  VkResult CheckCorruption(VmaAllocator hAllocator);
        4871 
        4872  // ppData can be null.
        4873  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
        4874  void Unmap(VmaAllocator hAllocator, uint32_t count);
        4875 
        4876  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        4877  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        4878 
        4879  VkResult BindBufferMemory(
        4880  const VmaAllocator hAllocator,
        4881  const VmaAllocation hAllocation,
        4882  VkBuffer hBuffer);
        4883  VkResult BindImageMemory(
        4884  const VmaAllocator hAllocator,
        4885  const VmaAllocation hAllocation,
        4886  VkImage hImage);
        4887 
        4888 private:
        4889  uint32_t m_MemoryTypeIndex;
        4890  uint32_t m_Id;
        4891  VkDeviceMemory m_hMemory;
        4892 
        4893  // Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
        4894  // Also protects m_MapCount, m_pMappedData.
        4895  VMA_MUTEX m_Mutex;
        4896  uint32_t m_MapCount;
        4897  void* m_pMappedData;
        4898 };
        4899 
        4900 struct VmaPointerLess
        4901 {
        4902  bool operator()(const void* lhs, const void* rhs) const
        4903  {
        4904  return lhs < rhs;
        4905  }
        4906 };
        4907 
        4908 class VmaDefragmentator;
        4909 
        4910 /*
        4911 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
        4912 Vulkan memory type.
        4913 
        4914 Synchronized internally with a mutex.
        4915 */
        4916 struct VmaBlockVector
        4917 {
        4918  VMA_CLASS_NO_COPY(VmaBlockVector)
        4919 public:
        4920  VmaBlockVector(
        4921  VmaAllocator hAllocator,
        4922  uint32_t memoryTypeIndex,
        4923  VkDeviceSize preferredBlockSize,
        4924  size_t minBlockCount,
        4925  size_t maxBlockCount,
        4926  VkDeviceSize bufferImageGranularity,
        4927  uint32_t frameInUseCount,
        4928  bool isCustomPool,
        4929  bool linearAlgorithm);
        4930  ~VmaBlockVector();
        4931 
        4932  VkResult CreateMinBlocks();
        4933 
        4934  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        4935  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
        4936  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
        4937  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
        4938  bool UsesLinearAlgorithm() const { return m_LinearAlgorithm; }
        4939 
        4940  void GetPoolStats(VmaPoolStats* pStats);
        4941 
        4942  bool IsEmpty() const { return m_Blocks.empty(); }
        4943  bool IsCorruptionDetectionEnabled() const;
        4944 
        4945  VkResult Allocate(
        4946  VmaPool hCurrentPool,
        4947  uint32_t currentFrameIndex,
        4948  VkDeviceSize size,
        4949  VkDeviceSize alignment,
        4950  const VmaAllocationCreateInfo& createInfo,
        4951  VmaSuballocationType suballocType,
        4952  VmaAllocation* pAllocation);
        4953 
        4954  void Free(
        4955  VmaAllocation hAllocation);
        4956 
        4957  // Adds statistics of this BlockVector to pStats.
        4958  void AddStats(VmaStats* pStats);
        4959 
        4960 #if VMA_STATS_STRING_ENABLED
        4961  void PrintDetailedMap(class VmaJsonWriter& json);
        4962 #endif
        4963 
        4964  void MakePoolAllocationsLost(
        4965  uint32_t currentFrameIndex,
        4966  size_t* pLostAllocationCount);
        4967  VkResult CheckCorruption();
        4968 
        4969  VmaDefragmentator* EnsureDefragmentator(
        4970  VmaAllocator hAllocator,
        4971  uint32_t currentFrameIndex);
        4972 
        4973  VkResult Defragment(
        4974  VmaDefragmentationStats* pDefragmentationStats,
        4975  VkDeviceSize& maxBytesToMove,
        4976  uint32_t& maxAllocationsToMove);
        4977 
        4978  void DestroyDefragmentator();
        4979 
        4980 private:
        4981  friend class VmaDefragmentator;
        4982 
        4983  const VmaAllocator m_hAllocator;
        4984  const uint32_t m_MemoryTypeIndex;
        4985  const VkDeviceSize m_PreferredBlockSize;
        4986  const size_t m_MinBlockCount;
        4987  const size_t m_MaxBlockCount;
        4988  const VkDeviceSize m_BufferImageGranularity;
        4989  const uint32_t m_FrameInUseCount;
        4990  const bool m_IsCustomPool;
        4991  const bool m_LinearAlgorithm;
        4992  bool m_HasEmptyBlock;
        4993  VMA_MUTEX m_Mutex;
        4994  // Incrementally sorted by sumFreeSize, ascending.
        4995  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
        4996  /* There can be at most one allocation that is completely empty - a
        4997  hysteresis to avoid pessimistic case of alternating creation and destruction
        4998  of a VkDeviceMemory. */
        4999  VmaDefragmentator* m_pDefragmentator;
        5000  uint32_t m_NextBlockId;
        5001 
        5002  VkDeviceSize CalcMaxBlockSize() const;
        5003 
        5004  // Finds and removes given block from vector.
        5005  void Remove(VmaDeviceMemoryBlock* pBlock);
        5006 
        5007  // Performs single step in sorting m_Blocks. They may not be fully sorted
        5008  // after this call.
        5009  void IncrementallySortBlocks();
        5010 
        5011  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
        5012 };
        5013 
        5014 struct VmaPool_T
        5015 {
        5016  VMA_CLASS_NO_COPY(VmaPool_T)
        5017 public:
        5018  VmaBlockVector m_BlockVector;
        5019 
        5020  VmaPool_T(
        5021  VmaAllocator hAllocator,
        5022  const VmaPoolCreateInfo& createInfo);
        5023  ~VmaPool_T();
        5024 
        5025  uint32_t GetId() const { return m_Id; }
        5026  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
        5027 
        5028 #if VMA_STATS_STRING_ENABLED
        5029  //void PrintDetailedMap(class VmaStringBuilder& sb);
        5030 #endif
        5031 
        5032 private:
        5033  uint32_t m_Id;
        5034 };
        5035 
        5036 class VmaDefragmentator
        5037 {
        5038  VMA_CLASS_NO_COPY(VmaDefragmentator)
        5039 private:
        5040  const VmaAllocator m_hAllocator;
        5041  VmaBlockVector* const m_pBlockVector;
        5042  uint32_t m_CurrentFrameIndex;
        5043  VkDeviceSize m_BytesMoved;
        5044  uint32_t m_AllocationsMoved;
        5045 
        5046  struct AllocationInfo
        5047  {
        5048  VmaAllocation m_hAllocation;
        5049  VkBool32* m_pChanged;
        5050 
        5051  AllocationInfo() :
        5052  m_hAllocation(VK_NULL_HANDLE),
        5053  m_pChanged(VMA_NULL)
        5054  {
        5055  }
        5056  };
        5057 
        5058  struct AllocationInfoSizeGreater
        5059  {
        5060  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        5061  {
        5062  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
        5063  }
        5064  };
        5065 
        5066  // Used between AddAllocation and Defragment.
        5067  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        5068 
        5069  struct BlockInfo
        5070  {
        5071  VmaDeviceMemoryBlock* m_pBlock;
        5072  bool m_HasNonMovableAllocations;
        5073  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        5074 
        5075  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
        5076  m_pBlock(VMA_NULL),
        5077  m_HasNonMovableAllocations(true),
        5078  m_Allocations(pAllocationCallbacks),
        5079  m_pMappedDataForDefragmentation(VMA_NULL)
        5080  {
        5081  }
        5082 
        5083  void CalcHasNonMovableAllocations()
        5084  {
        5085  const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
        5086  const size_t defragmentAllocCount = m_Allocations.size();
        5087  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
        5088  }
        5089 
        5090  void SortAllocationsBySizeDescecnding()
        5091  {
        5092  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
        5093  }
        5094 
        5095  VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);
        5096  void Unmap(VmaAllocator hAllocator);
        5097 
        5098  private:
        5099  // Not null if mapped for defragmentation only, not originally mapped.
        5100  void* m_pMappedDataForDefragmentation;
        5101  };
        5102 
        5103  struct BlockPointerLess
        5104  {
        5105  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
        5106  {
        5107  return pLhsBlockInfo->m_pBlock < pRhsBlock;
        5108  }
        5109  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        5110  {
        5111  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
        5112  }
        5113  };
        5114 
        5115  // 1. Blocks with some non-movable allocations go first.
        5116  // 2. Blocks with smaller sumFreeSize go first.
        5117  struct BlockInfoCompareMoveDestination
        5118  {
        5119  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        5120  {
        5121  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
        5122  {
        5123  return true;
        5124  }
        5125  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
        5126  {
        5127  return false;
        5128  }
        5129  if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
        5130  {
        5131  return true;
        5132  }
        5133  return false;
        5134  }
        5135  };
        5136 
        5137  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
        5138  BlockInfoVector m_Blocks;
        5139 
        5140  VkResult DefragmentRound(
        5141  VkDeviceSize maxBytesToMove,
        5142  uint32_t maxAllocationsToMove);
        5143 
        5144  static bool MoveMakesSense(
        5145  size_t dstBlockIndex, VkDeviceSize dstOffset,
        5146  size_t srcBlockIndex, VkDeviceSize srcOffset);
        5147 
        5148 public:
        5149  VmaDefragmentator(
        5150  VmaAllocator hAllocator,
        5151  VmaBlockVector* pBlockVector,
        5152  uint32_t currentFrameIndex);
        5153 
        5154  ~VmaDefragmentator();
        5155 
        5156  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        5157  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        5158 
        5159  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        5160 
        5161  VkResult Defragment(
        5162  VkDeviceSize maxBytesToMove,
        5163  uint32_t maxAllocationsToMove);
        5164 };
        5165 
        5166 #if VMA_RECORDING_ENABLED
        5167 
        5168 class VmaRecorder
        5169 {
        5170 public:
        5171  VmaRecorder();
        5172  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
        5173  void WriteConfiguration(
        5174  const VkPhysicalDeviceProperties& devProps,
        5175  const VkPhysicalDeviceMemoryProperties& memProps,
        5176  bool dedicatedAllocationExtensionEnabled);
        5177  ~VmaRecorder();
        5178 
        5179  void RecordCreateAllocator(uint32_t frameIndex);
        5180  void RecordDestroyAllocator(uint32_t frameIndex);
        5181  void RecordCreatePool(uint32_t frameIndex,
        5182  const VmaPoolCreateInfo& createInfo,
        5183  VmaPool pool);
        5184  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
        5185  void RecordAllocateMemory(uint32_t frameIndex,
        5186  const VkMemoryRequirements& vkMemReq,
        5187  const VmaAllocationCreateInfo& createInfo,
        5188  VmaAllocation allocation);
        5189  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        5190  const VkMemoryRequirements& vkMemReq,
        5191  bool requiresDedicatedAllocation,
        5192  bool prefersDedicatedAllocation,
        5193  const VmaAllocationCreateInfo& createInfo,
        5194  VmaAllocation allocation);
        5195  void RecordAllocateMemoryForImage(uint32_t frameIndex,
        5196  const VkMemoryRequirements& vkMemReq,
        5197  bool requiresDedicatedAllocation,
        5198  bool prefersDedicatedAllocation,
        5199  const VmaAllocationCreateInfo& createInfo,
        5200  VmaAllocation allocation);
        5201  void RecordFreeMemory(uint32_t frameIndex,
        5202  VmaAllocation allocation);
        5203  void RecordSetAllocationUserData(uint32_t frameIndex,
        5204  VmaAllocation allocation,
        5205  const void* pUserData);
        5206  void RecordCreateLostAllocation(uint32_t frameIndex,
        5207  VmaAllocation allocation);
        5208  void RecordMapMemory(uint32_t frameIndex,
        5209  VmaAllocation allocation);
        5210  void RecordUnmapMemory(uint32_t frameIndex,
        5211  VmaAllocation allocation);
        5212  void RecordFlushAllocation(uint32_t frameIndex,
        5213  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        5214  void RecordInvalidateAllocation(uint32_t frameIndex,
        5215  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        5216  void RecordCreateBuffer(uint32_t frameIndex,
        5217  const VkBufferCreateInfo& bufCreateInfo,
        5218  const VmaAllocationCreateInfo& allocCreateInfo,
        5219  VmaAllocation allocation);
        5220  void RecordCreateImage(uint32_t frameIndex,
        5221  const VkImageCreateInfo& imageCreateInfo,
        5222  const VmaAllocationCreateInfo& allocCreateInfo,
        5223  VmaAllocation allocation);
        5224  void RecordDestroyBuffer(uint32_t frameIndex,
        5225  VmaAllocation allocation);
        5226  void RecordDestroyImage(uint32_t frameIndex,
        5227  VmaAllocation allocation);
        5228  void RecordTouchAllocation(uint32_t frameIndex,
        5229  VmaAllocation allocation);
        5230  void RecordGetAllocationInfo(uint32_t frameIndex,
        5231  VmaAllocation allocation);
        5232  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
        5233  VmaPool pool);
        5234 
        5235 private:
        5236  struct CallParams
        5237  {
        5238  uint32_t threadId;
        5239  double time;
        5240  };
        5241 
        5242  class UserDataString
        5243  {
        5244  public:
        5245  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
        5246  const char* GetString() const { return m_Str; }
        5247 
        5248  private:
        5249  char m_PtrStr[17];
        5250  const char* m_Str;
        5251  };
        5252 
        5253  bool m_UseMutex;
        5254  VmaRecordFlags m_Flags;
        5255  FILE* m_File;
        5256  VMA_MUTEX m_FileMutex;
        5257  int64_t m_Freq;
        5258  int64_t m_StartCounter;
        5259 
        5260  void GetBasicParams(CallParams& outParams);
        5261  void Flush();
        5262 };
        5263 
        5264 #endif // #if VMA_RECORDING_ENABLED
        5265 
        5266 // Main allocator object.
        5267 struct VmaAllocator_T
        5268 {
        5269  VMA_CLASS_NO_COPY(VmaAllocator_T)
        5270 public:
        5271  bool m_UseMutex;
        5272  bool m_UseKhrDedicatedAllocation;
        5273  VkDevice m_hDevice;
        5274  bool m_AllocationCallbacksSpecified;
        5275  VkAllocationCallbacks m_AllocationCallbacks;
        5276  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
        5277 
        5278  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
        5279  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
        5280  VMA_MUTEX m_HeapSizeLimitMutex;
        5281 
        5282  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
        5283  VkPhysicalDeviceMemoryProperties m_MemProps;
        5284 
        5285  // Default pools.
        5286  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
        5287 
        5288  // Each vector is sorted by memory (handle value).
        5289  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
        5290  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
        5291  VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
        5292 
        5293  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
        5294  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
        5295  ~VmaAllocator_T();
        5296 
        5297  const VkAllocationCallbacks* GetAllocationCallbacks() const
        5298  {
        5299  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        5300  }
        5301  const VmaVulkanFunctions& GetVulkanFunctions() const
        5302  {
        5303  return m_VulkanFunctions;
        5304  }
        5305 
        5306  VkDeviceSize GetBufferImageGranularity() const
        5307  {
        5308  return VMA_MAX(
        5309  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
        5310  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        5311  }
        5312 
        5313  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
        5314  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
        5315 
        5316  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
        5317  {
        5318  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
        5319  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        5320  }
        5321  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
        5322  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
        5323  {
        5324  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
        5325  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        5326  }
        5327  // Minimum alignment for all allocations in specific memory type.
        5328  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
        5329  {
        5330  return IsMemoryTypeNonCoherent(memTypeIndex) ?
        5331  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
        5332  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
        5333  }
        5334 
        5335  bool IsIntegratedGpu() const
        5336  {
        5337  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
        5338  }
        5339 
        5340 #if VMA_RECORDING_ENABLED
        5341  VmaRecorder* GetRecorder() const { return m_pRecorder; }
        5342 #endif
        5343 
        5344  void GetBufferMemoryRequirements(
        5345  VkBuffer hBuffer,
        5346  VkMemoryRequirements& memReq,
        5347  bool& requiresDedicatedAllocation,
        5348  bool& prefersDedicatedAllocation) const;
        5349  void GetImageMemoryRequirements(
        5350  VkImage hImage,
        5351  VkMemoryRequirements& memReq,
        5352  bool& requiresDedicatedAllocation,
        5353  bool& prefersDedicatedAllocation) const;
        5354 
        5355  // Main allocation function.
        5356  VkResult AllocateMemory(
        5357  const VkMemoryRequirements& vkMemReq,
        5358  bool requiresDedicatedAllocation,
        5359  bool prefersDedicatedAllocation,
        5360  VkBuffer dedicatedBuffer,
        5361  VkImage dedicatedImage,
        5362  const VmaAllocationCreateInfo& createInfo,
        5363  VmaSuballocationType suballocType,
        5364  VmaAllocation* pAllocation);
        5365 
        5366  // Main deallocation function.
        5367  void FreeMemory(const VmaAllocation allocation);
        5368 
        5369  void CalculateStats(VmaStats* pStats);
        5370 
        5371 #if VMA_STATS_STRING_ENABLED
        5372  void PrintDetailedMap(class VmaJsonWriter& json);
        5373 #endif
        5374 
        5375  VkResult Defragment(
        5376  VmaAllocation* pAllocations,
        5377  size_t allocationCount,
        5378  VkBool32* pAllocationsChanged,
        5379  const VmaDefragmentationInfo* pDefragmentationInfo,
        5380  VmaDefragmentationStats* pDefragmentationStats);
        5381 
        5382  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
        5383  bool TouchAllocation(VmaAllocation hAllocation);
        5384 
        5385  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
        5386  void DestroyPool(VmaPool pool);
        5387  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
        5388 
        5389  void SetCurrentFrameIndex(uint32_t frameIndex);
        5390  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
        5391 
        5392  void MakePoolAllocationsLost(
        5393  VmaPool hPool,
        5394  size_t* pLostAllocationCount);
        5395  VkResult CheckPoolCorruption(VmaPool hPool);
        5396  VkResult CheckCorruption(uint32_t memoryTypeBits);
        5397 
        5398  void CreateLostAllocation(VmaAllocation* pAllocation);
        5399 
        5400  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
        5401  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
        5402 
        5403  VkResult Map(VmaAllocation hAllocation, void** ppData);
        5404  void Unmap(VmaAllocation hAllocation);
        5405 
        5406  VkResult BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer);
        5407  VkResult BindImageMemory(VmaAllocation hAllocation, VkImage hImage);
        5408 
        5409  void FlushOrInvalidateAllocation(
        5410  VmaAllocation hAllocation,
        5411  VkDeviceSize offset, VkDeviceSize size,
        5412  VMA_CACHE_OPERATION op);
        5413 
        5414  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
        5415 
        5416 private:
        5417  VkDeviceSize m_PreferredLargeHeapBlockSize;
        5418 
        5419  VkPhysicalDevice m_PhysicalDevice;
        5420  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
        5421 
        5422  VMA_MUTEX m_PoolsMutex;
        5423  // Protected by m_PoolsMutex. Sorted by pointer value.
        5424  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
        5425  uint32_t m_NextPoolId;
        5426 
        5427  VmaVulkanFunctions m_VulkanFunctions;
        5428 
        5429 #if VMA_RECORDING_ENABLED
        5430  VmaRecorder* m_pRecorder;
        5431 #endif
        5432 
        5433  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
        5434 
        5435  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
        5436 
        5437  VkResult AllocateMemoryOfType(
        5438  VkDeviceSize size,
        5439  VkDeviceSize alignment,
        5440  bool dedicatedAllocation,
        5441  VkBuffer dedicatedBuffer,
        5442  VkImage dedicatedImage,
        5443  const VmaAllocationCreateInfo& createInfo,
        5444  uint32_t memTypeIndex,
        5445  VmaSuballocationType suballocType,
        5446  VmaAllocation* pAllocation);
        5447 
        5448  // Allocates and registers new VkDeviceMemory specifically for single allocation.
        5449  VkResult AllocateDedicatedMemory(
        5450  VkDeviceSize size,
        5451  VmaSuballocationType suballocType,
        5452  uint32_t memTypeIndex,
        5453  bool map,
        5454  bool isUserDataString,
        5455  void* pUserData,
        5456  VkBuffer dedicatedBuffer,
        5457  VkImage dedicatedImage,
        5458  VmaAllocation* pAllocation);
        5459 
        5460  // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.
        5461  void FreeDedicatedMemory(VmaAllocation allocation);
        5462 };
        5463 
        5465 // Memory allocation #2 after VmaAllocator_T definition
        5466 
        5467 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
        5468 {
        5469  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
        5470 }
        5471 
        5472 static void VmaFree(VmaAllocator hAllocator, void* ptr)
        5473 {
        5474  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
        5475 }
        5476 
        5477 template<typename T>
        5478 static T* VmaAllocate(VmaAllocator hAllocator)
        5479 {
        5480  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
        5481 }
        5482 
        5483 template<typename T>
        5484 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
        5485 {
        5486  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
        5487 }
        5488 
        5489 template<typename T>
        5490 static void vma_delete(VmaAllocator hAllocator, T* ptr)
        5491 {
        5492  if(ptr != VMA_NULL)
        5493  {
        5494  ptr->~T();
        5495  VmaFree(hAllocator, ptr);
        5496  }
        5497 }
        5498 
        5499 template<typename T>
        5500 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
        5501 {
        5502  if(ptr != VMA_NULL)
        5503  {
        5504  for(size_t i = count; i--; )
        5505  ptr[i].~T();
        5506  VmaFree(hAllocator, ptr);
        5507  }
        5508 }
        5509 
        5511 // VmaStringBuilder
        5512 
        5513 #if VMA_STATS_STRING_ENABLED
        5514 
        5515 class VmaStringBuilder
        5516 {
        5517 public:
        5518  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
        5519  size_t GetLength() const { return m_Data.size(); }
        5520  const char* GetData() const { return m_Data.data(); }
        5521 
        5522  void Add(char ch) { m_Data.push_back(ch); }
        5523  void Add(const char* pStr);
        5524  void AddNewLine() { Add('\n'); }
        5525  void AddNumber(uint32_t num);
        5526  void AddNumber(uint64_t num);
        5527  void AddPointer(const void* ptr);
        5528 
        5529 private:
        5530  VmaVector< char, VmaStlAllocator<char> > m_Data;
        5531 };
        5532 
        5533 void VmaStringBuilder::Add(const char* pStr)
        5534 {
        5535  const size_t strLen = strlen(pStr);
        5536  if(strLen > 0)
        5537  {
        5538  const size_t oldCount = m_Data.size();
        5539  m_Data.resize(oldCount + strLen);
        5540  memcpy(m_Data.data() + oldCount, pStr, strLen);
        5541  }
        5542 }
        5543 
        5544 void VmaStringBuilder::AddNumber(uint32_t num)
        5545 {
        5546  char buf[11];
        5547  VmaUint32ToStr(buf, sizeof(buf), num);
        5548  Add(buf);
        5549 }
        5550 
        5551 void VmaStringBuilder::AddNumber(uint64_t num)
        5552 {
        5553  char buf[21];
        5554  VmaUint64ToStr(buf, sizeof(buf), num);
        5555  Add(buf);
        5556 }
        5557 
        5558 void VmaStringBuilder::AddPointer(const void* ptr)
        5559 {
        5560  char buf[21];
        5561  VmaPtrToStr(buf, sizeof(buf), ptr);
        5562  Add(buf);
        5563 }
        5564 
        5565 #endif // #if VMA_STATS_STRING_ENABLED
        5566 
        5568 // VmaJsonWriter
        5569 
        5570 #if VMA_STATS_STRING_ENABLED
        5571 
        5572 class VmaJsonWriter
        5573 {
        5574  VMA_CLASS_NO_COPY(VmaJsonWriter)
        5575 public:
        5576  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
        5577  ~VmaJsonWriter();
        5578 
        5579  void BeginObject(bool singleLine = false);
        5580  void EndObject();
        5581 
        5582  void BeginArray(bool singleLine = false);
        5583  void EndArray();
        5584 
        5585  void WriteString(const char* pStr);
        5586  void BeginString(const char* pStr = VMA_NULL);
        5587  void ContinueString(const char* pStr);
        5588  void ContinueString(uint32_t n);
        5589  void ContinueString(uint64_t n);
        5590  void ContinueString_Pointer(const void* ptr);
        5591  void EndString(const char* pStr = VMA_NULL);
        5592 
        5593  void WriteNumber(uint32_t n);
        5594  void WriteNumber(uint64_t n);
        5595  void WriteBool(bool b);
        5596  void WriteNull();
        5597 
        5598 private:
        5599  static const char* const INDENT;
        5600 
        5601  enum COLLECTION_TYPE
        5602  {
        5603  COLLECTION_TYPE_OBJECT,
        5604  COLLECTION_TYPE_ARRAY,
        5605  };
        5606  struct StackItem
        5607  {
        5608  COLLECTION_TYPE type;
        5609  uint32_t valueCount;
        5610  bool singleLineMode;
        5611  };
        5612 
        5613  VmaStringBuilder& m_SB;
        5614  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
        5615  bool m_InsideString;
        5616 
        5617  void BeginValue(bool isString);
        5618  void WriteIndent(bool oneLess = false);
        5619 };
        5620 
        5621 const char* const VmaJsonWriter::INDENT = " ";
        5622 
        5623 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
        5624  m_SB(sb),
        5625  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
        5626  m_InsideString(false)
        5627 {
        5628 }
        5629 
        5630 VmaJsonWriter::~VmaJsonWriter()
        5631 {
        5632  VMA_ASSERT(!m_InsideString);
        5633  VMA_ASSERT(m_Stack.empty());
        5634 }
        5635 
        5636 void VmaJsonWriter::BeginObject(bool singleLine)
        5637 {
        5638  VMA_ASSERT(!m_InsideString);
        5639 
        5640  BeginValue(false);
        5641  m_SB.Add('{');
        5642 
        5643  StackItem item;
        5644  item.type = COLLECTION_TYPE_OBJECT;
        5645  item.valueCount = 0;
        5646  item.singleLineMode = singleLine;
        5647  m_Stack.push_back(item);
        5648 }
        5649 
        5650 void VmaJsonWriter::EndObject()
        5651 {
        5652  VMA_ASSERT(!m_InsideString);
        5653 
        5654  WriteIndent(true);
        5655  m_SB.Add('}');
        5656 
        5657  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
        5658  m_Stack.pop_back();
        5659 }
        5660 
        5661 void VmaJsonWriter::BeginArray(bool singleLine)
        5662 {
        5663  VMA_ASSERT(!m_InsideString);
        5664 
        5665  BeginValue(false);
        5666  m_SB.Add('[');
        5667 
        5668  StackItem item;
        5669  item.type = COLLECTION_TYPE_ARRAY;
        5670  item.valueCount = 0;
        5671  item.singleLineMode = singleLine;
        5672  m_Stack.push_back(item);
        5673 }
        5674 
        5675 void VmaJsonWriter::EndArray()
        5676 {
        5677  VMA_ASSERT(!m_InsideString);
        5678 
        5679  WriteIndent(true);
        5680  m_SB.Add(']');
        5681 
        5682  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
        5683  m_Stack.pop_back();
        5684 }
        5685 
        5686 void VmaJsonWriter::WriteString(const char* pStr)
        5687 {
        5688  BeginString(pStr);
        5689  EndString();
        5690 }
        5691 
        5692 void VmaJsonWriter::BeginString(const char* pStr)
        5693 {
        5694  VMA_ASSERT(!m_InsideString);
        5695 
        5696  BeginValue(true);
        5697  m_SB.Add('"');
        5698  m_InsideString = true;
        5699  if(pStr != VMA_NULL && pStr[0] != '\0')
        5700  {
        5701  ContinueString(pStr);
        5702  }
        5703 }
        5704 
        5705 void VmaJsonWriter::ContinueString(const char* pStr)
        5706 {
        5707  VMA_ASSERT(m_InsideString);
        5708 
        5709  const size_t strLen = strlen(pStr);
        5710  for(size_t i = 0; i < strLen; ++i)
        5711  {
        5712  char ch = pStr[i];
        5713  if(ch == '\\')
        5714  {
        5715  m_SB.Add("\\\\");
        5716  }
        5717  else if(ch == '"')
        5718  {
        5719  m_SB.Add("\\\"");
        5720  }
        5721  else if(ch >= 32)
        5722  {
        5723  m_SB.Add(ch);
        5724  }
        5725  else switch(ch)
        5726  {
        5727  case '\b':
        5728  m_SB.Add("\\b");
        5729  break;
        5730  case '\f':
        5731  m_SB.Add("\\f");
        5732  break;
        5733  case '\n':
        5734  m_SB.Add("\\n");
        5735  break;
        5736  case '\r':
        5737  m_SB.Add("\\r");
        5738  break;
        5739  case '\t':
        5740  m_SB.Add("\\t");
        5741  break;
        5742  default:
        5743  VMA_ASSERT(0 && "Character not currently supported.");
        5744  break;
        5745  }
        5746  }
        5747 }
        5748 
        5749 void VmaJsonWriter::ContinueString(uint32_t n)
        5750 {
        5751  VMA_ASSERT(m_InsideString);
        5752  m_SB.AddNumber(n);
        5753 }
        5754 
        5755 void VmaJsonWriter::ContinueString(uint64_t n)
        5756 {
        5757  VMA_ASSERT(m_InsideString);
        5758  m_SB.AddNumber(n);
        5759 }
        5760 
        5761 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
        5762 {
        5763  VMA_ASSERT(m_InsideString);
        5764  m_SB.AddPointer(ptr);
        5765 }
        5766 
        5767 void VmaJsonWriter::EndString(const char* pStr)
        5768 {
        5769  VMA_ASSERT(m_InsideString);
        5770  if(pStr != VMA_NULL && pStr[0] != '\0')
        5771  {
        5772  ContinueString(pStr);
        5773  }
        5774  m_SB.Add('"');
        5775  m_InsideString = false;
        5776 }
        5777 
        5778 void VmaJsonWriter::WriteNumber(uint32_t n)
        5779 {
        5780  VMA_ASSERT(!m_InsideString);
        5781  BeginValue(false);
        5782  m_SB.AddNumber(n);
        5783 }
        5784 
        5785 void VmaJsonWriter::WriteNumber(uint64_t n)
        5786 {
        5787  VMA_ASSERT(!m_InsideString);
        5788  BeginValue(false);
        5789  m_SB.AddNumber(n);
        5790 }
        5791 
        5792 void VmaJsonWriter::WriteBool(bool b)
        5793 {
        5794  VMA_ASSERT(!m_InsideString);
        5795  BeginValue(false);
        5796  m_SB.Add(b ? "true" : "false");
        5797 }
        5798 
        5799 void VmaJsonWriter::WriteNull()
        5800 {
        5801  VMA_ASSERT(!m_InsideString);
        5802  BeginValue(false);
        5803  m_SB.Add("null");
        5804 }
        5805 
        5806 void VmaJsonWriter::BeginValue(bool isString)
        5807 {
        5808  if(!m_Stack.empty())
        5809  {
        5810  StackItem& currItem = m_Stack.back();
        5811  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        5812  currItem.valueCount % 2 == 0)
        5813  {
        5814  VMA_ASSERT(isString);
        5815  }
        5816 
        5817  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        5818  currItem.valueCount % 2 != 0)
        5819  {
        5820  m_SB.Add(": ");
        5821  }
        5822  else if(currItem.valueCount > 0)
        5823  {
        5824  m_SB.Add(", ");
        5825  WriteIndent();
        5826  }
        5827  else
        5828  {
        5829  WriteIndent();
        5830  }
        5831  ++currItem.valueCount;
        5832  }
        5833 }
        5834 
        5835 void VmaJsonWriter::WriteIndent(bool oneLess)
        5836 {
        5837  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
        5838  {
        5839  m_SB.AddNewLine();
        5840 
        5841  size_t count = m_Stack.size();
        5842  if(count > 0 && oneLess)
        5843  {
        5844  --count;
        5845  }
        5846  for(size_t i = 0; i < count; ++i)
        5847  {
        5848  m_SB.Add(INDENT);
        5849  }
        5850  }
        5851 }
        5852 
        5853 #endif // #if VMA_STATS_STRING_ENABLED
        5854 
        5856 
        5857 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
        5858 {
        5859  if(IsUserDataString())
        5860  {
        5861  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
        5862 
        5863  FreeUserDataString(hAllocator);
        5864 
        5865  if(pUserData != VMA_NULL)
        5866  {
        5867  const char* const newStrSrc = (char*)pUserData;
        5868  const size_t newStrLen = strlen(newStrSrc);
        5869  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
        5870  memcpy(newStrDst, newStrSrc, newStrLen + 1);
        5871  m_pUserData = newStrDst;
        5872  }
        5873  }
        5874  else
        5875  {
        5876  m_pUserData = pUserData;
        5877  }
        5878 }
        5879 
        5880 void VmaAllocation_T::ChangeBlockAllocation(
        5881  VmaAllocator hAllocator,
        5882  VmaDeviceMemoryBlock* block,
        5883  VkDeviceSize offset)
        5884 {
        5885  VMA_ASSERT(block != VMA_NULL);
        5886  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        5887 
        5888  // Move mapping reference counter from old block to new block.
        5889  if(block != m_BlockAllocation.m_Block)
        5890  {
        5891  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
        5892  if(IsPersistentMap())
        5893  ++mapRefCount;
        5894  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
        5895  block->Map(hAllocator, mapRefCount, VMA_NULL);
        5896  }
        5897 
        5898  m_BlockAllocation.m_Block = block;
        5899  m_BlockAllocation.m_Offset = offset;
        5900 }
        5901 
        5902 VkDeviceSize VmaAllocation_T::GetOffset() const
        5903 {
        5904  switch(m_Type)
        5905  {
        5906  case ALLOCATION_TYPE_BLOCK:
        5907  return m_BlockAllocation.m_Offset;
        5908  case ALLOCATION_TYPE_DEDICATED:
        5909  return 0;
        5910  default:
        5911  VMA_ASSERT(0);
        5912  return 0;
        5913  }
        5914 }
        5915 
        5916 VkDeviceMemory VmaAllocation_T::GetMemory() const
        5917 {
        5918  switch(m_Type)
        5919  {
        5920  case ALLOCATION_TYPE_BLOCK:
        5921  return m_BlockAllocation.m_Block->GetDeviceMemory();
        5922  case ALLOCATION_TYPE_DEDICATED:
        5923  return m_DedicatedAllocation.m_hMemory;
        5924  default:
        5925  VMA_ASSERT(0);
        5926  return VK_NULL_HANDLE;
        5927  }
        5928 }
        5929 
        5930 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
        5931 {
        5932  switch(m_Type)
        5933  {
        5934  case ALLOCATION_TYPE_BLOCK:
        5935  return m_BlockAllocation.m_Block->GetMemoryTypeIndex();
        5936  case ALLOCATION_TYPE_DEDICATED:
        5937  return m_DedicatedAllocation.m_MemoryTypeIndex;
        5938  default:
        5939  VMA_ASSERT(0);
        5940  return UINT32_MAX;
        5941  }
        5942 }
        5943 
        5944 void* VmaAllocation_T::GetMappedData() const
        5945 {
        5946  switch(m_Type)
        5947  {
        5948  case ALLOCATION_TYPE_BLOCK:
        5949  if(m_MapCount != 0)
        5950  {
        5951  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
        5952  VMA_ASSERT(pBlockData != VMA_NULL);
        5953  return (char*)pBlockData + m_BlockAllocation.m_Offset;
        5954  }
        5955  else
        5956  {
        5957  return VMA_NULL;
        5958  }
        5959  break;
        5960  case ALLOCATION_TYPE_DEDICATED:
        5961  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
        5962  return m_DedicatedAllocation.m_pMappedData;
        5963  default:
        5964  VMA_ASSERT(0);
        5965  return VMA_NULL;
        5966  }
        5967 }
        5968 
        5969 bool VmaAllocation_T::CanBecomeLost() const
        5970 {
        5971  switch(m_Type)
        5972  {
        5973  case ALLOCATION_TYPE_BLOCK:
        5974  return m_BlockAllocation.m_CanBecomeLost;
        5975  case ALLOCATION_TYPE_DEDICATED:
        5976  return false;
        5977  default:
        5978  VMA_ASSERT(0);
        5979  return false;
        5980  }
        5981 }
        5982 
        5983 VmaPool VmaAllocation_T::GetPool() const
        5984 {
        5985  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        5986  return m_BlockAllocation.m_hPool;
        5987 }
        5988 
        5989 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        5990 {
        5991  VMA_ASSERT(CanBecomeLost());
        5992 
        5993  /*
        5994  Warning: This is a carefully designed algorithm.
        5995  Do not modify unless you really know what you're doing :)
        5996  */
        5997  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
        5998  for(;;)
        5999  {
        6000  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        6001  {
        6002  VMA_ASSERT(0);
        6003  return false;
        6004  }
        6005  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
        6006  {
        6007  return false;
        6008  }
        6009  else // Last use time earlier than current time.
        6010  {
        6011  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
        6012  {
        6013  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
        6014  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
        6015  return true;
        6016  }
        6017  }
        6018  }
        6019 }
        6020 
        6021 #if VMA_STATS_STRING_ENABLED
        6022 
        6023 // Correspond to values of enum VmaSuballocationType.
        6024 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
        6025  "FREE",
        6026  "UNKNOWN",
        6027  "BUFFER",
        6028  "IMAGE_UNKNOWN",
        6029  "IMAGE_LINEAR",
        6030  "IMAGE_OPTIMAL",
        6031 };
        6032 
        6033 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
        6034 {
        6035  json.WriteString("Type");
        6036  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
        6037 
        6038  json.WriteString("Size");
        6039  json.WriteNumber(m_Size);
        6040 
        6041  if(m_pUserData != VMA_NULL)
        6042  {
        6043  json.WriteString("UserData");
        6044  if(IsUserDataString())
        6045  {
        6046  json.WriteString((const char*)m_pUserData);
        6047  }
        6048  else
        6049  {
        6050  json.BeginString();
        6051  json.ContinueString_Pointer(m_pUserData);
        6052  json.EndString();
        6053  }
        6054  }
        6055 
        6056  json.WriteString("CreationFrameIndex");
        6057  json.WriteNumber(m_CreationFrameIndex);
        6058 
        6059  json.WriteString("LastUseFrameIndex");
        6060  json.WriteNumber(GetLastUseFrameIndex());
        6061 
        6062  if(m_BufferImageUsage != 0)
        6063  {
        6064  json.WriteString("Usage");
        6065  json.WriteNumber(m_BufferImageUsage);
        6066  }
        6067 }
        6068 
        6069 #endif
        6070 
        6071 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
        6072 {
        6073  VMA_ASSERT(IsUserDataString());
        6074  if(m_pUserData != VMA_NULL)
        6075  {
        6076  char* const oldStr = (char*)m_pUserData;
        6077  const size_t oldStrLen = strlen(oldStr);
        6078  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
        6079  m_pUserData = VMA_NULL;
        6080  }
        6081 }
        6082 
        6083 void VmaAllocation_T::BlockAllocMap()
        6084 {
        6085  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        6086 
        6087  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        6088  {
        6089  ++m_MapCount;
        6090  }
        6091  else
        6092  {
        6093  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
        6094  }
        6095 }
        6096 
        6097 void VmaAllocation_T::BlockAllocUnmap()
        6098 {
        6099  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        6100 
        6101  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        6102  {
        6103  --m_MapCount;
        6104  }
        6105  else
        6106  {
        6107  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
        6108  }
        6109 }
        6110 
        6111 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
        6112 {
        6113  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        6114 
        6115  if(m_MapCount != 0)
        6116  {
        6117  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        6118  {
        6119  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
        6120  *ppData = m_DedicatedAllocation.m_pMappedData;
        6121  ++m_MapCount;
        6122  return VK_SUCCESS;
        6123  }
        6124  else
        6125  {
        6126  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
        6127  return VK_ERROR_MEMORY_MAP_FAILED;
        6128  }
        6129  }
        6130  else
        6131  {
        6132  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        6133  hAllocator->m_hDevice,
        6134  m_DedicatedAllocation.m_hMemory,
        6135  0, // offset
        6136  VK_WHOLE_SIZE,
        6137  0, // flags
        6138  ppData);
        6139  if(result == VK_SUCCESS)
        6140  {
        6141  m_DedicatedAllocation.m_pMappedData = *ppData;
        6142  m_MapCount = 1;
        6143  }
        6144  return result;
        6145  }
        6146 }
        6147 
        6148 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
        6149 {
        6150  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        6151 
        6152  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        6153  {
        6154  --m_MapCount;
        6155  if(m_MapCount == 0)
        6156  {
        6157  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
        6158  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
        6159  hAllocator->m_hDevice,
        6160  m_DedicatedAllocation.m_hMemory);
        6161  }
        6162  }
        6163  else
        6164  {
        6165  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
        6166  }
        6167 }
        6168 
        6169 #if VMA_STATS_STRING_ENABLED
        6170 
        6171 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
        6172 {
        6173  json.BeginObject();
        6174 
        6175  json.WriteString("Blocks");
        6176  json.WriteNumber(stat.blockCount);
        6177 
        6178  json.WriteString("Allocations");
        6179  json.WriteNumber(stat.allocationCount);
        6180 
        6181  json.WriteString("UnusedRanges");
        6182  json.WriteNumber(stat.unusedRangeCount);
        6183 
        6184  json.WriteString("UsedBytes");
        6185  json.WriteNumber(stat.usedBytes);
        6186 
        6187  json.WriteString("UnusedBytes");
        6188  json.WriteNumber(stat.unusedBytes);
        6189 
        6190  if(stat.allocationCount > 1)
        6191  {
        6192  json.WriteString("AllocationSize");
        6193  json.BeginObject(true);
        6194  json.WriteString("Min");
        6195  json.WriteNumber(stat.allocationSizeMin);
        6196  json.WriteString("Avg");
        6197  json.WriteNumber(stat.allocationSizeAvg);
        6198  json.WriteString("Max");
        6199  json.WriteNumber(stat.allocationSizeMax);
        6200  json.EndObject();
        6201  }
        6202 
        6203  if(stat.unusedRangeCount > 1)
        6204  {
        6205  json.WriteString("UnusedRangeSize");
        6206  json.BeginObject(true);
        6207  json.WriteString("Min");
        6208  json.WriteNumber(stat.unusedRangeSizeMin);
        6209  json.WriteString("Avg");
        6210  json.WriteNumber(stat.unusedRangeSizeAvg);
        6211  json.WriteString("Max");
        6212  json.WriteNumber(stat.unusedRangeSizeMax);
        6213  json.EndObject();
        6214  }
        6215 
        6216  json.EndObject();
        6217 }
        6218 
        6219 #endif // #if VMA_STATS_STRING_ENABLED
        6220 
        6221 struct VmaSuballocationItemSizeLess
        6222 {
        6223  bool operator()(
        6224  const VmaSuballocationList::iterator lhs,
        6225  const VmaSuballocationList::iterator rhs) const
        6226  {
        6227  return lhs->size < rhs->size;
        6228  }
        6229  bool operator()(
        6230  const VmaSuballocationList::iterator lhs,
        6231  VkDeviceSize rhsSize) const
        6232  {
        6233  return lhs->size < rhsSize;
        6234  }
        6235 };
        6236 
        6237 
        6239 // class VmaBlockMetadata
        6240 
        6241 #if VMA_STATS_STRING_ENABLED
        6242 
        6243 void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
        6244  VkDeviceSize unusedBytes,
        6245  size_t allocationCount,
        6246  size_t unusedRangeCount) const
        6247 {
        6248  json.BeginObject();
        6249 
        6250  json.WriteString("TotalBytes");
        6251  json.WriteNumber(GetSize());
        6252 
        6253  json.WriteString("UnusedBytes");
        6254  json.WriteNumber(unusedBytes);
        6255 
        6256  json.WriteString("Allocations");
        6257  json.WriteNumber((uint64_t)allocationCount);
        6258 
        6259  json.WriteString("UnusedRanges");
        6260  json.WriteNumber((uint64_t)unusedRangeCount);
        6261 
        6262  json.WriteString("Suballocations");
        6263  json.BeginArray();
        6264 }
        6265 
        6266 void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        6267  VkDeviceSize offset,
        6268  VmaAllocation hAllocation) const
        6269 {
        6270  json.BeginObject(true);
        6271 
        6272  json.WriteString("Offset");
        6273  json.WriteNumber(offset);
        6274 
        6275  hAllocation->PrintParameters(json);
        6276 
        6277  json.EndObject();
        6278 }
        6279 
        6280 void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        6281  VkDeviceSize offset,
        6282  VkDeviceSize size) const
        6283 {
        6284  json.BeginObject(true);
        6285 
        6286  json.WriteString("Offset");
        6287  json.WriteNumber(offset);
        6288 
        6289  json.WriteString("Type");
        6290  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
        6291 
        6292  json.WriteString("Size");
        6293  json.WriteNumber(size);
        6294 
        6295  json.EndObject();
        6296 }
        6297 
        6298 void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
        6299 {
        6300  json.EndArray();
        6301  json.EndObject();
        6302 }
        6303 
        6304 #endif // #if VMA_STATS_STRING_ENABLED
        6305 
        6307 // class VmaBlockMetadata_Generic
        6308 
        6309 VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
        6310  m_FreeCount(0),
        6311  m_SumFreeSize(0),
        6312  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        6313  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
        6314 {
        6315 }
        6316 
        6317 VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
        6318 {
        6319 }
        6320 
        6321 void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
        6322 {
        6323  VmaBlockMetadata::Init(size);
        6324  m_FreeCount = 1;
        6325  m_SumFreeSize = size;
        6326 
        6327  VmaSuballocation suballoc = {};
        6328  suballoc.offset = 0;
        6329  suballoc.size = size;
        6330  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        6331  suballoc.hAllocation = VK_NULL_HANDLE;
        6332 
        6333  m_Suballocations.push_back(suballoc);
        6334  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
        6335  --suballocItem;
        6336  m_FreeSuballocationsBySize.push_back(suballocItem);
        6337 }
        6338 
        6339 bool VmaBlockMetadata_Generic::Validate() const
        6340 {
        6341  if(m_Suballocations.empty())
        6342  {
        6343  return false;
        6344  }
        6345 
        6346  // Expected offset of new suballocation as calculated from previous ones.
        6347  VkDeviceSize calculatedOffset = 0;
        6348  // Expected number of free suballocations as calculated from traversing their list.
        6349  uint32_t calculatedFreeCount = 0;
        6350  // Expected sum size of free suballocations as calculated from traversing their list.
        6351  VkDeviceSize calculatedSumFreeSize = 0;
        6352  // Expected number of free suballocations that should be registered in
        6353  // m_FreeSuballocationsBySize calculated from traversing their list.
        6354  size_t freeSuballocationsToRegister = 0;
        6355  // True if previous visited suballocation was free.
        6356  bool prevFree = false;
        6357 
        6358  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        6359  suballocItem != m_Suballocations.cend();
        6360  ++suballocItem)
        6361  {
        6362  const VmaSuballocation& subAlloc = *suballocItem;
        6363 
        6364  // Actual offset of this suballocation doesn't match expected one.
        6365  if(subAlloc.offset != calculatedOffset)
        6366  {
        6367  return false;
        6368  }
        6369 
        6370  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        6371  // Two adjacent free suballocations are invalid. They should be merged.
        6372  if(prevFree && currFree)
        6373  {
        6374  return false;
        6375  }
        6376 
        6377  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
        6378  {
        6379  return false;
        6380  }
        6381 
        6382  if(currFree)
        6383  {
        6384  calculatedSumFreeSize += subAlloc.size;
        6385  ++calculatedFreeCount;
        6386  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        6387  {
        6388  ++freeSuballocationsToRegister;
        6389  }
        6390 
        6391  // Margin required between allocations - every free space must be at least that large.
        6392  if(subAlloc.size < VMA_DEBUG_MARGIN)
        6393  {
        6394  return false;
        6395  }
        6396  }
        6397  else
        6398  {
        6399  if(subAlloc.hAllocation->GetOffset() != subAlloc.offset)
        6400  {
        6401  return false;
        6402  }
        6403  if(subAlloc.hAllocation->GetSize() != subAlloc.size)
        6404  {
        6405  return false;
        6406  }
        6407 
        6408  // Margin required between allocations - previous allocation must be free.
        6409  if(VMA_DEBUG_MARGIN > 0 && !prevFree)
        6410  {
        6411  return false;
        6412  }
        6413  }
        6414 
        6415  calculatedOffset += subAlloc.size;
        6416  prevFree = currFree;
        6417  }
        6418 
        6419  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
        6420  // match expected one.
        6421  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
        6422  {
        6423  return false;
        6424  }
        6425 
        6426  VkDeviceSize lastSize = 0;
        6427  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
        6428  {
        6429  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
        6430 
        6431  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        6432  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
        6433  {
        6434  return false;
        6435  }
        6436  // They must be sorted by size ascending.
        6437  if(suballocItem->size < lastSize)
        6438  {
        6439  return false;
        6440  }
        6441 
        6442  lastSize = suballocItem->size;
        6443  }
        6444 
        6445  // Check if totals match calculacted values.
        6446  if(!ValidateFreeSuballocationList() ||
        6447  (calculatedOffset != GetSize()) ||
        6448  (calculatedSumFreeSize != m_SumFreeSize) ||
        6449  (calculatedFreeCount != m_FreeCount))
        6450  {
        6451  return false;
        6452  }
        6453 
        6454  return true;
        6455 }
        6456 
        6457 VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
        6458 {
        6459  if(!m_FreeSuballocationsBySize.empty())
        6460  {
        6461  return m_FreeSuballocationsBySize.back()->size;
        6462  }
        6463  else
        6464  {
        6465  return 0;
        6466  }
        6467 }
        6468 
        6469 bool VmaBlockMetadata_Generic::IsEmpty() const
        6470 {
        6471  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
        6472 }
        6473 
        6474 void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        6475 {
        6476  outInfo.blockCount = 1;
        6477 
        6478  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        6479  outInfo.allocationCount = rangeCount - m_FreeCount;
        6480  outInfo.unusedRangeCount = m_FreeCount;
        6481 
        6482  outInfo.unusedBytes = m_SumFreeSize;
        6483  outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
        6484 
        6485  outInfo.allocationSizeMin = UINT64_MAX;
        6486  outInfo.allocationSizeMax = 0;
        6487  outInfo.unusedRangeSizeMin = UINT64_MAX;
        6488  outInfo.unusedRangeSizeMax = 0;
        6489 
        6490  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        6491  suballocItem != m_Suballocations.cend();
        6492  ++suballocItem)
        6493  {
        6494  const VmaSuballocation& suballoc = *suballocItem;
        6495  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        6496  {
        6497  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        6498  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
        6499  }
        6500  else
        6501  {
        6502  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
        6503  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
        6504  }
        6505  }
        6506 }
        6507 
        6508 void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
        6509 {
        6510  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        6511 
        6512  inoutStats.size += GetSize();
        6513  inoutStats.unusedSize += m_SumFreeSize;
        6514  inoutStats.allocationCount += rangeCount - m_FreeCount;
        6515  inoutStats.unusedRangeCount += m_FreeCount;
        6516  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
        6517 }
        6518 
        6519 #if VMA_STATS_STRING_ENABLED
        6520 
        6521 void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
        6522 {
        6523  PrintDetailedMap_Begin(json,
        6524  m_SumFreeSize, // unusedBytes
        6525  m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
        6526  m_FreeCount); // unusedRangeCount
        6527 
        6528  size_t i = 0;
        6529  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        6530  suballocItem != m_Suballocations.cend();
        6531  ++suballocItem, ++i)
        6532  {
        6533  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        6534  {
        6535  PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
        6536  }
        6537  else
        6538  {
        6539  PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
        6540  }
        6541  }
        6542 
        6543  PrintDetailedMap_End(json);
        6544 }
        6545 
        6546 #endif // #if VMA_STATS_STRING_ENABLED
        6547 
        6548 /*
        6549 How many suitable free suballocations to analyze before choosing best one.
        6550 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
        6551  be chosen.
        6552 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
        6553  suballocations will be analized and best one will be chosen.
        6554 - Any other value is also acceptable.
        6555 */
        6556 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
        6557 
        6558 bool VmaBlockMetadata_Generic::CreateAllocationRequest(
        6559  uint32_t currentFrameIndex,
        6560  uint32_t frameInUseCount,
        6561  VkDeviceSize bufferImageGranularity,
        6562  VkDeviceSize allocSize,
        6563  VkDeviceSize allocAlignment,
        6564  bool upperAddress,
        6565  VmaSuballocationType allocType,
        6566  bool canMakeOtherLost,
        6567  VmaAllocationRequest* pAllocationRequest)
        6568 {
        6569  VMA_ASSERT(allocSize > 0);
        6570  VMA_ASSERT(!upperAddress);
        6571  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        6572  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        6573  VMA_HEAVY_ASSERT(Validate());
        6574 
        6575  // There is not enough total free space in this block to fullfill the request: Early return.
        6576  if(canMakeOtherLost == false && m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
        6577  {
        6578  return false;
        6579  }
        6580 
        6581  // New algorithm, efficiently searching freeSuballocationsBySize.
        6582  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
        6583  if(freeSuballocCount > 0)
        6584  {
        6585  if(VMA_BEST_FIT)
        6586  {
        6587  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
        6588  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        6589  m_FreeSuballocationsBySize.data(),
        6590  m_FreeSuballocationsBySize.data() + freeSuballocCount,
        6591  allocSize + 2 * VMA_DEBUG_MARGIN,
        6592  VmaSuballocationItemSizeLess());
        6593  size_t index = it - m_FreeSuballocationsBySize.data();
        6594  for(; index < freeSuballocCount; ++index)
        6595  {
        6596  if(CheckAllocation(
        6597  currentFrameIndex,
        6598  frameInUseCount,
        6599  bufferImageGranularity,
        6600  allocSize,
        6601  allocAlignment,
        6602  allocType,
        6603  m_FreeSuballocationsBySize[index],
        6604  false, // canMakeOtherLost
        6605  &pAllocationRequest->offset,
        6606  &pAllocationRequest->itemsToMakeLostCount,
        6607  &pAllocationRequest->sumFreeSize,
        6608  &pAllocationRequest->sumItemSize))
        6609  {
        6610  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        6611  return true;
        6612  }
        6613  }
        6614  }
        6615  else
        6616  {
        6617  // Search staring from biggest suballocations.
        6618  for(size_t index = freeSuballocCount; index--; )
        6619  {
        6620  if(CheckAllocation(
        6621  currentFrameIndex,
        6622  frameInUseCount,
        6623  bufferImageGranularity,
        6624  allocSize,
        6625  allocAlignment,
        6626  allocType,
        6627  m_FreeSuballocationsBySize[index],
        6628  false, // canMakeOtherLost
        6629  &pAllocationRequest->offset,
        6630  &pAllocationRequest->itemsToMakeLostCount,
        6631  &pAllocationRequest->sumFreeSize,
        6632  &pAllocationRequest->sumItemSize))
        6633  {
        6634  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        6635  return true;
        6636  }
        6637  }
        6638  }
        6639  }
        6640 
        6641  if(canMakeOtherLost)
        6642  {
        6643  // Brute-force algorithm. TODO: Come up with something better.
        6644 
        6645  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
        6646  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
        6647 
        6648  VmaAllocationRequest tmpAllocRequest = {};
        6649  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
        6650  suballocIt != m_Suballocations.end();
        6651  ++suballocIt)
        6652  {
        6653  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
        6654  suballocIt->hAllocation->CanBecomeLost())
        6655  {
        6656  if(CheckAllocation(
        6657  currentFrameIndex,
        6658  frameInUseCount,
        6659  bufferImageGranularity,
        6660  allocSize,
        6661  allocAlignment,
        6662  allocType,
        6663  suballocIt,
        6664  canMakeOtherLost,
        6665  &tmpAllocRequest.offset,
        6666  &tmpAllocRequest.itemsToMakeLostCount,
        6667  &tmpAllocRequest.sumFreeSize,
        6668  &tmpAllocRequest.sumItemSize))
        6669  {
        6670  tmpAllocRequest.item = suballocIt;
        6671 
        6672  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
        6673  {
        6674  *pAllocationRequest = tmpAllocRequest;
        6675  }
        6676  }
        6677  }
        6678  }
        6679 
        6680  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
        6681  {
        6682  return true;
        6683  }
        6684  }
        6685 
        6686  return false;
        6687 }
        6688 
        6689 bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
        6690  uint32_t currentFrameIndex,
        6691  uint32_t frameInUseCount,
        6692  VmaAllocationRequest* pAllocationRequest)
        6693 {
        6694  while(pAllocationRequest->itemsToMakeLostCount > 0)
        6695  {
        6696  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
        6697  {
        6698  ++pAllocationRequest->item;
        6699  }
        6700  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        6701  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
        6702  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
        6703  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        6704  {
        6705  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
        6706  --pAllocationRequest->itemsToMakeLostCount;
        6707  }
        6708  else
        6709  {
        6710  return false;
        6711  }
        6712  }
        6713 
        6714  VMA_HEAVY_ASSERT(Validate());
        6715  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        6716  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
        6717 
        6718  return true;
        6719 }
        6720 
        6721 uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        6722 {
        6723  uint32_t lostAllocationCount = 0;
        6724  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        6725  it != m_Suballocations.end();
        6726  ++it)
        6727  {
        6728  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
        6729  it->hAllocation->CanBecomeLost() &&
        6730  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        6731  {
        6732  it = FreeSuballocation(it);
        6733  ++lostAllocationCount;
        6734  }
        6735  }
        6736  return lostAllocationCount;
        6737 }
        6738 
        6739 VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
        6740 {
        6741  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        6742  it != m_Suballocations.end();
        6743  ++it)
        6744  {
        6745  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        6746  {
        6747  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
        6748  {
        6749  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        6750  return VK_ERROR_VALIDATION_FAILED_EXT;
        6751  }
        6752  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
        6753  {
        6754  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        6755  return VK_ERROR_VALIDATION_FAILED_EXT;
        6756  }
        6757  }
        6758  }
        6759 
        6760  return VK_SUCCESS;
        6761 }
        6762 
        6763 void VmaBlockMetadata_Generic::Alloc(
        6764  const VmaAllocationRequest& request,
        6765  VmaSuballocationType type,
        6766  VkDeviceSize allocSize,
        6767  bool upperAddress,
        6768  VmaAllocation hAllocation)
        6769 {
        6770  VMA_ASSERT(!upperAddress);
        6771  VMA_ASSERT(request.item != m_Suballocations.end());
        6772  VmaSuballocation& suballoc = *request.item;
        6773  // Given suballocation is a free block.
        6774  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        6775  // Given offset is inside this suballocation.
        6776  VMA_ASSERT(request.offset >= suballoc.offset);
        6777  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
        6778  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
        6779  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
        6780 
        6781  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
        6782  // it to become used.
        6783  UnregisterFreeSuballocation(request.item);
        6784 
        6785  suballoc.offset = request.offset;
        6786  suballoc.size = allocSize;
        6787  suballoc.type = type;
        6788  suballoc.hAllocation = hAllocation;
        6789 
        6790  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
        6791  if(paddingEnd)
        6792  {
        6793  VmaSuballocation paddingSuballoc = {};
        6794  paddingSuballoc.offset = request.offset + allocSize;
        6795  paddingSuballoc.size = paddingEnd;
        6796  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        6797  VmaSuballocationList::iterator next = request.item;
        6798  ++next;
        6799  const VmaSuballocationList::iterator paddingEndItem =
        6800  m_Suballocations.insert(next, paddingSuballoc);
        6801  RegisterFreeSuballocation(paddingEndItem);
        6802  }
        6803 
        6804  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
        6805  if(paddingBegin)
        6806  {
        6807  VmaSuballocation paddingSuballoc = {};
        6808  paddingSuballoc.offset = request.offset - paddingBegin;
        6809  paddingSuballoc.size = paddingBegin;
        6810  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        6811  const VmaSuballocationList::iterator paddingBeginItem =
        6812  m_Suballocations.insert(request.item, paddingSuballoc);
        6813  RegisterFreeSuballocation(paddingBeginItem);
        6814  }
        6815 
        6816  // Update totals.
        6817  m_FreeCount = m_FreeCount - 1;
        6818  if(paddingBegin > 0)
        6819  {
        6820  ++m_FreeCount;
        6821  }
        6822  if(paddingEnd > 0)
        6823  {
        6824  ++m_FreeCount;
        6825  }
        6826  m_SumFreeSize -= allocSize;
        6827 }
        6828 
        6829 void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
        6830 {
        6831  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        6832  suballocItem != m_Suballocations.end();
        6833  ++suballocItem)
        6834  {
        6835  VmaSuballocation& suballoc = *suballocItem;
        6836  if(suballoc.hAllocation == allocation)
        6837  {
        6838  FreeSuballocation(suballocItem);
        6839  VMA_HEAVY_ASSERT(Validate());
        6840  return;
        6841  }
        6842  }
        6843  VMA_ASSERT(0 && "Not found!");
        6844 }
        6845 
        6846 void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
        6847 {
        6848  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        6849  suballocItem != m_Suballocations.end();
        6850  ++suballocItem)
        6851  {
        6852  VmaSuballocation& suballoc = *suballocItem;
        6853  if(suballoc.offset == offset)
        6854  {
        6855  FreeSuballocation(suballocItem);
        6856  return;
        6857  }
        6858  }
        6859  VMA_ASSERT(0 && "Not found!");
        6860 }
        6861 
        6862 bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
        6863 {
        6864  VkDeviceSize lastSize = 0;
        6865  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
        6866  {
        6867  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
        6868 
        6869  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        6870  {
        6871  VMA_ASSERT(0);
        6872  return false;
        6873  }
        6874  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        6875  {
        6876  VMA_ASSERT(0);
        6877  return false;
        6878  }
        6879  if(it->size < lastSize)
        6880  {
        6881  VMA_ASSERT(0);
        6882  return false;
        6883  }
        6884 
        6885  lastSize = it->size;
        6886  }
        6887  return true;
        6888 }
        6889 
        6890 bool VmaBlockMetadata_Generic::CheckAllocation(
        6891  uint32_t currentFrameIndex,
        6892  uint32_t frameInUseCount,
        6893  VkDeviceSize bufferImageGranularity,
        6894  VkDeviceSize allocSize,
        6895  VkDeviceSize allocAlignment,
        6896  VmaSuballocationType allocType,
        6897  VmaSuballocationList::const_iterator suballocItem,
        6898  bool canMakeOtherLost,
        6899  VkDeviceSize* pOffset,
        6900  size_t* itemsToMakeLostCount,
        6901  VkDeviceSize* pSumFreeSize,
        6902  VkDeviceSize* pSumItemSize) const
        6903 {
        6904  VMA_ASSERT(allocSize > 0);
        6905  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        6906  VMA_ASSERT(suballocItem != m_Suballocations.cend());
        6907  VMA_ASSERT(pOffset != VMA_NULL);
        6908 
        6909  *itemsToMakeLostCount = 0;
        6910  *pSumFreeSize = 0;
        6911  *pSumItemSize = 0;
        6912 
        6913  if(canMakeOtherLost)
        6914  {
        6915  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        6916  {
        6917  *pSumFreeSize = suballocItem->size;
        6918  }
        6919  else
        6920  {
        6921  if(suballocItem->hAllocation->CanBecomeLost() &&
        6922  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        6923  {
        6924  ++*itemsToMakeLostCount;
        6925  *pSumItemSize = suballocItem->size;
        6926  }
        6927  else
        6928  {
        6929  return false;
        6930  }
        6931  }
        6932 
        6933  // Remaining size is too small for this request: Early return.
        6934  if(GetSize() - suballocItem->offset < allocSize)
        6935  {
        6936  return false;
        6937  }
        6938 
        6939  // Start from offset equal to beginning of this suballocation.
        6940  *pOffset = suballocItem->offset;
        6941 
        6942  // Apply VMA_DEBUG_MARGIN at the beginning.
        6943  if(VMA_DEBUG_MARGIN > 0)
        6944  {
        6945  *pOffset += VMA_DEBUG_MARGIN;
        6946  }
        6947 
        6948  // Apply alignment.
        6949  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        6950 
        6951  // Check previous suballocations for BufferImageGranularity conflicts.
        6952  // Make bigger alignment if necessary.
        6953  if(bufferImageGranularity > 1)
        6954  {
        6955  bool bufferImageGranularityConflict = false;
        6956  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        6957  while(prevSuballocItem != m_Suballocations.cbegin())
        6958  {
        6959  --prevSuballocItem;
        6960  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        6961  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        6962  {
        6963  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        6964  {
        6965  bufferImageGranularityConflict = true;
        6966  break;
        6967  }
        6968  }
        6969  else
        6970  // Already on previous page.
        6971  break;
        6972  }
        6973  if(bufferImageGranularityConflict)
        6974  {
        6975  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        6976  }
        6977  }
        6978 
        6979  // Now that we have final *pOffset, check if we are past suballocItem.
        6980  // If yes, return false - this function should be called for another suballocItem as starting point.
        6981  if(*pOffset >= suballocItem->offset + suballocItem->size)
        6982  {
        6983  return false;
        6984  }
        6985 
        6986  // Calculate padding at the beginning based on current offset.
        6987  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
        6988 
        6989  // Calculate required margin at the end.
        6990  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        6991 
        6992  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
        6993  // Another early return check.
        6994  if(suballocItem->offset + totalSize > GetSize())
        6995  {
        6996  return false;
        6997  }
        6998 
        6999  // Advance lastSuballocItem until desired size is reached.
        7000  // Update itemsToMakeLostCount.
        7001  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
        7002  if(totalSize > suballocItem->size)
        7003  {
        7004  VkDeviceSize remainingSize = totalSize - suballocItem->size;
        7005  while(remainingSize > 0)
        7006  {
        7007  ++lastSuballocItem;
        7008  if(lastSuballocItem == m_Suballocations.cend())
        7009  {
        7010  return false;
        7011  }
        7012  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        7013  {
        7014  *pSumFreeSize += lastSuballocItem->size;
        7015  }
        7016  else
        7017  {
        7018  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
        7019  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
        7020  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        7021  {
        7022  ++*itemsToMakeLostCount;
        7023  *pSumItemSize += lastSuballocItem->size;
        7024  }
        7025  else
        7026  {
        7027  return false;
        7028  }
        7029  }
        7030  remainingSize = (lastSuballocItem->size < remainingSize) ?
        7031  remainingSize - lastSuballocItem->size : 0;
        7032  }
        7033  }
        7034 
        7035  // Check next suballocations for BufferImageGranularity conflicts.
        7036  // If conflict exists, we must mark more allocations lost or fail.
        7037  if(bufferImageGranularity > 1)
        7038  {
        7039  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
        7040  ++nextSuballocItem;
        7041  while(nextSuballocItem != m_Suballocations.cend())
        7042  {
        7043  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        7044  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        7045  {
        7046  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        7047  {
        7048  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
        7049  if(nextSuballoc.hAllocation->CanBecomeLost() &&
        7050  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        7051  {
        7052  ++*itemsToMakeLostCount;
        7053  }
        7054  else
        7055  {
        7056  return false;
        7057  }
        7058  }
        7059  }
        7060  else
        7061  {
        7062  // Already on next page.
        7063  break;
        7064  }
        7065  ++nextSuballocItem;
        7066  }
        7067  }
        7068  }
        7069  else
        7070  {
        7071  const VmaSuballocation& suballoc = *suballocItem;
        7072  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7073 
        7074  *pSumFreeSize = suballoc.size;
        7075 
        7076  // Size of this suballocation is too small for this request: Early return.
        7077  if(suballoc.size < allocSize)
        7078  {
        7079  return false;
        7080  }
        7081 
        7082  // Start from offset equal to beginning of this suballocation.
        7083  *pOffset = suballoc.offset;
        7084 
        7085  // Apply VMA_DEBUG_MARGIN at the beginning.
        7086  if(VMA_DEBUG_MARGIN > 0)
        7087  {
        7088  *pOffset += VMA_DEBUG_MARGIN;
        7089  }
        7090 
        7091  // Apply alignment.
        7092  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        7093 
        7094  // Check previous suballocations for BufferImageGranularity conflicts.
        7095  // Make bigger alignment if necessary.
        7096  if(bufferImageGranularity > 1)
        7097  {
        7098  bool bufferImageGranularityConflict = false;
        7099  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        7100  while(prevSuballocItem != m_Suballocations.cbegin())
        7101  {
        7102  --prevSuballocItem;
        7103  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        7104  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        7105  {
        7106  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        7107  {
        7108  bufferImageGranularityConflict = true;
        7109  break;
        7110  }
        7111  }
        7112  else
        7113  // Already on previous page.
        7114  break;
        7115  }
        7116  if(bufferImageGranularityConflict)
        7117  {
        7118  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        7119  }
        7120  }
        7121 
        7122  // Calculate padding at the beginning based on current offset.
        7123  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
        7124 
        7125  // Calculate required margin at the end.
        7126  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        7127 
        7128  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
        7129  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
        7130  {
        7131  return false;
        7132  }
        7133 
        7134  // Check next suballocations for BufferImageGranularity conflicts.
        7135  // If conflict exists, allocation cannot be made here.
        7136  if(bufferImageGranularity > 1)
        7137  {
        7138  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        7139  ++nextSuballocItem;
        7140  while(nextSuballocItem != m_Suballocations.cend())
        7141  {
        7142  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        7143  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        7144  {
        7145  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        7146  {
        7147  return false;
        7148  }
        7149  }
        7150  else
        7151  {
        7152  // Already on next page.
        7153  break;
        7154  }
        7155  ++nextSuballocItem;
        7156  }
        7157  }
        7158  }
        7159 
        7160  // All tests passed: Success. pOffset is already filled.
        7161  return true;
        7162 }
        7163 
        7164 void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
        7165 {
        7166  VMA_ASSERT(item != m_Suballocations.end());
        7167  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        7168 
        7169  VmaSuballocationList::iterator nextItem = item;
        7170  ++nextItem;
        7171  VMA_ASSERT(nextItem != m_Suballocations.end());
        7172  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        7173 
        7174  item->size += nextItem->size;
        7175  --m_FreeCount;
        7176  m_Suballocations.erase(nextItem);
        7177 }
        7178 
        7179 VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
        7180 {
        7181  // Change this suballocation to be marked as free.
        7182  VmaSuballocation& suballoc = *suballocItem;
        7183  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        7184  suballoc.hAllocation = VK_NULL_HANDLE;
        7185 
        7186  // Update totals.
        7187  ++m_FreeCount;
        7188  m_SumFreeSize += suballoc.size;
        7189 
        7190  // Merge with previous and/or next suballocation if it's also free.
        7191  bool mergeWithNext = false;
        7192  bool mergeWithPrev = false;
        7193 
        7194  VmaSuballocationList::iterator nextItem = suballocItem;
        7195  ++nextItem;
        7196  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
        7197  {
        7198  mergeWithNext = true;
        7199  }
        7200 
        7201  VmaSuballocationList::iterator prevItem = suballocItem;
        7202  if(suballocItem != m_Suballocations.begin())
        7203  {
        7204  --prevItem;
        7205  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        7206  {
        7207  mergeWithPrev = true;
        7208  }
        7209  }
        7210 
        7211  if(mergeWithNext)
        7212  {
        7213  UnregisterFreeSuballocation(nextItem);
        7214  MergeFreeWithNext(suballocItem);
        7215  }
        7216 
        7217  if(mergeWithPrev)
        7218  {
        7219  UnregisterFreeSuballocation(prevItem);
        7220  MergeFreeWithNext(prevItem);
        7221  RegisterFreeSuballocation(prevItem);
        7222  return prevItem;
        7223  }
        7224  else
        7225  {
        7226  RegisterFreeSuballocation(suballocItem);
        7227  return suballocItem;
        7228  }
        7229 }
        7230 
        7231 void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
        7232 {
        7233  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        7234  VMA_ASSERT(item->size > 0);
        7235 
        7236  // You may want to enable this validation at the beginning or at the end of
        7237  // this function, depending on what do you want to check.
        7238  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7239 
        7240  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        7241  {
        7242  if(m_FreeSuballocationsBySize.empty())
        7243  {
        7244  m_FreeSuballocationsBySize.push_back(item);
        7245  }
        7246  else
        7247  {
        7248  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
        7249  }
        7250  }
        7251 
        7252  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7253 }
        7254 
        7255 
        7256 void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
        7257 {
        7258  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        7259  VMA_ASSERT(item->size > 0);
        7260 
        7261  // You may want to enable this validation at the beginning or at the end of
        7262  // this function, depending on what do you want to check.
        7263  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7264 
        7265  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        7266  {
        7267  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        7268  m_FreeSuballocationsBySize.data(),
        7269  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        7270  item,
        7271  VmaSuballocationItemSizeLess());
        7272  for(size_t index = it - m_FreeSuballocationsBySize.data();
        7273  index < m_FreeSuballocationsBySize.size();
        7274  ++index)
        7275  {
        7276  if(m_FreeSuballocationsBySize[index] == item)
        7277  {
        7278  VmaVectorRemove(m_FreeSuballocationsBySize, index);
        7279  return;
        7280  }
        7281  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
        7282  }
        7283  VMA_ASSERT(0 && "Not found.");
        7284  }
        7285 
        7286  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7287 }
        7288 
        7290 // class VmaBlockMetadata_Linear
        7291 
        7292 VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
        7293  m_SumFreeSize(0),
        7294  m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        7295  m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        7296  m_1stVectorIndex(0),
        7297  m_2ndVectorMode(SECOND_VECTOR_EMPTY),
        7298  m_1stNullItemsBeginCount(0),
        7299  m_1stNullItemsMiddleCount(0),
        7300  m_2ndNullItemsCount(0)
        7301 {
        7302 }
        7303 
        7304 VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
        7305 {
        7306 }
        7307 
        7308 void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
        7309 {
        7310  VmaBlockMetadata::Init(size);
        7311  m_SumFreeSize = size;
        7312 }
        7313 
        7314 bool VmaBlockMetadata_Linear::Validate() const
        7315 {
        7316  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7317  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7318 
        7319  if(suballocations2nd.empty() != (m_2ndVectorMode == SECOND_VECTOR_EMPTY))
        7320  {
        7321  return false;
        7322  }
        7323  if(suballocations1st.empty() && !suballocations2nd.empty() &&
        7324  m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7325  {
        7326  return false;
        7327  }
        7328  if(!suballocations1st.empty())
        7329  {
        7330  // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
        7331  if(suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        7332  {
        7333  return false;
        7334  }
        7335  // Null item at the end should be just pop_back().
        7336  if(suballocations1st.back().hAllocation == VK_NULL_HANDLE)
        7337  {
        7338  return false;
        7339  }
        7340  }
        7341  if(!suballocations2nd.empty())
        7342  {
        7343  // Null item at the end should be just pop_back().
        7344  if(suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
        7345  {
        7346  return false;
        7347  }
        7348  }
        7349 
        7350  if(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount > suballocations1st.size())
        7351  {
        7352  return false;
        7353  }
        7354  if(m_2ndNullItemsCount > suballocations2nd.size())
        7355  {
        7356  return false;
        7357  }
        7358 
        7359  VkDeviceSize sumUsedSize = 0;
        7360  const size_t suballoc1stCount = suballocations1st.size();
        7361  VkDeviceSize offset = VMA_DEBUG_MARGIN;
        7362 
        7363  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7364  {
        7365  const size_t suballoc2ndCount = suballocations2nd.size();
        7366  size_t nullItem2ndCount = 0;
        7367  for(size_t i = 0; i < suballoc2ndCount; ++i)
        7368  {
        7369  const VmaSuballocation& suballoc = suballocations2nd[i];
        7370  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7371 
        7372  if(currFree != (suballoc.hAllocation == VK_NULL_HANDLE))
        7373  {
        7374  return false;
        7375  }
        7376  if(suballoc.offset < offset)
        7377  {
        7378  return false;
        7379  }
        7380 
        7381  if(!currFree)
        7382  {
        7383  if(suballoc.hAllocation->GetOffset() != suballoc.offset)
        7384  {
        7385  return false;
        7386  }
        7387  if(suballoc.hAllocation->GetSize() != suballoc.size)
        7388  {
        7389  return false;
        7390  }
        7391  sumUsedSize += suballoc.size;
        7392  }
        7393  else
        7394  {
        7395  ++nullItem2ndCount;
        7396  }
        7397 
        7398  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        7399  }
        7400 
        7401  if(nullItem2ndCount != m_2ndNullItemsCount)
        7402  {
        7403  return false;
        7404  }
        7405  }
        7406 
        7407  for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
        7408  {
        7409  const VmaSuballocation& suballoc = suballocations1st[i];
        7410  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE ||
        7411  suballoc.hAllocation != VK_NULL_HANDLE)
        7412  {
        7413  return false;
        7414  }
        7415  }
        7416 
        7417  size_t nullItem1stCount = m_1stNullItemsBeginCount;
        7418 
        7419  for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
        7420  {
        7421  const VmaSuballocation& suballoc = suballocations1st[i];
        7422  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7423 
        7424  if(currFree != (suballoc.hAllocation == VK_NULL_HANDLE))
        7425  {
        7426  return false;
        7427  }
        7428  if(suballoc.offset < offset)
        7429  {
        7430  return false;
        7431  }
        7432  if(i < m_1stNullItemsBeginCount && !currFree)
        7433  {
        7434  return false;
        7435  }
        7436 
        7437  if(!currFree)
        7438  {
        7439  if(suballoc.hAllocation->GetOffset() != suballoc.offset)
        7440  {
        7441  return false;
        7442  }
        7443  if(suballoc.hAllocation->GetSize() != suballoc.size)
        7444  {
        7445  return false;
        7446  }
        7447  sumUsedSize += suballoc.size;
        7448  }
        7449  else
        7450  {
        7451  ++nullItem1stCount;
        7452  }
        7453 
        7454  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        7455  }
        7456  if(nullItem1stCount != m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount)
        7457  {
        7458  return false;
        7459  }
        7460 
        7461  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        7462  {
        7463  const size_t suballoc2ndCount = suballocations2nd.size();
        7464  size_t nullItem2ndCount = 0;
        7465  for(size_t i = suballoc2ndCount; i--; )
        7466  {
        7467  const VmaSuballocation& suballoc = suballocations2nd[i];
        7468  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7469 
        7470  if(currFree != (suballoc.hAllocation == VK_NULL_HANDLE))
        7471  {
        7472  return false;
        7473  }
        7474  if(suballoc.offset < offset)
        7475  {
        7476  return false;
        7477  }
        7478 
        7479  if(!currFree)
        7480  {
        7481  if(suballoc.hAllocation->GetOffset() != suballoc.offset)
        7482  {
        7483  return false;
        7484  }
        7485  if(suballoc.hAllocation->GetSize() != suballoc.size)
        7486  {
        7487  return false;
        7488  }
        7489  sumUsedSize += suballoc.size;
        7490  }
        7491  else
        7492  {
        7493  ++nullItem2ndCount;
        7494  }
        7495 
        7496  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        7497  }
        7498 
        7499  if(nullItem2ndCount != m_2ndNullItemsCount)
        7500  {
        7501  return false;
        7502  }
        7503  }
        7504 
        7505  if(offset > GetSize())
        7506  {
        7507  return false;
        7508  }
        7509  if(m_SumFreeSize != GetSize() - sumUsedSize)
        7510  {
        7511  return false;
        7512  }
        7513 
        7514  return true;
        7515 }
        7516 
        7517 size_t VmaBlockMetadata_Linear::GetAllocationCount() const
        7518 {
        7519  return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
        7520  AccessSuballocations2nd().size() - m_2ndNullItemsCount;
        7521 }
        7522 
        7523 VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
        7524 {
        7525  const VkDeviceSize size = GetSize();
        7526 
        7527  /*
        7528  We don't consider gaps inside allocation vectors with freed allocations because
        7529  they are not suitable for reuse in linear allocator. We consider only space that
        7530  is available for new allocations.
        7531  */
        7532  if(IsEmpty())
        7533  {
        7534  return size;
        7535  }
        7536 
        7537  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7538 
        7539  switch(m_2ndVectorMode)
        7540  {
        7541  case SECOND_VECTOR_EMPTY:
        7542  /*
        7543  Available space is after end of 1st, as well as before beginning of 1st (which
        7544  whould make it a ring buffer).
        7545  */
        7546  {
        7547  const size_t suballocations1stCount = suballocations1st.size();
        7548  VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
        7549  const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        7550  const VmaSuballocation& lastSuballoc = suballocations1st[suballocations1stCount - 1];
        7551  return VMA_MAX(
        7552  firstSuballoc.offset,
        7553  size - (lastSuballoc.offset + lastSuballoc.size));
        7554  }
        7555  break;
        7556 
        7557  case SECOND_VECTOR_RING_BUFFER:
        7558  /*
        7559  Available space is only between end of 2nd and beginning of 1st.
        7560  */
        7561  {
        7562  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7563  const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
        7564  const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
        7565  return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
        7566  }
        7567  break;
        7568 
        7569  case SECOND_VECTOR_DOUBLE_STACK:
        7570  /*
        7571  Available space is only between end of 1st and top of 2nd.
        7572  */
        7573  {
        7574  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7575  const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
        7576  const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
        7577  return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
        7578  }
        7579  break;
        7580 
        7581  default:
        7582  VMA_ASSERT(0);
        7583  return 0;
        7584  }
        7585 }
        7586 
        7587 void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        7588 {
        7589  const VkDeviceSize size = GetSize();
        7590  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7591  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7592  const size_t suballoc1stCount = suballocations1st.size();
        7593  const size_t suballoc2ndCount = suballocations2nd.size();
        7594 
        7595  outInfo.blockCount = 1;
        7596  outInfo.allocationCount = (uint32_t)GetAllocationCount();
        7597  outInfo.unusedRangeCount = 0;
        7598  outInfo.usedBytes = 0;
        7599  outInfo.allocationSizeMin = UINT64_MAX;
        7600  outInfo.allocationSizeMax = 0;
        7601  outInfo.unusedRangeSizeMin = UINT64_MAX;
        7602  outInfo.unusedRangeSizeMax = 0;
        7603 
        7604  VkDeviceSize lastOffset = 0;
        7605 
        7606  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7607  {
        7608  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        7609  size_t nextAlloc2ndIndex = 0;
        7610  while(lastOffset < freeSpace2ndTo1stEnd)
        7611  {
        7612  // Find next non-null allocation or move nextAllocIndex to the end.
        7613  while(nextAlloc2ndIndex < suballoc2ndCount &&
        7614  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7615  {
        7616  ++nextAlloc2ndIndex;
        7617  }
        7618 
        7619  // Found non-null allocation.
        7620  if(nextAlloc2ndIndex < suballoc2ndCount)
        7621  {
        7622  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7623 
        7624  // 1. Process free space before this allocation.
        7625  if(lastOffset < suballoc.offset)
        7626  {
        7627  // There is free space from lastOffset to suballoc.offset.
        7628  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7629  ++outInfo.unusedRangeCount;
        7630  outInfo.unusedBytes += unusedRangeSize;
        7631  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7632  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7633  }
        7634 
        7635  // 2. Process this allocation.
        7636  // There is allocation with suballoc.offset, suballoc.size.
        7637  outInfo.usedBytes += suballoc.size;
        7638  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        7639  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        7640 
        7641  // 3. Prepare for next iteration.
        7642  lastOffset = suballoc.offset + suballoc.size;
        7643  ++nextAlloc2ndIndex;
        7644  }
        7645  // We are at the end.
        7646  else
        7647  {
        7648  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        7649  if(lastOffset < freeSpace2ndTo1stEnd)
        7650  {
        7651  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        7652  ++outInfo.unusedRangeCount;
        7653  outInfo.unusedBytes += unusedRangeSize;
        7654  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7655  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7656  }
        7657 
        7658  // End of loop.
        7659  lastOffset = freeSpace2ndTo1stEnd;
        7660  }
        7661  }
        7662  }
        7663 
        7664  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        7665  const VkDeviceSize freeSpace1stTo2ndEnd =
        7666  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        7667  while(lastOffset < freeSpace1stTo2ndEnd)
        7668  {
        7669  // Find next non-null allocation or move nextAllocIndex to the end.
        7670  while(nextAlloc1stIndex < suballoc1stCount &&
        7671  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        7672  {
        7673  ++nextAlloc1stIndex;
        7674  }
        7675 
        7676  // Found non-null allocation.
        7677  if(nextAlloc1stIndex < suballoc1stCount)
        7678  {
        7679  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        7680 
        7681  // 1. Process free space before this allocation.
        7682  if(lastOffset < suballoc.offset)
        7683  {
        7684  // There is free space from lastOffset to suballoc.offset.
        7685  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7686  ++outInfo.unusedRangeCount;
        7687  outInfo.unusedBytes += unusedRangeSize;
        7688  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7689  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7690  }
        7691 
        7692  // 2. Process this allocation.
        7693  // There is allocation with suballoc.offset, suballoc.size.
        7694  outInfo.usedBytes += suballoc.size;
        7695  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        7696  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        7697 
        7698  // 3. Prepare for next iteration.
        7699  lastOffset = suballoc.offset + suballoc.size;
        7700  ++nextAlloc1stIndex;
        7701  }
        7702  // We are at the end.
        7703  else
        7704  {
        7705  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        7706  if(lastOffset < freeSpace1stTo2ndEnd)
        7707  {
        7708  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        7709  ++outInfo.unusedRangeCount;
        7710  outInfo.unusedBytes += unusedRangeSize;
        7711  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7712  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7713  }
        7714 
        7715  // End of loop.
        7716  lastOffset = freeSpace1stTo2ndEnd;
        7717  }
        7718  }
        7719 
        7720  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        7721  {
        7722  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        7723  while(lastOffset < size)
        7724  {
        7725  // Find next non-null allocation or move nextAllocIndex to the end.
        7726  while(nextAlloc2ndIndex != SIZE_MAX &&
        7727  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7728  {
        7729  --nextAlloc2ndIndex;
        7730  }
        7731 
        7732  // Found non-null allocation.
        7733  if(nextAlloc2ndIndex != SIZE_MAX)
        7734  {
        7735  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7736 
        7737  // 1. Process free space before this allocation.
        7738  if(lastOffset < suballoc.offset)
        7739  {
        7740  // There is free space from lastOffset to suballoc.offset.
        7741  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7742  ++outInfo.unusedRangeCount;
        7743  outInfo.unusedBytes += unusedRangeSize;
        7744  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7745  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7746  }
        7747 
        7748  // 2. Process this allocation.
        7749  // There is allocation with suballoc.offset, suballoc.size.
        7750  outInfo.usedBytes += suballoc.size;
        7751  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        7752  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        7753 
        7754  // 3. Prepare for next iteration.
        7755  lastOffset = suballoc.offset + suballoc.size;
        7756  --nextAlloc2ndIndex;
        7757  }
        7758  // We are at the end.
        7759  else
        7760  {
        7761  // There is free space from lastOffset to size.
        7762  if(lastOffset < size)
        7763  {
        7764  const VkDeviceSize unusedRangeSize = size - lastOffset;
        7765  ++outInfo.unusedRangeCount;
        7766  outInfo.unusedBytes += unusedRangeSize;
        7767  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7768  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7769  }
        7770 
        7771  // End of loop.
        7772  lastOffset = size;
        7773  }
        7774  }
        7775  }
        7776 
        7777  outInfo.unusedBytes = size - outInfo.usedBytes;
        7778 }
        7779 
        7780 void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
        7781 {
        7782  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7783  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7784  const VkDeviceSize size = GetSize();
        7785  const size_t suballoc1stCount = suballocations1st.size();
        7786  const size_t suballoc2ndCount = suballocations2nd.size();
        7787 
        7788  inoutStats.size += size;
        7789 
        7790  VkDeviceSize lastOffset = 0;
        7791 
        7792  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7793  {
        7794  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        7795  size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
        7796  while(lastOffset < freeSpace2ndTo1stEnd)
        7797  {
        7798  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        7799  while(nextAlloc2ndIndex < suballoc2ndCount &&
        7800  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7801  {
        7802  ++nextAlloc2ndIndex;
        7803  }
        7804 
        7805  // Found non-null allocation.
        7806  if(nextAlloc2ndIndex < suballoc2ndCount)
        7807  {
        7808  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7809 
        7810  // 1. Process free space before this allocation.
        7811  if(lastOffset < suballoc.offset)
        7812  {
        7813  // There is free space from lastOffset to suballoc.offset.
        7814  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7815  inoutStats.unusedSize += unusedRangeSize;
        7816  ++inoutStats.unusedRangeCount;
        7817  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7818  }
        7819 
        7820  // 2. Process this allocation.
        7821  // There is allocation with suballoc.offset, suballoc.size.
        7822  ++inoutStats.allocationCount;
        7823 
        7824  // 3. Prepare for next iteration.
        7825  lastOffset = suballoc.offset + suballoc.size;
        7826  ++nextAlloc2ndIndex;
        7827  }
        7828  // We are at the end.
        7829  else
        7830  {
        7831  if(lastOffset < freeSpace2ndTo1stEnd)
        7832  {
        7833  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        7834  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        7835  inoutStats.unusedSize += unusedRangeSize;
        7836  ++inoutStats.unusedRangeCount;
        7837  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7838  }
        7839 
        7840  // End of loop.
        7841  lastOffset = freeSpace2ndTo1stEnd;
        7842  }
        7843  }
        7844  }
        7845 
        7846  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        7847  const VkDeviceSize freeSpace1stTo2ndEnd =
        7848  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        7849  while(lastOffset < freeSpace1stTo2ndEnd)
        7850  {
        7851  // Find next non-null allocation or move nextAllocIndex to the end.
        7852  while(nextAlloc1stIndex < suballoc1stCount &&
        7853  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        7854  {
        7855  ++nextAlloc1stIndex;
        7856  }
        7857 
        7858  // Found non-null allocation.
        7859  if(nextAlloc1stIndex < suballoc1stCount)
        7860  {
        7861  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        7862 
        7863  // 1. Process free space before this allocation.
        7864  if(lastOffset < suballoc.offset)
        7865  {
        7866  // There is free space from lastOffset to suballoc.offset.
        7867  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7868  inoutStats.unusedSize += unusedRangeSize;
        7869  ++inoutStats.unusedRangeCount;
        7870  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7871  }
        7872 
        7873  // 2. Process this allocation.
        7874  // There is allocation with suballoc.offset, suballoc.size.
        7875  ++inoutStats.allocationCount;
        7876 
        7877  // 3. Prepare for next iteration.
        7878  lastOffset = suballoc.offset + suballoc.size;
        7879  ++nextAlloc1stIndex;
        7880  }
        7881  // We are at the end.
        7882  else
        7883  {
        7884  if(lastOffset < freeSpace1stTo2ndEnd)
        7885  {
        7886  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        7887  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        7888  inoutStats.unusedSize += unusedRangeSize;
        7889  ++inoutStats.unusedRangeCount;
        7890  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7891  }
        7892 
        7893  // End of loop.
        7894  lastOffset = freeSpace1stTo2ndEnd;
        7895  }
        7896  }
        7897 
        7898  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        7899  {
        7900  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        7901  while(lastOffset < size)
        7902  {
        7903  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        7904  while(nextAlloc2ndIndex != SIZE_MAX &&
        7905  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7906  {
        7907  --nextAlloc2ndIndex;
        7908  }
        7909 
        7910  // Found non-null allocation.
        7911  if(nextAlloc2ndIndex != SIZE_MAX)
        7912  {
        7913  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7914 
        7915  // 1. Process free space before this allocation.
        7916  if(lastOffset < suballoc.offset)
        7917  {
        7918  // There is free space from lastOffset to suballoc.offset.
        7919  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7920  inoutStats.unusedSize += unusedRangeSize;
        7921  ++inoutStats.unusedRangeCount;
        7922  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7923  }
        7924 
        7925  // 2. Process this allocation.
        7926  // There is allocation with suballoc.offset, suballoc.size.
        7927  ++inoutStats.allocationCount;
        7928 
        7929  // 3. Prepare for next iteration.
        7930  lastOffset = suballoc.offset + suballoc.size;
        7931  --nextAlloc2ndIndex;
        7932  }
        7933  // We are at the end.
        7934  else
        7935  {
        7936  if(lastOffset < size)
        7937  {
        7938  // There is free space from lastOffset to size.
        7939  const VkDeviceSize unusedRangeSize = size - lastOffset;
        7940  inoutStats.unusedSize += unusedRangeSize;
        7941  ++inoutStats.unusedRangeCount;
        7942  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7943  }
        7944 
        7945  // End of loop.
        7946  lastOffset = size;
        7947  }
        7948  }
        7949  }
        7950 }
        7951 
        7952 #if VMA_STATS_STRING_ENABLED
        7953 void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
        7954 {
        7955  const VkDeviceSize size = GetSize();
        7956  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7957  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7958  const size_t suballoc1stCount = suballocations1st.size();
        7959  const size_t suballoc2ndCount = suballocations2nd.size();
        7960 
        7961  // FIRST PASS
        7962 
        7963  size_t unusedRangeCount = 0;
        7964  VkDeviceSize usedBytes = 0;
        7965 
        7966  VkDeviceSize lastOffset = 0;
        7967 
        7968  size_t alloc2ndCount = 0;
        7969  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7970  {
        7971  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        7972  size_t nextAlloc2ndIndex = 0;
        7973  while(lastOffset < freeSpace2ndTo1stEnd)
        7974  {
        7975  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        7976  while(nextAlloc2ndIndex < suballoc2ndCount &&
        7977  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7978  {
        7979  ++nextAlloc2ndIndex;
        7980  }
        7981 
        7982  // Found non-null allocation.
        7983  if(nextAlloc2ndIndex < suballoc2ndCount)
        7984  {
        7985  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7986 
        7987  // 1. Process free space before this allocation.
        7988  if(lastOffset < suballoc.offset)
        7989  {
        7990  // There is free space from lastOffset to suballoc.offset.
        7991  ++unusedRangeCount;
        7992  }
        7993 
        7994  // 2. Process this allocation.
        7995  // There is allocation with suballoc.offset, suballoc.size.
        7996  ++alloc2ndCount;
        7997  usedBytes += suballoc.size;
        7998 
        7999  // 3. Prepare for next iteration.
        8000  lastOffset = suballoc.offset + suballoc.size;
        8001  ++nextAlloc2ndIndex;
        8002  }
        8003  // We are at the end.
        8004  else
        8005  {
        8006  if(lastOffset < freeSpace2ndTo1stEnd)
        8007  {
        8008  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        8009  ++unusedRangeCount;
        8010  }
        8011 
        8012  // End of loop.
        8013  lastOffset = freeSpace2ndTo1stEnd;
        8014  }
        8015  }
        8016  }
        8017 
        8018  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        8019  size_t alloc1stCount = 0;
        8020  const VkDeviceSize freeSpace1stTo2ndEnd =
        8021  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        8022  while(lastOffset < freeSpace1stTo2ndEnd)
        8023  {
        8024  // Find next non-null allocation or move nextAllocIndex to the end.
        8025  while(nextAlloc1stIndex < suballoc1stCount &&
        8026  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        8027  {
        8028  ++nextAlloc1stIndex;
        8029  }
        8030 
        8031  // Found non-null allocation.
        8032  if(nextAlloc1stIndex < suballoc1stCount)
        8033  {
        8034  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        8035 
        8036  // 1. Process free space before this allocation.
        8037  if(lastOffset < suballoc.offset)
        8038  {
        8039  // There is free space from lastOffset to suballoc.offset.
        8040  ++unusedRangeCount;
        8041  }
        8042 
        8043  // 2. Process this allocation.
        8044  // There is allocation with suballoc.offset, suballoc.size.
        8045  ++alloc1stCount;
        8046  usedBytes += suballoc.size;
        8047 
        8048  // 3. Prepare for next iteration.
        8049  lastOffset = suballoc.offset + suballoc.size;
        8050  ++nextAlloc1stIndex;
        8051  }
        8052  // We are at the end.
        8053  else
        8054  {
        8055  if(lastOffset < size)
        8056  {
        8057  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        8058  ++unusedRangeCount;
        8059  }
        8060 
        8061  // End of loop.
        8062  lastOffset = freeSpace1stTo2ndEnd;
        8063  }
        8064  }
        8065 
        8066  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8067  {
        8068  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        8069  while(lastOffset < size)
        8070  {
        8071  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8072  while(nextAlloc2ndIndex != SIZE_MAX &&
        8073  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8074  {
        8075  --nextAlloc2ndIndex;
        8076  }
        8077 
        8078  // Found non-null allocation.
        8079  if(nextAlloc2ndIndex != SIZE_MAX)
        8080  {
        8081  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8082 
        8083  // 1. Process free space before this allocation.
        8084  if(lastOffset < suballoc.offset)
        8085  {
        8086  // There is free space from lastOffset to suballoc.offset.
        8087  ++unusedRangeCount;
        8088  }
        8089 
        8090  // 2. Process this allocation.
        8091  // There is allocation with suballoc.offset, suballoc.size.
        8092  ++alloc2ndCount;
        8093  usedBytes += suballoc.size;
        8094 
        8095  // 3. Prepare for next iteration.
        8096  lastOffset = suballoc.offset + suballoc.size;
        8097  --nextAlloc2ndIndex;
        8098  }
        8099  // We are at the end.
        8100  else
        8101  {
        8102  if(lastOffset < size)
        8103  {
        8104  // There is free space from lastOffset to size.
        8105  ++unusedRangeCount;
        8106  }
        8107 
        8108  // End of loop.
        8109  lastOffset = size;
        8110  }
        8111  }
        8112  }
        8113 
        8114  const VkDeviceSize unusedBytes = size - usedBytes;
        8115  PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
        8116 
        8117  // SECOND PASS
        8118  lastOffset = 0;
        8119 
        8120  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8121  {
        8122  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        8123  size_t nextAlloc2ndIndex = 0;
        8124  while(lastOffset < freeSpace2ndTo1stEnd)
        8125  {
        8126  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8127  while(nextAlloc2ndIndex < suballoc2ndCount &&
        8128  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8129  {
        8130  ++nextAlloc2ndIndex;
        8131  }
        8132 
        8133  // Found non-null allocation.
        8134  if(nextAlloc2ndIndex < suballoc2ndCount)
        8135  {
        8136  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8137 
        8138  // 1. Process free space before this allocation.
        8139  if(lastOffset < suballoc.offset)
        8140  {
        8141  // There is free space from lastOffset to suballoc.offset.
        8142  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        8143  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8144  }
        8145 
        8146  // 2. Process this allocation.
        8147  // There is allocation with suballoc.offset, suballoc.size.
        8148  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        8149 
        8150  // 3. Prepare for next iteration.
        8151  lastOffset = suballoc.offset + suballoc.size;
        8152  ++nextAlloc2ndIndex;
        8153  }
        8154  // We are at the end.
        8155  else
        8156  {
        8157  if(lastOffset < freeSpace2ndTo1stEnd)
        8158  {
        8159  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        8160  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        8161  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8162  }
        8163 
        8164  // End of loop.
        8165  lastOffset = freeSpace2ndTo1stEnd;
        8166  }
        8167  }
        8168  }
        8169 
        8170  nextAlloc1stIndex = m_1stNullItemsBeginCount;
        8171  while(lastOffset < freeSpace1stTo2ndEnd)
        8172  {
        8173  // Find next non-null allocation or move nextAllocIndex to the end.
        8174  while(nextAlloc1stIndex < suballoc1stCount &&
        8175  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        8176  {
        8177  ++nextAlloc1stIndex;
        8178  }
        8179 
        8180  // Found non-null allocation.
        8181  if(nextAlloc1stIndex < suballoc1stCount)
        8182  {
        8183  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        8184 
        8185  // 1. Process free space before this allocation.
        8186  if(lastOffset < suballoc.offset)
        8187  {
        8188  // There is free space from lastOffset to suballoc.offset.
        8189  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        8190  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8191  }
        8192 
        8193  // 2. Process this allocation.
        8194  // There is allocation with suballoc.offset, suballoc.size.
        8195  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        8196 
        8197  // 3. Prepare for next iteration.
        8198  lastOffset = suballoc.offset + suballoc.size;
        8199  ++nextAlloc1stIndex;
        8200  }
        8201  // We are at the end.
        8202  else
        8203  {
        8204  if(lastOffset < freeSpace1stTo2ndEnd)
        8205  {
        8206  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        8207  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        8208  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8209  }
        8210 
        8211  // End of loop.
        8212  lastOffset = freeSpace1stTo2ndEnd;
        8213  }
        8214  }
        8215 
        8216  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8217  {
        8218  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        8219  while(lastOffset < size)
        8220  {
        8221  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8222  while(nextAlloc2ndIndex != SIZE_MAX &&
        8223  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8224  {
        8225  --nextAlloc2ndIndex;
        8226  }
        8227 
        8228  // Found non-null allocation.
        8229  if(nextAlloc2ndIndex != SIZE_MAX)
        8230  {
        8231  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8232 
        8233  // 1. Process free space before this allocation.
        8234  if(lastOffset < suballoc.offset)
        8235  {
        8236  // There is free space from lastOffset to suballoc.offset.
        8237  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        8238  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8239  }
        8240 
        8241  // 2. Process this allocation.
        8242  // There is allocation with suballoc.offset, suballoc.size.
        8243  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        8244 
        8245  // 3. Prepare for next iteration.
        8246  lastOffset = suballoc.offset + suballoc.size;
        8247  --nextAlloc2ndIndex;
        8248  }
        8249  // We are at the end.
        8250  else
        8251  {
        8252  if(lastOffset < size)
        8253  {
        8254  // There is free space from lastOffset to size.
        8255  const VkDeviceSize unusedRangeSize = size - lastOffset;
        8256  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8257  }
        8258 
        8259  // End of loop.
        8260  lastOffset = size;
        8261  }
        8262  }
        8263  }
        8264 
        8265  PrintDetailedMap_End(json);
        8266 }
        8267 #endif // #if VMA_STATS_STRING_ENABLED
        8268 
        8269 bool VmaBlockMetadata_Linear::CreateAllocationRequest(
        8270  uint32_t currentFrameIndex,
        8271  uint32_t frameInUseCount,
        8272  VkDeviceSize bufferImageGranularity,
        8273  VkDeviceSize allocSize,
        8274  VkDeviceSize allocAlignment,
        8275  bool upperAddress,
        8276  VmaSuballocationType allocType,
        8277  bool canMakeOtherLost,
        8278  VmaAllocationRequest* pAllocationRequest)
        8279 {
        8280  VMA_ASSERT(allocSize > 0);
        8281  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        8282  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        8283  VMA_HEAVY_ASSERT(Validate());
        8284 
        8285  const VkDeviceSize size = GetSize();
        8286  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8287  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8288 
        8289  if(upperAddress)
        8290  {
        8291  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8292  {
        8293  VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
        8294  return false;
        8295  }
        8296 
        8297  // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
        8298  if(allocSize > size)
        8299  {
        8300  return false;
        8301  }
        8302  VkDeviceSize resultBaseOffset = size - allocSize;
        8303  if(!suballocations2nd.empty())
        8304  {
        8305  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        8306  resultBaseOffset = lastSuballoc.offset - allocSize;
        8307  if(allocSize > lastSuballoc.offset)
        8308  {
        8309  return false;
        8310  }
        8311  }
        8312 
        8313  // Start from offset equal to end of free space.
        8314  VkDeviceSize resultOffset = resultBaseOffset;
        8315 
        8316  // Apply VMA_DEBUG_MARGIN at the end.
        8317  if(VMA_DEBUG_MARGIN > 0)
        8318  {
        8319  if(resultOffset < VMA_DEBUG_MARGIN)
        8320  {
        8321  return false;
        8322  }
        8323  resultOffset -= VMA_DEBUG_MARGIN;
        8324  }
        8325 
        8326  // Apply alignment.
        8327  resultOffset = VmaAlignDown(resultOffset, allocAlignment);
        8328 
        8329  // Check next suballocations from 2nd for BufferImageGranularity conflicts.
        8330  // Make bigger alignment if necessary.
        8331  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        8332  {
        8333  bool bufferImageGranularityConflict = false;
        8334  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        8335  {
        8336  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        8337  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        8338  {
        8339  if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
        8340  {
        8341  bufferImageGranularityConflict = true;
        8342  break;
        8343  }
        8344  }
        8345  else
        8346  // Already on previous page.
        8347  break;
        8348  }
        8349  if(bufferImageGranularityConflict)
        8350  {
        8351  resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
        8352  }
        8353  }
        8354 
        8355  // There is enough free space.
        8356  const VkDeviceSize endOf1st = !suballocations1st.empty() ?
        8357  suballocations1st.back().offset + suballocations1st.back().size :
        8358  0;
        8359  if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
        8360  {
        8361  // Check previous suballocations for BufferImageGranularity conflicts.
        8362  // If conflict exists, allocation cannot be made here.
        8363  if(bufferImageGranularity > 1)
        8364  {
        8365  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        8366  {
        8367  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        8368  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        8369  {
        8370  if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
        8371  {
        8372  return false;
        8373  }
        8374  }
        8375  else
        8376  {
        8377  // Already on next page.
        8378  break;
        8379  }
        8380  }
        8381  }
        8382 
        8383  // All tests passed: Success.
        8384  pAllocationRequest->offset = resultOffset;
        8385  pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
        8386  pAllocationRequest->sumItemSize = 0;
        8387  // pAllocationRequest->item unused.
        8388  pAllocationRequest->itemsToMakeLostCount = 0;
        8389  return true;
        8390  }
        8391  }
        8392  else // !upperAddress
        8393  {
        8394  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8395  {
        8396  // Try to allocate at the end of 1st vector.
        8397 
        8398  VkDeviceSize resultBaseOffset = 0;
        8399  if(!suballocations1st.empty())
        8400  {
        8401  const VmaSuballocation& lastSuballoc = suballocations1st.back();
        8402  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        8403  }
        8404 
        8405  // Start from offset equal to beginning of free space.
        8406  VkDeviceSize resultOffset = resultBaseOffset;
        8407 
        8408  // Apply VMA_DEBUG_MARGIN at the beginning.
        8409  if(VMA_DEBUG_MARGIN > 0)
        8410  {
        8411  resultOffset += VMA_DEBUG_MARGIN;
        8412  }
        8413 
        8414  // Apply alignment.
        8415  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        8416 
        8417  // Check previous suballocations for BufferImageGranularity conflicts.
        8418  // Make bigger alignment if necessary.
        8419  if(bufferImageGranularity > 1 && !suballocations1st.empty())
        8420  {
        8421  bool bufferImageGranularityConflict = false;
        8422  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        8423  {
        8424  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        8425  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        8426  {
        8427  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        8428  {
        8429  bufferImageGranularityConflict = true;
        8430  break;
        8431  }
        8432  }
        8433  else
        8434  // Already on previous page.
        8435  break;
        8436  }
        8437  if(bufferImageGranularityConflict)
        8438  {
        8439  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        8440  }
        8441  }
        8442 
        8443  const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
        8444  suballocations2nd.back().offset : size;
        8445 
        8446  // There is enough free space at the end after alignment.
        8447  if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
        8448  {
        8449  // Check next suballocations for BufferImageGranularity conflicts.
        8450  // If conflict exists, allocation cannot be made here.
        8451  if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8452  {
        8453  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        8454  {
        8455  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        8456  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        8457  {
        8458  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        8459  {
        8460  return false;
        8461  }
        8462  }
        8463  else
        8464  {
        8465  // Already on previous page.
        8466  break;
        8467  }
        8468  }
        8469  }
        8470 
        8471  // All tests passed: Success.
        8472  pAllocationRequest->offset = resultOffset;
        8473  pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
        8474  pAllocationRequest->sumItemSize = 0;
        8475  // pAllocationRequest->item unused.
        8476  pAllocationRequest->itemsToMakeLostCount = 0;
        8477  return true;
        8478  }
        8479  }
        8480 
        8481  // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
        8482  // beginning of 1st vector as the end of free space.
        8483  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8484  {
        8485  VMA_ASSERT(!suballocations1st.empty());
        8486 
        8487  VkDeviceSize resultBaseOffset = 0;
        8488  if(!suballocations2nd.empty())
        8489  {
        8490  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        8491  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        8492  }
        8493 
        8494  // Start from offset equal to beginning of free space.
        8495  VkDeviceSize resultOffset = resultBaseOffset;
        8496 
        8497  // Apply VMA_DEBUG_MARGIN at the beginning.
        8498  if(VMA_DEBUG_MARGIN > 0)
        8499  {
        8500  resultOffset += VMA_DEBUG_MARGIN;
        8501  }
        8502 
        8503  // Apply alignment.
        8504  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        8505 
        8506  // Check previous suballocations for BufferImageGranularity conflicts.
        8507  // Make bigger alignment if necessary.
        8508  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        8509  {
        8510  bool bufferImageGranularityConflict = false;
        8511  for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
        8512  {
        8513  const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
        8514  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        8515  {
        8516  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        8517  {
        8518  bufferImageGranularityConflict = true;
        8519  break;
        8520  }
        8521  }
        8522  else
        8523  // Already on previous page.
        8524  break;
        8525  }
        8526  if(bufferImageGranularityConflict)
        8527  {
        8528  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        8529  }
        8530  }
        8531 
        8532  pAllocationRequest->itemsToMakeLostCount = 0;
        8533  pAllocationRequest->sumItemSize = 0;
        8534  size_t index1st = m_1stNullItemsBeginCount;
        8535 
        8536  if(canMakeOtherLost)
        8537  {
        8538  while(index1st < suballocations1st.size() &&
        8539  resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
        8540  {
        8541  // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
        8542  const VmaSuballocation& suballoc = suballocations1st[index1st];
        8543  if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
        8544  {
        8545  // No problem.
        8546  }
        8547  else
        8548  {
        8549  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        8550  if(suballoc.hAllocation->CanBecomeLost() &&
        8551  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        8552  {
        8553  ++pAllocationRequest->itemsToMakeLostCount;
        8554  pAllocationRequest->sumItemSize += suballoc.size;
        8555  }
        8556  else
        8557  {
        8558  return false;
        8559  }
        8560  }
        8561  ++index1st;
        8562  }
        8563 
        8564  // Check next suballocations for BufferImageGranularity conflicts.
        8565  // If conflict exists, we must mark more allocations lost or fail.
        8566  if(bufferImageGranularity > 1)
        8567  {
        8568  while(index1st < suballocations1st.size())
        8569  {
        8570  const VmaSuballocation& suballoc = suballocations1st[index1st];
        8571  if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
        8572  {
        8573  if(suballoc.hAllocation != VK_NULL_HANDLE)
        8574  {
        8575  // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
        8576  if(suballoc.hAllocation->CanBecomeLost() &&
        8577  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        8578  {
        8579  ++pAllocationRequest->itemsToMakeLostCount;
        8580  pAllocationRequest->sumItemSize += suballoc.size;
        8581  }
        8582  else
        8583  {
        8584  return false;
        8585  }
        8586  }
        8587  }
        8588  else
        8589  {
        8590  // Already on next page.
        8591  break;
        8592  }
        8593  ++index1st;
        8594  }
        8595  }
        8596  }
        8597 
        8598  // There is enough free space at the end after alignment.
        8599  if(index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN < size ||
        8600  index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset)
        8601  {
        8602  // Check next suballocations for BufferImageGranularity conflicts.
        8603  // If conflict exists, allocation cannot be made here.
        8604  if(bufferImageGranularity > 1)
        8605  {
        8606  for(size_t nextSuballocIndex = index1st;
        8607  nextSuballocIndex < suballocations1st.size();
        8608  nextSuballocIndex++)
        8609  {
        8610  const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
        8611  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        8612  {
        8613  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        8614  {
        8615  return false;
        8616  }
        8617  }
        8618  else
        8619  {
        8620  // Already on next page.
        8621  break;
        8622  }
        8623  }
        8624  }
        8625 
        8626  // All tests passed: Success.
        8627  pAllocationRequest->offset = resultOffset;
        8628  pAllocationRequest->sumFreeSize =
        8629  (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
        8630  - resultBaseOffset
        8631  - pAllocationRequest->sumItemSize;
        8632  // pAllocationRequest->item unused.
        8633  return true;
        8634  }
        8635  }
        8636  }
        8637 
        8638  return false;
        8639 }
        8640 
        8641 bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
        8642  uint32_t currentFrameIndex,
        8643  uint32_t frameInUseCount,
        8644  VmaAllocationRequest* pAllocationRequest)
        8645 {
        8646  if(pAllocationRequest->itemsToMakeLostCount == 0)
        8647  {
        8648  return true;
        8649  }
        8650 
        8651  VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
        8652 
        8653  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8654  size_t index1st = m_1stNullItemsBeginCount;
        8655  size_t madeLostCount = 0;
        8656  while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
        8657  {
        8658  VMA_ASSERT(index1st < suballocations1st.size());
        8659  VmaSuballocation& suballoc = suballocations1st[index1st];
        8660  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        8661  {
        8662  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        8663  VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
        8664  if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        8665  {
        8666  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8667  suballoc.hAllocation = VK_NULL_HANDLE;
        8668  m_SumFreeSize += suballoc.size;
        8669  ++m_1stNullItemsMiddleCount;
        8670  ++madeLostCount;
        8671  }
        8672  else
        8673  {
        8674  return false;
        8675  }
        8676  }
        8677  ++index1st;
        8678  }
        8679 
        8680  CleanupAfterFree();
        8681  //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
        8682 
        8683  return true;
        8684 }
        8685 
        8686 uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        8687 {
        8688  uint32_t lostAllocationCount = 0;
        8689 
        8690  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8691  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        8692  {
        8693  VmaSuballocation& suballoc = suballocations1st[i];
        8694  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        8695  suballoc.hAllocation->CanBecomeLost() &&
        8696  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        8697  {
        8698  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8699  suballoc.hAllocation = VK_NULL_HANDLE;
        8700  ++m_1stNullItemsMiddleCount;
        8701  m_SumFreeSize += suballoc.size;
        8702  ++lostAllocationCount;
        8703  }
        8704  }
        8705 
        8706  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8707  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        8708  {
        8709  VmaSuballocation& suballoc = suballocations2nd[i];
        8710  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        8711  suballoc.hAllocation->CanBecomeLost() &&
        8712  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        8713  {
        8714  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8715  suballoc.hAllocation = VK_NULL_HANDLE;
        8716  ++m_2ndNullItemsCount;
        8717  ++lostAllocationCount;
        8718  }
        8719  }
        8720 
        8721  if(lostAllocationCount)
        8722  {
        8723  CleanupAfterFree();
        8724  }
        8725 
        8726  return lostAllocationCount;
        8727 }
        8728 
        8729 VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
        8730 {
        8731  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8732  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        8733  {
        8734  const VmaSuballocation& suballoc = suballocations1st[i];
        8735  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        8736  {
        8737  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        8738  {
        8739  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        8740  return VK_ERROR_VALIDATION_FAILED_EXT;
        8741  }
        8742  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        8743  {
        8744  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        8745  return VK_ERROR_VALIDATION_FAILED_EXT;
        8746  }
        8747  }
        8748  }
        8749 
        8750  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8751  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        8752  {
        8753  const VmaSuballocation& suballoc = suballocations2nd[i];
        8754  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        8755  {
        8756  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        8757  {
        8758  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        8759  return VK_ERROR_VALIDATION_FAILED_EXT;
        8760  }
        8761  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        8762  {
        8763  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        8764  return VK_ERROR_VALIDATION_FAILED_EXT;
        8765  }
        8766  }
        8767  }
        8768 
        8769  return VK_SUCCESS;
        8770 }
        8771 
        8772 void VmaBlockMetadata_Linear::Alloc(
        8773  const VmaAllocationRequest& request,
        8774  VmaSuballocationType type,
        8775  VkDeviceSize allocSize,
        8776  bool upperAddress,
        8777  VmaAllocation hAllocation)
        8778 {
        8779  const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
        8780 
        8781  if(upperAddress)
        8782  {
        8783  VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
        8784  "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
        8785  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8786  suballocations2nd.push_back(newSuballoc);
        8787  m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
        8788  }
        8789  else
        8790  {
        8791  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8792 
        8793  // First allocation.
        8794  if(suballocations1st.empty())
        8795  {
        8796  suballocations1st.push_back(newSuballoc);
        8797  }
        8798  else
        8799  {
        8800  // New allocation at the end of 1st vector.
        8801  if(request.offset >= suballocations1st.back().offset + suballocations1st.back().size)
        8802  {
        8803  // Check if it fits before the end of the block.
        8804  VMA_ASSERT(request.offset + allocSize <= GetSize());
        8805  suballocations1st.push_back(newSuballoc);
        8806  }
        8807  // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
        8808  else if(request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset)
        8809  {
        8810  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8811 
        8812  switch(m_2ndVectorMode)
        8813  {
        8814  case SECOND_VECTOR_EMPTY:
        8815  // First allocation from second part ring buffer.
        8816  VMA_ASSERT(suballocations2nd.empty());
        8817  m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
        8818  break;
        8819  case SECOND_VECTOR_RING_BUFFER:
        8820  // 2-part ring buffer is already started.
        8821  VMA_ASSERT(!suballocations2nd.empty());
        8822  break;
        8823  case SECOND_VECTOR_DOUBLE_STACK:
        8824  VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
        8825  break;
        8826  default:
        8827  VMA_ASSERT(0);
        8828  }
        8829 
        8830  suballocations2nd.push_back(newSuballoc);
        8831  }
        8832  else
        8833  {
        8834  VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
        8835  }
        8836  }
        8837  }
        8838 
        8839  m_SumFreeSize -= newSuballoc.size;
        8840 }
        8841 
        8842 void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
        8843 {
        8844  FreeAtOffset(allocation->GetOffset());
        8845 }
        8846 
        8847 void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
        8848 {
        8849  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8850  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8851 
        8852  if(!suballocations1st.empty())
        8853  {
        8854  // First allocation: Mark it as next empty at the beginning.
        8855  VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        8856  if(firstSuballoc.offset == offset)
        8857  {
        8858  firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8859  firstSuballoc.hAllocation = VK_NULL_HANDLE;
        8860  m_SumFreeSize += firstSuballoc.size;
        8861  ++m_1stNullItemsBeginCount;
        8862  CleanupAfterFree();
        8863  return;
        8864  }
        8865  }
        8866 
        8867  // Last allocation in 2-part ring buffer or top of upper stack (same logic).
        8868  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
        8869  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8870  {
        8871  VmaSuballocation& lastSuballoc = suballocations2nd.back();
        8872  if(lastSuballoc.offset == offset)
        8873  {
        8874  m_SumFreeSize += lastSuballoc.size;
        8875  suballocations2nd.pop_back();
        8876  CleanupAfterFree();
        8877  return;
        8878  }
        8879  }
        8880  // Last allocation in 1st vector.
        8881  else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
        8882  {
        8883  VmaSuballocation& lastSuballoc = suballocations1st.back();
        8884  if(lastSuballoc.offset == offset)
        8885  {
        8886  m_SumFreeSize += lastSuballoc.size;
        8887  suballocations1st.pop_back();
        8888  CleanupAfterFree();
        8889  return;
        8890  }
        8891  }
        8892 
        8893  // Item from the middle of 1st vector.
        8894  {
        8895  VmaSuballocation refSuballoc;
        8896  refSuballoc.offset = offset;
        8897  // Rest of members stays uninitialized intentionally for better performance.
        8898  SuballocationVectorType::iterator it = VmaVectorFindSorted<VmaSuballocationOffsetLess>(
        8899  suballocations1st.begin() + m_1stNullItemsBeginCount,
        8900  suballocations1st.end(),
        8901  refSuballoc);
        8902  if(it != suballocations1st.end())
        8903  {
        8904  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        8905  it->hAllocation = VK_NULL_HANDLE;
        8906  ++m_1stNullItemsMiddleCount;
        8907  m_SumFreeSize += it->size;
        8908  CleanupAfterFree();
        8909  return;
        8910  }
        8911  }
        8912 
        8913  if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
        8914  {
        8915  // Item from the middle of 2nd vector.
        8916  VmaSuballocation refSuballoc;
        8917  refSuballoc.offset = offset;
        8918  // Rest of members stays uninitialized intentionally for better performance.
        8919  SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
        8920  VmaVectorFindSorted<VmaSuballocationOffsetLess>(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc) :
        8921  VmaVectorFindSorted<VmaSuballocationOffsetGreater>(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc);
        8922  if(it != suballocations2nd.end())
        8923  {
        8924  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        8925  it->hAllocation = VK_NULL_HANDLE;
        8926  ++m_2ndNullItemsCount;
        8927  m_SumFreeSize += it->size;
        8928  CleanupAfterFree();
        8929  return;
        8930  }
        8931  }
        8932 
        8933  VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
        8934 }
        8935 
        8936 bool VmaBlockMetadata_Linear::ShouldCompact1st() const
        8937 {
        8938  const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        8939  const size_t suballocCount = AccessSuballocations1st().size();
        8940  return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
        8941 }
        8942 
        8943 void VmaBlockMetadata_Linear::CleanupAfterFree()
        8944 {
        8945  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8946  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8947 
        8948  if(IsEmpty())
        8949  {
        8950  suballocations1st.clear();
        8951  suballocations2nd.clear();
        8952  m_1stNullItemsBeginCount = 0;
        8953  m_1stNullItemsMiddleCount = 0;
        8954  m_2ndNullItemsCount = 0;
        8955  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        8956  }
        8957  else
        8958  {
        8959  const size_t suballoc1stCount = suballocations1st.size();
        8960  const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        8961  VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
        8962 
        8963  // Find more null items at the beginning of 1st vector.
        8964  while(m_1stNullItemsBeginCount < suballoc1stCount &&
        8965  suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        8966  {
        8967  ++m_1stNullItemsBeginCount;
        8968  --m_1stNullItemsMiddleCount;
        8969  }
        8970 
        8971  // Find more null items at the end of 1st vector.
        8972  while(m_1stNullItemsMiddleCount > 0 &&
        8973  suballocations1st.back().hAllocation == VK_NULL_HANDLE)
        8974  {
        8975  --m_1stNullItemsMiddleCount;
        8976  suballocations1st.pop_back();
        8977  }
        8978 
        8979  // Find more null items at the end of 2nd vector.
        8980  while(m_2ndNullItemsCount > 0 &&
        8981  suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
        8982  {
        8983  --m_2ndNullItemsCount;
        8984  suballocations2nd.pop_back();
        8985  }
        8986 
        8987  if(ShouldCompact1st())
        8988  {
        8989  const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
        8990  size_t srcIndex = m_1stNullItemsBeginCount;
        8991  for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
        8992  {
        8993  while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
        8994  {
        8995  ++srcIndex;
        8996  }
        8997  if(dstIndex != srcIndex)
        8998  {
        8999  suballocations1st[dstIndex] = suballocations1st[srcIndex];
        9000  }
        9001  ++srcIndex;
        9002  }
        9003  suballocations1st.resize(nonNullItemCount);
        9004  m_1stNullItemsBeginCount = 0;
        9005  m_1stNullItemsMiddleCount = 0;
        9006  }
        9007 
        9008  // 2nd vector became empty.
        9009  if(suballocations2nd.empty())
        9010  {
        9011  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        9012  }
        9013 
        9014  // 1st vector became empty.
        9015  if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
        9016  {
        9017  suballocations1st.clear();
        9018  m_1stNullItemsBeginCount = 0;
        9019 
        9020  if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        9021  {
        9022  // Swap 1st with 2nd. Now 2nd is empty.
        9023  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        9024  m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
        9025  while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
        9026  suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        9027  {
        9028  ++m_1stNullItemsBeginCount;
        9029  --m_1stNullItemsMiddleCount;
        9030  }
        9031  m_2ndNullItemsCount = 0;
        9032  m_1stVectorIndex ^= 1;
        9033  }
        9034  }
        9035  }
        9036 
        9037  VMA_HEAVY_ASSERT(Validate());
        9038 }
        9039 
        9040 
        9042 // class VmaDeviceMemoryBlock
        9043 
        9044 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
        9045  m_pMetadata(VMA_NULL),
        9046  m_MemoryTypeIndex(UINT32_MAX),
        9047  m_Id(0),
        9048  m_hMemory(VK_NULL_HANDLE),
        9049  m_MapCount(0),
        9050  m_pMappedData(VMA_NULL)
        9051 {
        9052 }
        9053 
        9054 void VmaDeviceMemoryBlock::Init(
        9055  VmaAllocator hAllocator,
        9056  uint32_t newMemoryTypeIndex,
        9057  VkDeviceMemory newMemory,
        9058  VkDeviceSize newSize,
        9059  uint32_t id,
        9060  bool linearAlgorithm)
        9061 {
        9062  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        9063 
        9064  m_MemoryTypeIndex = newMemoryTypeIndex;
        9065  m_Id = id;
        9066  m_hMemory = newMemory;
        9067 
        9068  if(linearAlgorithm)
        9069  {
        9070  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
        9071  }
        9072  else
        9073  {
        9074  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
        9075  }
        9076  m_pMetadata->Init(newSize);
        9077 }
        9078 
        9079 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
        9080 {
        9081  // This is the most important assert in the entire library.
        9082  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
        9083  VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
        9084 
        9085  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
        9086  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
        9087  m_hMemory = VK_NULL_HANDLE;
        9088 
        9089  vma_delete(allocator, m_pMetadata);
        9090  m_pMetadata = VMA_NULL;
        9091 }
        9092 
        9093 bool VmaDeviceMemoryBlock::Validate() const
        9094 {
        9095  if((m_hMemory == VK_NULL_HANDLE) ||
        9096  (m_pMetadata->GetSize() == 0))
        9097  {
        9098  return false;
        9099  }
        9100 
        9101  return m_pMetadata->Validate();
        9102 }
        9103 
        9104 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
        9105 {
        9106  void* pData = nullptr;
        9107  VkResult res = Map(hAllocator, 1, &pData);
        9108  if(res != VK_SUCCESS)
        9109  {
        9110  return res;
        9111  }
        9112 
        9113  res = m_pMetadata->CheckCorruption(pData);
        9114 
        9115  Unmap(hAllocator, 1);
        9116 
        9117  return res;
        9118 }
        9119 
        9120 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
        9121 {
        9122  if(count == 0)
        9123  {
        9124  return VK_SUCCESS;
        9125  }
        9126 
        9127  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9128  if(m_MapCount != 0)
        9129  {
        9130  m_MapCount += count;
        9131  VMA_ASSERT(m_pMappedData != VMA_NULL);
        9132  if(ppData != VMA_NULL)
        9133  {
        9134  *ppData = m_pMappedData;
        9135  }
        9136  return VK_SUCCESS;
        9137  }
        9138  else
        9139  {
        9140  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        9141  hAllocator->m_hDevice,
        9142  m_hMemory,
        9143  0, // offset
        9144  VK_WHOLE_SIZE,
        9145  0, // flags
        9146  &m_pMappedData);
        9147  if(result == VK_SUCCESS)
        9148  {
        9149  if(ppData != VMA_NULL)
        9150  {
        9151  *ppData = m_pMappedData;
        9152  }
        9153  m_MapCount = count;
        9154  }
        9155  return result;
        9156  }
        9157 }
        9158 
        9159 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
        9160 {
        9161  if(count == 0)
        9162  {
        9163  return;
        9164  }
        9165 
        9166  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9167  if(m_MapCount >= count)
        9168  {
        9169  m_MapCount -= count;
        9170  if(m_MapCount == 0)
        9171  {
        9172  m_pMappedData = VMA_NULL;
        9173  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
        9174  }
        9175  }
        9176  else
        9177  {
        9178  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
        9179  }
        9180 }
        9181 
        9182 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        9183 {
        9184  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        9185  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        9186 
        9187  void* pData;
        9188  VkResult res = Map(hAllocator, 1, &pData);
        9189  if(res != VK_SUCCESS)
        9190  {
        9191  return res;
        9192  }
        9193 
        9194  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
        9195  VmaWriteMagicValue(pData, allocOffset + allocSize);
        9196 
        9197  Unmap(hAllocator, 1);
        9198 
        9199  return VK_SUCCESS;
        9200 }
        9201 
        9202 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        9203 {
        9204  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        9205  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        9206 
        9207  void* pData;
        9208  VkResult res = Map(hAllocator, 1, &pData);
        9209  if(res != VK_SUCCESS)
        9210  {
        9211  return res;
        9212  }
        9213 
        9214  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
        9215  {
        9216  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
        9217  }
        9218  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
        9219  {
        9220  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
        9221  }
        9222 
        9223  Unmap(hAllocator, 1);
        9224 
        9225  return VK_SUCCESS;
        9226 }
        9227 
        9228 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
        9229  const VmaAllocator hAllocator,
        9230  const VmaAllocation hAllocation,
        9231  VkBuffer hBuffer)
        9232 {
        9233  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        9234  hAllocation->GetBlock() == this);
        9235  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        9236  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9237  return hAllocator->GetVulkanFunctions().vkBindBufferMemory(
        9238  hAllocator->m_hDevice,
        9239  hBuffer,
        9240  m_hMemory,
        9241  hAllocation->GetOffset());
        9242 }
        9243 
        9244 VkResult VmaDeviceMemoryBlock::BindImageMemory(
        9245  const VmaAllocator hAllocator,
        9246  const VmaAllocation hAllocation,
        9247  VkImage hImage)
        9248 {
        9249  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        9250  hAllocation->GetBlock() == this);
        9251  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        9252  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9253  return hAllocator->GetVulkanFunctions().vkBindImageMemory(
        9254  hAllocator->m_hDevice,
        9255  hImage,
        9256  m_hMemory,
        9257  hAllocation->GetOffset());
        9258 }
        9259 
        9260 static void InitStatInfo(VmaStatInfo& outInfo)
        9261 {
        9262  memset(&outInfo, 0, sizeof(outInfo));
        9263  outInfo.allocationSizeMin = UINT64_MAX;
        9264  outInfo.unusedRangeSizeMin = UINT64_MAX;
        9265 }
        9266 
        9267 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
        9268 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
        9269 {
        9270  inoutInfo.blockCount += srcInfo.blockCount;
        9271  inoutInfo.allocationCount += srcInfo.allocationCount;
        9272  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
        9273  inoutInfo.usedBytes += srcInfo.usedBytes;
        9274  inoutInfo.unusedBytes += srcInfo.unusedBytes;
        9275  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
        9276  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
        9277  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
        9278  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
        9279 }
        9280 
        9281 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
        9282 {
        9283  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
        9284  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
        9285  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
        9286  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
        9287 }
        9288 
        9289 VmaPool_T::VmaPool_T(
        9290  VmaAllocator hAllocator,
        9291  const VmaPoolCreateInfo& createInfo) :
        9292  m_BlockVector(
        9293  hAllocator,
        9294  createInfo.memoryTypeIndex,
        9295  createInfo.blockSize,
        9296  createInfo.minBlockCount,
        9297  createInfo.maxBlockCount,
        9298  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        9299  createInfo.frameInUseCount,
        9300  true, // isCustomPool
        9301  (createInfo.flags & VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) != 0), // linearAlgorithm
        9302  m_Id(0)
        9303 {
        9304 }
        9305 
        9306 VmaPool_T::~VmaPool_T()
        9307 {
        9308 }
        9309 
        9310 #if VMA_STATS_STRING_ENABLED
        9311 
        9312 #endif // #if VMA_STATS_STRING_ENABLED
        9313 
        9314 VmaBlockVector::VmaBlockVector(
        9315  VmaAllocator hAllocator,
        9316  uint32_t memoryTypeIndex,
        9317  VkDeviceSize preferredBlockSize,
        9318  size_t minBlockCount,
        9319  size_t maxBlockCount,
        9320  VkDeviceSize bufferImageGranularity,
        9321  uint32_t frameInUseCount,
        9322  bool isCustomPool,
        9323  bool linearAlgorithm) :
        9324  m_hAllocator(hAllocator),
        9325  m_MemoryTypeIndex(memoryTypeIndex),
        9326  m_PreferredBlockSize(preferredBlockSize),
        9327  m_MinBlockCount(minBlockCount),
        9328  m_MaxBlockCount(maxBlockCount),
        9329  m_BufferImageGranularity(bufferImageGranularity),
        9330  m_FrameInUseCount(frameInUseCount),
        9331  m_IsCustomPool(isCustomPool),
        9332  m_LinearAlgorithm(linearAlgorithm),
        9333  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
        9334  m_HasEmptyBlock(false),
        9335  m_pDefragmentator(VMA_NULL),
        9336  m_NextBlockId(0)
        9337 {
        9338 }
        9339 
        9340 VmaBlockVector::~VmaBlockVector()
        9341 {
        9342  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
        9343 
        9344  for(size_t i = m_Blocks.size(); i--; )
        9345  {
        9346  m_Blocks[i]->Destroy(m_hAllocator);
        9347  vma_delete(m_hAllocator, m_Blocks[i]);
        9348  }
        9349 }
        9350 
        9351 VkResult VmaBlockVector::CreateMinBlocks()
        9352 {
        9353  for(size_t i = 0; i < m_MinBlockCount; ++i)
        9354  {
        9355  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        9356  if(res != VK_SUCCESS)
        9357  {
        9358  return res;
        9359  }
        9360  }
        9361  return VK_SUCCESS;
        9362 }
        9363 
        9364 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
        9365 {
        9366  pStats->size = 0;
        9367  pStats->unusedSize = 0;
        9368  pStats->allocationCount = 0;
        9369  pStats->unusedRangeCount = 0;
        9370  pStats->unusedRangeSizeMax = 0;
        9371 
        9372  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9373 
        9374  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        9375  {
        9376  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        9377  VMA_ASSERT(pBlock);
        9378  VMA_HEAVY_ASSERT(pBlock->Validate());
        9379  pBlock->m_pMetadata->AddPoolStats(*pStats);
        9380  }
        9381 }
        9382 
        9383 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
        9384 {
        9385  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        9386  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
        9387  (VMA_DEBUG_MARGIN > 0) &&
        9388  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
        9389 }
        9390 
        9391 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
        9392 
        9393 VkResult VmaBlockVector::Allocate(
        9394  VmaPool hCurrentPool,
        9395  uint32_t currentFrameIndex,
        9396  VkDeviceSize size,
        9397  VkDeviceSize alignment,
        9398  const VmaAllocationCreateInfo& createInfo,
        9399  VmaSuballocationType suballocType,
        9400  VmaAllocation* pAllocation)
        9401 {
        9402  const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        9403  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
        9404  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        9405  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        9406  const bool canCreateNewBlock =
        9407  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        9408  (m_Blocks.size() < m_MaxBlockCount);
        9409 
        9410  // Upper address can only be used with linear allocator.
        9411  if(isUpperAddress && !m_LinearAlgorithm)
        9412  {
        9413  return VK_ERROR_FEATURE_NOT_PRESENT;
        9414  }
        9415 
        9416  // Early reject: requested allocation size is larger that maximum block size for this block vector.
        9417  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
        9418  {
        9419  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9420  }
        9421 
        9422  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9423 
        9424  /*
        9425  Under certain condition, this whole section can be skipped for optimization, so
        9426  we move on directly to trying to allocate with canMakeOtherLost. That's the case
        9427  e.g. for custom pools with linear algorithm.
        9428  */
        9429  if(!canMakeOtherLost || canCreateNewBlock)
        9430  {
        9431  // 1. Search existing allocations. Try to allocate without making other allocations lost.
        9432  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        9433  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        9434  {
        9435  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        9436  VMA_ASSERT(pCurrBlock);
        9437  VmaAllocationRequest currRequest = {};
        9438  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        9439  currentFrameIndex,
        9440  m_FrameInUseCount,
        9441  m_BufferImageGranularity,
        9442  size,
        9443  alignment,
        9444  isUpperAddress,
        9445  suballocType,
        9446  false, // canMakeOtherLost
        9447  &currRequest))
        9448  {
        9449  // Allocate from pCurrBlock.
        9450  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
        9451 
        9452  if(mapped)
        9453  {
        9454  VkResult res = pCurrBlock->Map(m_hAllocator, 1, VMA_NULL);
        9455  if(res != VK_SUCCESS)
        9456  {
        9457  return res;
        9458  }
        9459  }
        9460 
        9461  // We no longer have an empty Allocation.
        9462  if(pCurrBlock->m_pMetadata->IsEmpty())
        9463  {
        9464  m_HasEmptyBlock = false;
        9465  }
        9466 
        9467  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
        9468  pCurrBlock->m_pMetadata->Alloc(currRequest, suballocType, size, isUpperAddress, *pAllocation);
        9469  (*pAllocation)->InitBlockAllocation(
        9470  hCurrentPool,
        9471  pCurrBlock,
        9472  currRequest.offset,
        9473  alignment,
        9474  size,
        9475  suballocType,
        9476  mapped,
        9477  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        9478  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
        9479  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        9480  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
        9481  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        9482  {
        9483  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        9484  }
        9485  if(IsCorruptionDetectionEnabled())
        9486  {
        9487  VkResult res = pCurrBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
        9488  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        9489  }
        9490  return VK_SUCCESS;
        9491  }
        9492  }
        9493 
        9494  // 2. Try to create new block.
        9495  if(canCreateNewBlock)
        9496  {
        9497  // Calculate optimal size for new block.
        9498  VkDeviceSize newBlockSize = m_PreferredBlockSize;
        9499  uint32_t newBlockSizeShift = 0;
        9500  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
        9501 
        9502  // Allocating blocks of other sizes is allowed only in default pools.
        9503  // In custom pools block size is fixed.
        9504  if(m_IsCustomPool == false)
        9505  {
        9506  // Allocate 1/8, 1/4, 1/2 as first blocks.
        9507  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
        9508  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
        9509  {
        9510  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        9511  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
        9512  {
        9513  newBlockSize = smallerNewBlockSize;
        9514  ++newBlockSizeShift;
        9515  }
        9516  else
        9517  {
        9518  break;
        9519  }
        9520  }
        9521  }
        9522 
        9523  size_t newBlockIndex = 0;
        9524  VkResult res = CreateBlock(newBlockSize, &newBlockIndex);
        9525  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
        9526  if(m_IsCustomPool == false)
        9527  {
        9528  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
        9529  {
        9530  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        9531  if(smallerNewBlockSize >= size)
        9532  {
        9533  newBlockSize = smallerNewBlockSize;
        9534  ++newBlockSizeShift;
        9535  res = CreateBlock(newBlockSize, &newBlockIndex);
        9536  }
        9537  else
        9538  {
        9539  break;
        9540  }
        9541  }
        9542  }
        9543 
        9544  if(res == VK_SUCCESS)
        9545  {
        9546  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
        9547  VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
        9548 
        9549  if(mapped)
        9550  {
        9551  res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
        9552  if(res != VK_SUCCESS)
        9553  {
        9554  return res;
        9555  }
        9556  }
        9557 
        9558  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
        9559  VmaAllocationRequest allocRequest;
        9560  if(pBlock->m_pMetadata->CreateAllocationRequest(
        9561  currentFrameIndex,
        9562  m_FrameInUseCount,
        9563  m_BufferImageGranularity,
        9564  size,
        9565  alignment,
        9566  isUpperAddress,
        9567  suballocType,
        9568  false, // canMakeOtherLost
        9569  &allocRequest))
        9570  {
        9571  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
        9572  pBlock->m_pMetadata->Alloc(allocRequest, suballocType, size, isUpperAddress, *pAllocation);
        9573  (*pAllocation)->InitBlockAllocation(
        9574  hCurrentPool,
        9575  pBlock,
        9576  allocRequest.offset,
        9577  alignment,
        9578  size,
        9579  suballocType,
        9580  mapped,
        9581  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        9582  VMA_HEAVY_ASSERT(pBlock->Validate());
        9583  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
        9584  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
        9585  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        9586  {
        9587  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        9588  }
        9589  if(IsCorruptionDetectionEnabled())
        9590  {
        9591  res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, allocRequest.offset, size);
        9592  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        9593  }
        9594  return VK_SUCCESS;
        9595  }
        9596  else
        9597  {
        9598  // Allocation from empty block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
        9599  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9600  }
        9601  }
        9602  }
        9603  }
        9604 
        9605  // 3. Try to allocate from existing blocks with making other allocations lost.
        9606  if(canMakeOtherLost)
        9607  {
        9608  uint32_t tryIndex = 0;
        9609  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
        9610  {
        9611  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
        9612  VmaAllocationRequest bestRequest = {};
        9613  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
        9614 
        9615  // 1. Search existing allocations.
        9616  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        9617  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        9618  {
        9619  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        9620  VMA_ASSERT(pCurrBlock);
        9621  VmaAllocationRequest currRequest = {};
        9622  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        9623  currentFrameIndex,
        9624  m_FrameInUseCount,
        9625  m_BufferImageGranularity,
        9626  size,
        9627  alignment,
        9628  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
        9629  suballocType,
        9630  canMakeOtherLost,
        9631  &currRequest))
        9632  {
        9633  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        9634  if(pBestRequestBlock == VMA_NULL ||
        9635  currRequestCost < bestRequestCost)
        9636  {
        9637  pBestRequestBlock = pCurrBlock;
        9638  bestRequest = currRequest;
        9639  bestRequestCost = currRequestCost;
        9640 
        9641  if(bestRequestCost == 0)
        9642  {
        9643  break;
        9644  }
        9645  }
        9646  }
        9647  }
        9648 
        9649  if(pBestRequestBlock != VMA_NULL)
        9650  {
        9651  if(mapped)
        9652  {
        9653  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
        9654  if(res != VK_SUCCESS)
        9655  {
        9656  return res;
        9657  }
        9658  }
        9659 
        9660  if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
        9661  currentFrameIndex,
        9662  m_FrameInUseCount,
        9663  &bestRequest))
        9664  {
        9665  // We no longer have an empty Allocation.
        9666  if(pBestRequestBlock->m_pMetadata->IsEmpty())
        9667  {
        9668  m_HasEmptyBlock = false;
        9669  }
        9670  // Allocate from this pBlock.
        9671  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
        9672  pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, isUpperAddress, *pAllocation);
        9673  (*pAllocation)->InitBlockAllocation(
        9674  hCurrentPool,
        9675  pBestRequestBlock,
        9676  bestRequest.offset,
        9677  alignment,
        9678  size,
        9679  suballocType,
        9680  mapped,
        9681  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        9682  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
        9683  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        9684  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
        9685  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        9686  {
        9687  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        9688  }
        9689  if(IsCorruptionDetectionEnabled())
        9690  {
        9691  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
        9692  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        9693  }
        9694  return VK_SUCCESS;
        9695  }
        9696  // else: Some allocations must have been touched while we are here. Next try.
        9697  }
        9698  else
        9699  {
        9700  // Could not find place in any of the blocks - break outer loop.
        9701  break;
        9702  }
        9703  }
        9704  /* Maximum number of tries exceeded - a very unlike event when many other
        9705  threads are simultaneously touching allocations making it impossible to make
        9706  lost at the same time as we try to allocate. */
        9707  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
        9708  {
        9709  return VK_ERROR_TOO_MANY_OBJECTS;
        9710  }
        9711  }
        9712 
        9713  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9714 }
        9715 
        9716 void VmaBlockVector::Free(
        9717  VmaAllocation hAllocation)
        9718 {
        9719  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
        9720 
        9721  // Scope for lock.
        9722  {
        9723  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9724 
        9725  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        9726 
        9727  if(IsCorruptionDetectionEnabled())
        9728  {
        9729  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
        9730  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
        9731  }
        9732 
        9733  if(hAllocation->IsPersistentMap())
        9734  {
        9735  pBlock->Unmap(m_hAllocator, 1);
        9736  }
        9737 
        9738  pBlock->m_pMetadata->Free(hAllocation);
        9739  VMA_HEAVY_ASSERT(pBlock->Validate());
        9740 
        9741  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
        9742 
        9743  // pBlock became empty after this deallocation.
        9744  if(pBlock->m_pMetadata->IsEmpty())
        9745  {
        9746  // Already has empty Allocation. We don't want to have two, so delete this one.
        9747  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
        9748  {
        9749  pBlockToDelete = pBlock;
        9750  Remove(pBlock);
        9751  }
        9752  // We now have first empty block.
        9753  else
        9754  {
        9755  m_HasEmptyBlock = true;
        9756  }
        9757  }
        9758  // pBlock didn't become empty, but we have another empty block - find and free that one.
        9759  // (This is optional, heuristics.)
        9760  else if(m_HasEmptyBlock)
        9761  {
        9762  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
        9763  if(pLastBlock->m_pMetadata->IsEmpty() && m_Blocks.size() > m_MinBlockCount)
        9764  {
        9765  pBlockToDelete = pLastBlock;
        9766  m_Blocks.pop_back();
        9767  m_HasEmptyBlock = false;
        9768  }
        9769  }
        9770 
        9771  IncrementallySortBlocks();
        9772  }
        9773 
        9774  // Destruction of a free Allocation. Deferred until this point, outside of mutex
        9775  // lock, for performance reason.
        9776  if(pBlockToDelete != VMA_NULL)
        9777  {
        9778  VMA_DEBUG_LOG(" Deleted empty allocation");
        9779  pBlockToDelete->Destroy(m_hAllocator);
        9780  vma_delete(m_hAllocator, pBlockToDelete);
        9781  }
        9782 }
        9783 
        9784 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
        9785 {
        9786  VkDeviceSize result = 0;
        9787  for(size_t i = m_Blocks.size(); i--; )
        9788  {
        9789  result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
        9790  if(result >= m_PreferredBlockSize)
        9791  {
        9792  break;
        9793  }
        9794  }
        9795  return result;
        9796 }
        9797 
        9798 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
        9799 {
        9800  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        9801  {
        9802  if(m_Blocks[blockIndex] == pBlock)
        9803  {
        9804  VmaVectorRemove(m_Blocks, blockIndex);
        9805  return;
        9806  }
        9807  }
        9808  VMA_ASSERT(0);
        9809 }
        9810 
        9811 void VmaBlockVector::IncrementallySortBlocks()
        9812 {
        9813  // Bubble sort only until first swap.
        9814  for(size_t i = 1; i < m_Blocks.size(); ++i)
        9815  {
        9816  if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
        9817  {
        9818  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
        9819  return;
        9820  }
        9821  }
        9822 }
        9823 
        9824 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
        9825 {
        9826  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        9827  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
        9828  allocInfo.allocationSize = blockSize;
        9829  VkDeviceMemory mem = VK_NULL_HANDLE;
        9830  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
        9831  if(res < 0)
        9832  {
        9833  return res;
        9834  }
        9835 
        9836  // New VkDeviceMemory successfully created.
        9837 
        9838  // Create new Allocation for it.
        9839  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
        9840  pBlock->Init(
        9841  m_hAllocator,
        9842  m_MemoryTypeIndex,
        9843  mem,
        9844  allocInfo.allocationSize,
        9845  m_NextBlockId++,
        9846  m_LinearAlgorithm);
        9847 
        9848  m_Blocks.push_back(pBlock);
        9849  if(pNewBlockIndex != VMA_NULL)
        9850  {
        9851  *pNewBlockIndex = m_Blocks.size() - 1;
        9852  }
        9853 
        9854  return VK_SUCCESS;
        9855 }
        9856 
        9857 #if VMA_STATS_STRING_ENABLED
        9858 
        9859 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
        9860 {
        9861  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9862 
        9863  json.BeginObject();
        9864 
        9865  if(m_IsCustomPool)
        9866  {
        9867  json.WriteString("MemoryTypeIndex");
        9868  json.WriteNumber(m_MemoryTypeIndex);
        9869 
        9870  json.WriteString("BlockSize");
        9871  json.WriteNumber(m_PreferredBlockSize);
        9872 
        9873  json.WriteString("BlockCount");
        9874  json.BeginObject(true);
        9875  if(m_MinBlockCount > 0)
        9876  {
        9877  json.WriteString("Min");
        9878  json.WriteNumber((uint64_t)m_MinBlockCount);
        9879  }
        9880  if(m_MaxBlockCount < SIZE_MAX)
        9881  {
        9882  json.WriteString("Max");
        9883  json.WriteNumber((uint64_t)m_MaxBlockCount);
        9884  }
        9885  json.WriteString("Cur");
        9886  json.WriteNumber((uint64_t)m_Blocks.size());
        9887  json.EndObject();
        9888 
        9889  if(m_FrameInUseCount > 0)
        9890  {
        9891  json.WriteString("FrameInUseCount");
        9892  json.WriteNumber(m_FrameInUseCount);
        9893  }
        9894 
        9895  if(m_LinearAlgorithm)
        9896  {
        9897  json.WriteString("LinearAlgorithm");
        9898  json.WriteBool(true);
        9899  }
        9900  }
        9901  else
        9902  {
        9903  json.WriteString("PreferredBlockSize");
        9904  json.WriteNumber(m_PreferredBlockSize);
        9905  }
        9906 
        9907  json.WriteString("Blocks");
        9908  json.BeginObject();
        9909  for(size_t i = 0; i < m_Blocks.size(); ++i)
        9910  {
        9911  json.BeginString();
        9912  json.ContinueString(m_Blocks[i]->GetId());
        9913  json.EndString();
        9914 
        9915  m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
        9916  }
        9917  json.EndObject();
        9918 
        9919  json.EndObject();
        9920 }
        9921 
        9922 #endif // #if VMA_STATS_STRING_ENABLED
        9923 
        9924 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
        9925  VmaAllocator hAllocator,
        9926  uint32_t currentFrameIndex)
        9927 {
        9928  if(m_pDefragmentator == VMA_NULL)
        9929  {
        9930  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
        9931  hAllocator,
        9932  this,
        9933  currentFrameIndex);
        9934  }
        9935 
        9936  return m_pDefragmentator;
        9937 }
        9938 
        9939 VkResult VmaBlockVector::Defragment(
        9940  VmaDefragmentationStats* pDefragmentationStats,
        9941  VkDeviceSize& maxBytesToMove,
        9942  uint32_t& maxAllocationsToMove)
        9943 {
        9944  if(m_pDefragmentator == VMA_NULL)
        9945  {
        9946  return VK_SUCCESS;
        9947  }
        9948 
        9949  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9950 
        9951  // Defragment.
        9952  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
        9953 
        9954  // Accumulate statistics.
        9955  if(pDefragmentationStats != VMA_NULL)
        9956  {
        9957  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
        9958  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
        9959  pDefragmentationStats->bytesMoved += bytesMoved;
        9960  pDefragmentationStats->allocationsMoved += allocationsMoved;
        9961  VMA_ASSERT(bytesMoved <= maxBytesToMove);
        9962  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
        9963  maxBytesToMove -= bytesMoved;
        9964  maxAllocationsToMove -= allocationsMoved;
        9965  }
        9966 
        9967  // Free empty blocks.
        9968  m_HasEmptyBlock = false;
        9969  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        9970  {
        9971  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        9972  if(pBlock->m_pMetadata->IsEmpty())
        9973  {
        9974  if(m_Blocks.size() > m_MinBlockCount)
        9975  {
        9976  if(pDefragmentationStats != VMA_NULL)
        9977  {
        9978  ++pDefragmentationStats->deviceMemoryBlocksFreed;
        9979  pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
        9980  }
        9981 
        9982  VmaVectorRemove(m_Blocks, blockIndex);
        9983  pBlock->Destroy(m_hAllocator);
        9984  vma_delete(m_hAllocator, pBlock);
        9985  }
        9986  else
        9987  {
        9988  m_HasEmptyBlock = true;
        9989  }
        9990  }
        9991  }
        9992 
        9993  return result;
        9994 }
        9995 
        9996 void VmaBlockVector::DestroyDefragmentator()
        9997 {
        9998  if(m_pDefragmentator != VMA_NULL)
        9999  {
        10000  vma_delete(m_hAllocator, m_pDefragmentator);
        10001  m_pDefragmentator = VMA_NULL;
        10002  }
        10003 }
        10004 
        10005 void VmaBlockVector::MakePoolAllocationsLost(
        10006  uint32_t currentFrameIndex,
        10007  size_t* pLostAllocationCount)
        10008 {
        10009  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10010  size_t lostAllocationCount = 0;
        10011  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        10012  {
        10013  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        10014  VMA_ASSERT(pBlock);
        10015  lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
        10016  }
        10017  if(pLostAllocationCount != VMA_NULL)
        10018  {
        10019  *pLostAllocationCount = lostAllocationCount;
        10020  }
        10021 }
        10022 
        10023 VkResult VmaBlockVector::CheckCorruption()
        10024 {
        10025  if(!IsCorruptionDetectionEnabled())
        10026  {
        10027  return VK_ERROR_FEATURE_NOT_PRESENT;
        10028  }
        10029 
        10030  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10031  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        10032  {
        10033  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        10034  VMA_ASSERT(pBlock);
        10035  VkResult res = pBlock->CheckCorruption(m_hAllocator);
        10036  if(res != VK_SUCCESS)
        10037  {
        10038  return res;
        10039  }
        10040  }
        10041  return VK_SUCCESS;
        10042 }
        10043 
        10044 void VmaBlockVector::AddStats(VmaStats* pStats)
        10045 {
        10046  const uint32_t memTypeIndex = m_MemoryTypeIndex;
        10047  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
        10048 
        10049  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10050 
        10051  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        10052  {
        10053  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        10054  VMA_ASSERT(pBlock);
        10055  VMA_HEAVY_ASSERT(pBlock->Validate());
        10056  VmaStatInfo allocationStatInfo;
        10057  pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
        10058  VmaAddStatInfo(pStats->total, allocationStatInfo);
        10059  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        10060  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        10061  }
        10062 }
        10063 
        10065 // VmaDefragmentator members definition
        10066 
        10067 VmaDefragmentator::VmaDefragmentator(
        10068  VmaAllocator hAllocator,
        10069  VmaBlockVector* pBlockVector,
        10070  uint32_t currentFrameIndex) :
        10071  m_hAllocator(hAllocator),
        10072  m_pBlockVector(pBlockVector),
        10073  m_CurrentFrameIndex(currentFrameIndex),
        10074  m_BytesMoved(0),
        10075  m_AllocationsMoved(0),
        10076  m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),
        10077  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
        10078 {
        10079  VMA_ASSERT(!pBlockVector->UsesLinearAlgorithm());
        10080 }
        10081 
        10082 VmaDefragmentator::~VmaDefragmentator()
        10083 {
        10084  for(size_t i = m_Blocks.size(); i--; )
        10085  {
        10086  vma_delete(m_hAllocator, m_Blocks[i]);
        10087  }
        10088 }
        10089 
        10090 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        10091 {
        10092  AllocationInfo allocInfo;
        10093  allocInfo.m_hAllocation = hAlloc;
        10094  allocInfo.m_pChanged = pChanged;
        10095  m_Allocations.push_back(allocInfo);
        10096 }
        10097 
        10098 VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)
        10099 {
        10100  // It has already been mapped for defragmentation.
        10101  if(m_pMappedDataForDefragmentation)
        10102  {
        10103  *ppMappedData = m_pMappedDataForDefragmentation;
        10104  return VK_SUCCESS;
        10105  }
        10106 
        10107  // It is originally mapped.
        10108  if(m_pBlock->GetMappedData())
        10109  {
        10110  *ppMappedData = m_pBlock->GetMappedData();
        10111  return VK_SUCCESS;
        10112  }
        10113 
        10114  // Map on first usage.
        10115  VkResult res = m_pBlock->Map(hAllocator, 1, &m_pMappedDataForDefragmentation);
        10116  *ppMappedData = m_pMappedDataForDefragmentation;
        10117  return res;
        10118 }
        10119 
        10120 void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)
        10121 {
        10122  if(m_pMappedDataForDefragmentation != VMA_NULL)
        10123  {
        10124  m_pBlock->Unmap(hAllocator, 1);
        10125  }
        10126 }
        10127 
        10128 VkResult VmaDefragmentator::DefragmentRound(
        10129  VkDeviceSize maxBytesToMove,
        10130  uint32_t maxAllocationsToMove)
        10131 {
        10132  if(m_Blocks.empty())
        10133  {
        10134  return VK_SUCCESS;
        10135  }
        10136 
        10137  size_t srcBlockIndex = m_Blocks.size() - 1;
        10138  size_t srcAllocIndex = SIZE_MAX;
        10139  for(;;)
        10140  {
        10141  // 1. Find next allocation to move.
        10142  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
        10143  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
        10144  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
        10145  {
        10146  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
        10147  {
        10148  // Finished: no more allocations to process.
        10149  if(srcBlockIndex == 0)
        10150  {
        10151  return VK_SUCCESS;
        10152  }
        10153  else
        10154  {
        10155  --srcBlockIndex;
        10156  srcAllocIndex = SIZE_MAX;
        10157  }
        10158  }
        10159  else
        10160  {
        10161  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
        10162  }
        10163  }
        10164 
        10165  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
        10166  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
        10167 
        10168  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
        10169  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
        10170  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
        10171  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
        10172 
        10173  // 2. Try to find new place for this allocation in preceding or current block.
        10174  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
        10175  {
        10176  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
        10177  VmaAllocationRequest dstAllocRequest;
        10178  if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
        10179  m_CurrentFrameIndex,
        10180  m_pBlockVector->GetFrameInUseCount(),
        10181  m_pBlockVector->GetBufferImageGranularity(),
        10182  size,
        10183  alignment,
        10184  false, // upperAddress
        10185  suballocType,
        10186  false, // canMakeOtherLost
        10187  &dstAllocRequest) &&
        10188  MoveMakesSense(
        10189  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
        10190  {
        10191  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
        10192 
        10193  // Reached limit on number of allocations or bytes to move.
        10194  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
        10195  (m_BytesMoved + size > maxBytesToMove))
        10196  {
        10197  return VK_INCOMPLETE;
        10198  }
        10199 
        10200  void* pDstMappedData = VMA_NULL;
        10201  VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);
        10202  if(res != VK_SUCCESS)
        10203  {
        10204  return res;
        10205  }
        10206 
        10207  void* pSrcMappedData = VMA_NULL;
        10208  res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);
        10209  if(res != VK_SUCCESS)
        10210  {
        10211  return res;
        10212  }
        10213 
        10214  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
        10215  memcpy(
        10216  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
        10217  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
        10218  static_cast<size_t>(size));
        10219 
        10220  if(VMA_DEBUG_MARGIN > 0)
        10221  {
        10222  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset - VMA_DEBUG_MARGIN);
        10223  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset + size);
        10224  }
        10225 
        10226  pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
        10227  dstAllocRequest,
        10228  suballocType,
        10229  size,
        10230  false, // upperAddress
        10231  allocInfo.m_hAllocation);
        10232  pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
        10233 
        10234  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
        10235 
        10236  if(allocInfo.m_pChanged != VMA_NULL)
        10237  {
        10238  *allocInfo.m_pChanged = VK_TRUE;
        10239  }
        10240 
        10241  ++m_AllocationsMoved;
        10242  m_BytesMoved += size;
        10243 
        10244  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
        10245 
        10246  break;
        10247  }
        10248  }
        10249 
        10250  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
        10251 
        10252  if(srcAllocIndex > 0)
        10253  {
        10254  --srcAllocIndex;
        10255  }
        10256  else
        10257  {
        10258  if(srcBlockIndex > 0)
        10259  {
        10260  --srcBlockIndex;
        10261  srcAllocIndex = SIZE_MAX;
        10262  }
        10263  else
        10264  {
        10265  return VK_SUCCESS;
        10266  }
        10267  }
        10268  }
        10269 }
        10270 
        10271 VkResult VmaDefragmentator::Defragment(
        10272  VkDeviceSize maxBytesToMove,
        10273  uint32_t maxAllocationsToMove)
        10274 {
        10275  if(m_Allocations.empty())
        10276  {
        10277  return VK_SUCCESS;
        10278  }
        10279 
        10280  // Create block info for each block.
        10281  const size_t blockCount = m_pBlockVector->m_Blocks.size();
        10282  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        10283  {
        10284  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
        10285  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
        10286  m_Blocks.push_back(pBlockInfo);
        10287  }
        10288 
        10289  // Sort them by m_pBlock pointer value.
        10290  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
        10291 
        10292  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
        10293  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
        10294  {
        10295  AllocationInfo& allocInfo = m_Allocations[blockIndex];
        10296  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
        10297  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        10298  {
        10299  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
        10300  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
        10301  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
        10302  {
        10303  (*it)->m_Allocations.push_back(allocInfo);
        10304  }
        10305  else
        10306  {
        10307  VMA_ASSERT(0);
        10308  }
        10309  }
        10310  }
        10311  m_Allocations.clear();
        10312 
        10313  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        10314  {
        10315  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
        10316  pBlockInfo->CalcHasNonMovableAllocations();
        10317  pBlockInfo->SortAllocationsBySizeDescecnding();
        10318  }
        10319 
        10320  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
        10321  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
        10322 
        10323  // Execute defragmentation rounds (the main part).
        10324  VkResult result = VK_SUCCESS;
        10325  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
        10326  {
        10327  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
        10328  }
        10329 
        10330  // Unmap blocks that were mapped for defragmentation.
        10331  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        10332  {
        10333  m_Blocks[blockIndex]->Unmap(m_hAllocator);
        10334  }
        10335 
        10336  return result;
        10337 }
        10338 
        10339 bool VmaDefragmentator::MoveMakesSense(
        10340  size_t dstBlockIndex, VkDeviceSize dstOffset,
        10341  size_t srcBlockIndex, VkDeviceSize srcOffset)
        10342 {
        10343  if(dstBlockIndex < srcBlockIndex)
        10344  {
        10345  return true;
        10346  }
        10347  if(dstBlockIndex > srcBlockIndex)
        10348  {
        10349  return false;
        10350  }
        10351  if(dstOffset < srcOffset)
        10352  {
        10353  return true;
        10354  }
        10355  return false;
        10356 }
        10357 
        10359 // VmaRecorder
        10360 
        10361 #if VMA_RECORDING_ENABLED
        10362 
        10363 VmaRecorder::VmaRecorder() :
        10364  m_UseMutex(true),
        10365  m_Flags(0),
        10366  m_File(VMA_NULL),
        10367  m_Freq(INT64_MAX),
        10368  m_StartCounter(INT64_MAX)
        10369 {
        10370 }
        10371 
        10372 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
        10373 {
        10374  m_UseMutex = useMutex;
        10375  m_Flags = settings.flags;
        10376 
        10377  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
        10378  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
        10379 
        10380  // Open file for writing.
        10381  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
        10382  if(err != 0)
        10383  {
        10384  return VK_ERROR_INITIALIZATION_FAILED;
        10385  }
        10386 
        10387  // Write header.
        10388  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
        10389  fprintf(m_File, "%s\n", "1,3");
        10390 
        10391  return VK_SUCCESS;
        10392 }
        10393 
        10394 VmaRecorder::~VmaRecorder()
        10395 {
        10396  if(m_File != VMA_NULL)
        10397  {
        10398  fclose(m_File);
        10399  }
        10400 }
        10401 
        10402 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
        10403 {
        10404  CallParams callParams;
        10405  GetBasicParams(callParams);
        10406 
        10407  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10408  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
        10409  Flush();
        10410 }
        10411 
        10412 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
        10413 {
        10414  CallParams callParams;
        10415  GetBasicParams(callParams);
        10416 
        10417  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10418  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
        10419  Flush();
        10420 }
        10421 
        10422 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
        10423 {
        10424  CallParams callParams;
        10425  GetBasicParams(callParams);
        10426 
        10427  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10428  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
        10429  createInfo.memoryTypeIndex,
        10430  createInfo.flags,
        10431  createInfo.blockSize,
        10432  createInfo.minBlockCount,
        10433  createInfo.maxBlockCount,
        10434  createInfo.frameInUseCount,
        10435  pool);
        10436  Flush();
        10437 }
        10438 
        10439 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
        10440 {
        10441  CallParams callParams;
        10442  GetBasicParams(callParams);
        10443 
        10444  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10445  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
        10446  pool);
        10447  Flush();
        10448 }
        10449 
        10450 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
        10451  const VkMemoryRequirements& vkMemReq,
        10452  const VmaAllocationCreateInfo& createInfo,
        10453  VmaAllocation allocation)
        10454 {
        10455  CallParams callParams;
        10456  GetBasicParams(callParams);
        10457 
        10458  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10459  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        10460  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10461  vkMemReq.size,
        10462  vkMemReq.alignment,
        10463  vkMemReq.memoryTypeBits,
        10464  createInfo.flags,
        10465  createInfo.usage,
        10466  createInfo.requiredFlags,
        10467  createInfo.preferredFlags,
        10468  createInfo.memoryTypeBits,
        10469  createInfo.pool,
        10470  allocation,
        10471  userDataStr.GetString());
        10472  Flush();
        10473 }
        10474 
        10475 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        10476  const VkMemoryRequirements& vkMemReq,
        10477  bool requiresDedicatedAllocation,
        10478  bool prefersDedicatedAllocation,
        10479  const VmaAllocationCreateInfo& createInfo,
        10480  VmaAllocation allocation)
        10481 {
        10482  CallParams callParams;
        10483  GetBasicParams(callParams);
        10484 
        10485  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10486  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        10487  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForBuffer,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10488  vkMemReq.size,
        10489  vkMemReq.alignment,
        10490  vkMemReq.memoryTypeBits,
        10491  requiresDedicatedAllocation ? 1 : 0,
        10492  prefersDedicatedAllocation ? 1 : 0,
        10493  createInfo.flags,
        10494  createInfo.usage,
        10495  createInfo.requiredFlags,
        10496  createInfo.preferredFlags,
        10497  createInfo.memoryTypeBits,
        10498  createInfo.pool,
        10499  allocation,
        10500  userDataStr.GetString());
        10501  Flush();
        10502 }
        10503 
        10504 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
        10505  const VkMemoryRequirements& vkMemReq,
        10506  bool requiresDedicatedAllocation,
        10507  bool prefersDedicatedAllocation,
        10508  const VmaAllocationCreateInfo& createInfo,
        10509  VmaAllocation allocation)
        10510 {
        10511  CallParams callParams;
        10512  GetBasicParams(callParams);
        10513 
        10514  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10515  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        10516  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForImage,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10517  vkMemReq.size,
        10518  vkMemReq.alignment,
        10519  vkMemReq.memoryTypeBits,
        10520  requiresDedicatedAllocation ? 1 : 0,
        10521  prefersDedicatedAllocation ? 1 : 0,
        10522  createInfo.flags,
        10523  createInfo.usage,
        10524  createInfo.requiredFlags,
        10525  createInfo.preferredFlags,
        10526  createInfo.memoryTypeBits,
        10527  createInfo.pool,
        10528  allocation,
        10529  userDataStr.GetString());
        10530  Flush();
        10531 }
        10532 
        10533 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
        10534  VmaAllocation allocation)
        10535 {
        10536  CallParams callParams;
        10537  GetBasicParams(callParams);
        10538 
        10539  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10540  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        10541  allocation);
        10542  Flush();
        10543 }
        10544 
        10545 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
        10546  VmaAllocation allocation,
        10547  const void* pUserData)
        10548 {
        10549  CallParams callParams;
        10550  GetBasicParams(callParams);
        10551 
        10552  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10553  UserDataString userDataStr(
        10554  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
        10555  pUserData);
        10556  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10557  allocation,
        10558  userDataStr.GetString());
        10559  Flush();
        10560 }
        10561 
        10562 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
        10563  VmaAllocation allocation)
        10564 {
        10565  CallParams callParams;
        10566  GetBasicParams(callParams);
        10567 
        10568  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10569  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        10570  allocation);
        10571  Flush();
        10572 }
        10573 
        10574 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
        10575  VmaAllocation allocation)
        10576 {
        10577  CallParams callParams;
        10578  GetBasicParams(callParams);
        10579 
        10580  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10581  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        10582  allocation);
        10583  Flush();
        10584 }
        10585 
        10586 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
        10587  VmaAllocation allocation)
        10588 {
        10589  CallParams callParams;
        10590  GetBasicParams(callParams);
        10591 
        10592  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10593  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        10594  allocation);
        10595  Flush();
        10596 }
        10597 
        10598 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
        10599  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        10600 {
        10601  CallParams callParams;
        10602  GetBasicParams(callParams);
        10603 
        10604  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10605  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        10606  allocation,
        10607  offset,
        10608  size);
        10609  Flush();
        10610 }
        10611 
        10612 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
        10613  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        10614 {
        10615  CallParams callParams;
        10616  GetBasicParams(callParams);
        10617 
        10618  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10619  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        10620  allocation,
        10621  offset,
        10622  size);
        10623  Flush();
        10624 }
        10625 
        10626 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
        10627  const VkBufferCreateInfo& bufCreateInfo,
        10628  const VmaAllocationCreateInfo& allocCreateInfo,
        10629  VmaAllocation allocation)
        10630 {
        10631  CallParams callParams;
        10632  GetBasicParams(callParams);
        10633 
        10634  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10635  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        10636  fprintf(m_File, "%u,%.3f,%u,vmaCreateBuffer,%u,%llu,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10637  bufCreateInfo.flags,
        10638  bufCreateInfo.size,
        10639  bufCreateInfo.usage,
        10640  bufCreateInfo.sharingMode,
        10641  allocCreateInfo.flags,
        10642  allocCreateInfo.usage,
        10643  allocCreateInfo.requiredFlags,
        10644  allocCreateInfo.preferredFlags,
        10645  allocCreateInfo.memoryTypeBits,
        10646  allocCreateInfo.pool,
        10647  allocation,
        10648  userDataStr.GetString());
        10649  Flush();
        10650 }
        10651 
        10652 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
        10653  const VkImageCreateInfo& imageCreateInfo,
        10654  const VmaAllocationCreateInfo& allocCreateInfo,
        10655  VmaAllocation allocation)
        10656 {
        10657  CallParams callParams;
        10658  GetBasicParams(callParams);
        10659 
        10660  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10661  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        10662  fprintf(m_File, "%u,%.3f,%u,vmaCreateImage,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10663  imageCreateInfo.flags,
        10664  imageCreateInfo.imageType,
        10665  imageCreateInfo.format,
        10666  imageCreateInfo.extent.width,
        10667  imageCreateInfo.extent.height,
        10668  imageCreateInfo.extent.depth,
        10669  imageCreateInfo.mipLevels,
        10670  imageCreateInfo.arrayLayers,
        10671  imageCreateInfo.samples,
        10672  imageCreateInfo.tiling,
        10673  imageCreateInfo.usage,
        10674  imageCreateInfo.sharingMode,
        10675  imageCreateInfo.initialLayout,
        10676  allocCreateInfo.flags,
        10677  allocCreateInfo.usage,
        10678  allocCreateInfo.requiredFlags,
        10679  allocCreateInfo.preferredFlags,
        10680  allocCreateInfo.memoryTypeBits,
        10681  allocCreateInfo.pool,
        10682  allocation,
        10683  userDataStr.GetString());
        10684  Flush();
        10685 }
        10686 
        10687 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
        10688  VmaAllocation allocation)
        10689 {
        10690  CallParams callParams;
        10691  GetBasicParams(callParams);
        10692 
        10693  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10694  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
        10695  allocation);
        10696  Flush();
        10697 }
        10698 
        10699 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
        10700  VmaAllocation allocation)
        10701 {
        10702  CallParams callParams;
        10703  GetBasicParams(callParams);
        10704 
        10705  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10706  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
        10707  allocation);
        10708  Flush();
        10709 }
        10710 
        10711 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
        10712  VmaAllocation allocation)
        10713 {
        10714  CallParams callParams;
        10715  GetBasicParams(callParams);
        10716 
        10717  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10718  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        10719  allocation);
        10720  Flush();
        10721 }
        10722 
        10723 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
        10724  VmaAllocation allocation)
        10725 {
        10726  CallParams callParams;
        10727  GetBasicParams(callParams);
        10728 
        10729  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10730  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
        10731  allocation);
        10732  Flush();
        10733 }
        10734 
        10735 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
        10736  VmaPool pool)
        10737 {
        10738  CallParams callParams;
        10739  GetBasicParams(callParams);
        10740 
        10741  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10742  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
        10743  pool);
        10744  Flush();
        10745 }
        10746 
        10747 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
        10748 {
        10749  if(pUserData != VMA_NULL)
        10750  {
        10751  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
        10752  {
        10753  m_Str = (const char*)pUserData;
        10754  }
        10755  else
        10756  {
        10757  sprintf_s(m_PtrStr, "%p", pUserData);
        10758  m_Str = m_PtrStr;
        10759  }
        10760  }
        10761  else
        10762  {
        10763  m_Str = "";
        10764  }
        10765 }
        10766 
        10767 void VmaRecorder::WriteConfiguration(
        10768  const VkPhysicalDeviceProperties& devProps,
        10769  const VkPhysicalDeviceMemoryProperties& memProps,
        10770  bool dedicatedAllocationExtensionEnabled)
        10771 {
        10772  fprintf(m_File, "Config,Begin\n");
        10773 
        10774  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
        10775  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
        10776  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
        10777  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
        10778  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
        10779  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
        10780 
        10781  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
        10782  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
        10783  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
        10784 
        10785  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
        10786  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
        10787  {
        10788  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
        10789  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
        10790  }
        10791  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
        10792  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
        10793  {
        10794  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
        10795  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
        10796  }
        10797 
        10798  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
        10799 
        10800  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
        10801  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
        10802  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
        10803  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
        10804  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
        10805  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
        10806  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
        10807  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
        10808  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        10809 
        10810  fprintf(m_File, "Config,End\n");
        10811 }
        10812 
        10813 void VmaRecorder::GetBasicParams(CallParams& outParams)
        10814 {
        10815  outParams.threadId = GetCurrentThreadId();
        10816 
        10817  LARGE_INTEGER counter;
        10818  QueryPerformanceCounter(&counter);
        10819  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
        10820 }
        10821 
        10822 void VmaRecorder::Flush()
        10823 {
        10824  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
        10825  {
        10826  fflush(m_File);
        10827  }
        10828 }
        10829 
        10830 #endif // #if VMA_RECORDING_ENABLED
        10831 
        10833 // VmaAllocator_T
        10834 
        10835 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
        10836  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        10837  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
        10838  m_hDevice(pCreateInfo->device),
        10839  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
        10840  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        10841  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
        10842  m_PreferredLargeHeapBlockSize(0),
        10843  m_PhysicalDevice(pCreateInfo->physicalDevice),
        10844  m_CurrentFrameIndex(0),
        10845  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
        10846  m_NextPoolId(0)
        10847 #if VMA_RECORDING_ENABLED
        10848  ,m_pRecorder(VMA_NULL)
        10849 #endif
        10850 {
        10851  if(VMA_DEBUG_DETECT_CORRUPTION)
        10852  {
        10853  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
        10854  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
        10855  }
        10856 
        10857  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
        10858 
        10859 #if !(VMA_DEDICATED_ALLOCATION)
        10860  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
        10861  {
        10862  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
        10863  }
        10864 #endif
        10865 
        10866  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
        10867  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        10868  memset(&m_MemProps, 0, sizeof(m_MemProps));
        10869 
        10870  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
        10871  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
        10872 
        10873  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        10874  {
        10875  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
        10876  }
        10877 
        10878  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
        10879  {
        10880  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        10881  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        10882  }
        10883 
        10884  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
        10885 
        10886  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
        10887  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
        10888 
        10889  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        10890  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        10891 
        10892  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
        10893  {
        10894  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        10895  {
        10896  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
        10897  if(limit != VK_WHOLE_SIZE)
        10898  {
        10899  m_HeapSizeLimit[heapIndex] = limit;
        10900  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
        10901  {
        10902  m_MemProps.memoryHeaps[heapIndex].size = limit;
        10903  }
        10904  }
        10905  }
        10906  }
        10907 
        10908  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        10909  {
        10910  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
        10911 
        10912  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
        10913  this,
        10914  memTypeIndex,
        10915  preferredBlockSize,
        10916  0,
        10917  SIZE_MAX,
        10918  GetBufferImageGranularity(),
        10919  pCreateInfo->frameInUseCount,
        10920  false, // isCustomPool
        10921  false); // linearAlgorithm
        10922  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
        10923  // becase minBlockCount is 0.
        10924  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
        10925 
        10926  }
        10927 }
        10928 
        10929 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
        10930 {
        10931  VkResult res = VK_SUCCESS;
        10932 
        10933  if(pCreateInfo->pRecordSettings != VMA_NULL &&
        10934  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
        10935  {
        10936 #if VMA_RECORDING_ENABLED
        10937  m_pRecorder = vma_new(this, VmaRecorder)();
        10938  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
        10939  if(res != VK_SUCCESS)
        10940  {
        10941  return res;
        10942  }
        10943  m_pRecorder->WriteConfiguration(
        10944  m_PhysicalDeviceProperties,
        10945  m_MemProps,
        10946  m_UseKhrDedicatedAllocation);
        10947  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
        10948 #else
        10949  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
        10950  return VK_ERROR_FEATURE_NOT_PRESENT;
        10951 #endif
        10952  }
        10953 
        10954  return res;
        10955 }
        10956 
        10957 VmaAllocator_T::~VmaAllocator_T()
        10958 {
        10959 #if VMA_RECORDING_ENABLED
        10960  if(m_pRecorder != VMA_NULL)
        10961  {
        10962  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
        10963  vma_delete(this, m_pRecorder);
        10964  }
        10965 #endif
        10966 
        10967  VMA_ASSERT(m_Pools.empty());
        10968 
        10969  for(size_t i = GetMemoryTypeCount(); i--; )
        10970  {
        10971  vma_delete(this, m_pDedicatedAllocations[i]);
        10972  vma_delete(this, m_pBlockVectors[i]);
        10973  }
        10974 }
        10975 
        10976 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
        10977 {
        10978 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        10979  m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;
        10980  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;
        10981  m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
        10982  m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;
        10983  m_VulkanFunctions.vkMapMemory = &vkMapMemory;
        10984  m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;
        10985  m_VulkanFunctions.vkFlushMappedMemoryRanges = &vkFlushMappedMemoryRanges;
        10986  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = &vkInvalidateMappedMemoryRanges;
        10987  m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;
        10988  m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;
        10989  m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;
        10990  m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;
        10991  m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;
        10992  m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;
        10993  m_VulkanFunctions.vkCreateImage = &vkCreateImage;
        10994  m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;
        10995 #if VMA_DEDICATED_ALLOCATION
        10996  if(m_UseKhrDedicatedAllocation)
        10997  {
        10998  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
        10999  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
        11000  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
        11001  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
        11002  }
        11003 #endif // #if VMA_DEDICATED_ALLOCATION
        11004 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        11005 
        11006 #define VMA_COPY_IF_NOT_NULL(funcName) \
        11007  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
        11008 
        11009  if(pVulkanFunctions != VMA_NULL)
        11010  {
        11011  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
        11012  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
        11013  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
        11014  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
        11015  VMA_COPY_IF_NOT_NULL(vkMapMemory);
        11016  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
        11017  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
        11018  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
        11019  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
        11020  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
        11021  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
        11022  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
        11023  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
        11024  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
        11025  VMA_COPY_IF_NOT_NULL(vkCreateImage);
        11026  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
        11027 #if VMA_DEDICATED_ALLOCATION
        11028  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
        11029  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
        11030 #endif
        11031  }
        11032 
        11033 #undef VMA_COPY_IF_NOT_NULL
        11034 
        11035  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
        11036  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
        11037  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
        11038  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
        11039  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
        11040  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
        11041  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
        11042  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
        11043  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
        11044  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
        11045  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
        11046  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
        11047  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
        11048  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
        11049  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
        11050  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
        11051  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
        11052  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
        11053 #if VMA_DEDICATED_ALLOCATION
        11054  if(m_UseKhrDedicatedAllocation)
        11055  {
        11056  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
        11057  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
        11058  }
        11059 #endif
        11060 }
        11061 
        11062 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
        11063 {
        11064  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        11065  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        11066  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
        11067  return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
        11068 }
        11069 
        11070 VkResult VmaAllocator_T::AllocateMemoryOfType(
        11071  VkDeviceSize size,
        11072  VkDeviceSize alignment,
        11073  bool dedicatedAllocation,
        11074  VkBuffer dedicatedBuffer,
        11075  VkImage dedicatedImage,
        11076  const VmaAllocationCreateInfo& createInfo,
        11077  uint32_t memTypeIndex,
        11078  VmaSuballocationType suballocType,
        11079  VmaAllocation* pAllocation)
        11080 {
        11081  VMA_ASSERT(pAllocation != VMA_NULL);
        11082  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
        11083 
        11084  VmaAllocationCreateInfo finalCreateInfo = createInfo;
        11085 
        11086  // If memory type is not HOST_VISIBLE, disable MAPPED.
        11087  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        11088  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        11089  {
        11090  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
        11091  }
        11092 
        11093  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
        11094  VMA_ASSERT(blockVector);
        11095 
        11096  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        11097  bool preferDedicatedMemory =
        11098  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
        11099  dedicatedAllocation ||
        11100  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
        11101  size > preferredBlockSize / 2;
        11102 
        11103  if(preferDedicatedMemory &&
        11104  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
        11105  finalCreateInfo.pool == VK_NULL_HANDLE)
        11106  {
        11107  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        11108  }
        11109 
        11110  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
        11111  {
        11112  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11113  {
        11114  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11115  }
        11116  else
        11117  {
        11118  return AllocateDedicatedMemory(
        11119  size,
        11120  suballocType,
        11121  memTypeIndex,
        11122  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        11123  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        11124  finalCreateInfo.pUserData,
        11125  dedicatedBuffer,
        11126  dedicatedImage,
        11127  pAllocation);
        11128  }
        11129  }
        11130  else
        11131  {
        11132  VkResult res = blockVector->Allocate(
        11133  VK_NULL_HANDLE, // hCurrentPool
        11134  m_CurrentFrameIndex.load(),
        11135  size,
        11136  alignment,
        11137  finalCreateInfo,
        11138  suballocType,
        11139  pAllocation);
        11140  if(res == VK_SUCCESS)
        11141  {
        11142  return res;
        11143  }
        11144 
        11145  // 5. Try dedicated memory.
        11146  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11147  {
        11148  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11149  }
        11150  else
        11151  {
        11152  res = AllocateDedicatedMemory(
        11153  size,
        11154  suballocType,
        11155  memTypeIndex,
        11156  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        11157  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        11158  finalCreateInfo.pUserData,
        11159  dedicatedBuffer,
        11160  dedicatedImage,
        11161  pAllocation);
        11162  if(res == VK_SUCCESS)
        11163  {
        11164  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
        11165  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
        11166  return VK_SUCCESS;
        11167  }
        11168  else
        11169  {
        11170  // Everything failed: Return error code.
        11171  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        11172  return res;
        11173  }
        11174  }
        11175  }
        11176 }
        11177 
        11178 VkResult VmaAllocator_T::AllocateDedicatedMemory(
        11179  VkDeviceSize size,
        11180  VmaSuballocationType suballocType,
        11181  uint32_t memTypeIndex,
        11182  bool map,
        11183  bool isUserDataString,
        11184  void* pUserData,
        11185  VkBuffer dedicatedBuffer,
        11186  VkImage dedicatedImage,
        11187  VmaAllocation* pAllocation)
        11188 {
        11189  VMA_ASSERT(pAllocation);
        11190 
        11191  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        11192  allocInfo.memoryTypeIndex = memTypeIndex;
        11193  allocInfo.allocationSize = size;
        11194 
        11195 #if VMA_DEDICATED_ALLOCATION
        11196  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
        11197  if(m_UseKhrDedicatedAllocation)
        11198  {
        11199  if(dedicatedBuffer != VK_NULL_HANDLE)
        11200  {
        11201  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
        11202  dedicatedAllocInfo.buffer = dedicatedBuffer;
        11203  allocInfo.pNext = &dedicatedAllocInfo;
        11204  }
        11205  else if(dedicatedImage != VK_NULL_HANDLE)
        11206  {
        11207  dedicatedAllocInfo.image = dedicatedImage;
        11208  allocInfo.pNext = &dedicatedAllocInfo;
        11209  }
        11210  }
        11211 #endif // #if VMA_DEDICATED_ALLOCATION
        11212 
        11213  // Allocate VkDeviceMemory.
        11214  VkDeviceMemory hMemory = VK_NULL_HANDLE;
        11215  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
        11216  if(res < 0)
        11217  {
        11218  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        11219  return res;
        11220  }
        11221 
        11222  void* pMappedData = VMA_NULL;
        11223  if(map)
        11224  {
        11225  res = (*m_VulkanFunctions.vkMapMemory)(
        11226  m_hDevice,
        11227  hMemory,
        11228  0,
        11229  VK_WHOLE_SIZE,
        11230  0,
        11231  &pMappedData);
        11232  if(res < 0)
        11233  {
        11234  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        11235  FreeVulkanMemory(memTypeIndex, size, hMemory);
        11236  return res;
        11237  }
        11238  }
        11239 
        11240  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
        11241  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
        11242  (*pAllocation)->SetUserData(this, pUserData);
        11243  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        11244  {
        11245  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        11246  }
        11247 
        11248  // Register it in m_pDedicatedAllocations.
        11249  {
        11250  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        11251  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        11252  VMA_ASSERT(pDedicatedAllocations);
        11253  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);
        11254  }
        11255 
        11256  VMA_DEBUG_LOG(" Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
        11257 
        11258  return VK_SUCCESS;
        11259 }
        11260 
        11261 void VmaAllocator_T::GetBufferMemoryRequirements(
        11262  VkBuffer hBuffer,
        11263  VkMemoryRequirements& memReq,
        11264  bool& requiresDedicatedAllocation,
        11265  bool& prefersDedicatedAllocation) const
        11266 {
        11267 #if VMA_DEDICATED_ALLOCATION
        11268  if(m_UseKhrDedicatedAllocation)
        11269  {
        11270  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
        11271  memReqInfo.buffer = hBuffer;
        11272 
        11273  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        11274 
        11275  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        11276  memReq2.pNext = &memDedicatedReq;
        11277 
        11278  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        11279 
        11280  memReq = memReq2.memoryRequirements;
        11281  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        11282  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        11283  }
        11284  else
        11285 #endif // #if VMA_DEDICATED_ALLOCATION
        11286  {
        11287  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
        11288  requiresDedicatedAllocation = false;
        11289  prefersDedicatedAllocation = false;
        11290  }
        11291 }
        11292 
        11293 void VmaAllocator_T::GetImageMemoryRequirements(
        11294  VkImage hImage,
        11295  VkMemoryRequirements& memReq,
        11296  bool& requiresDedicatedAllocation,
        11297  bool& prefersDedicatedAllocation) const
        11298 {
        11299 #if VMA_DEDICATED_ALLOCATION
        11300  if(m_UseKhrDedicatedAllocation)
        11301  {
        11302  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
        11303  memReqInfo.image = hImage;
        11304 
        11305  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        11306 
        11307  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        11308  memReq2.pNext = &memDedicatedReq;
        11309 
        11310  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        11311 
        11312  memReq = memReq2.memoryRequirements;
        11313  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        11314  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        11315  }
        11316  else
        11317 #endif // #if VMA_DEDICATED_ALLOCATION
        11318  {
        11319  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
        11320  requiresDedicatedAllocation = false;
        11321  prefersDedicatedAllocation = false;
        11322  }
        11323 }
        11324 
        11325 VkResult VmaAllocator_T::AllocateMemory(
        11326  const VkMemoryRequirements& vkMemReq,
        11327  bool requiresDedicatedAllocation,
        11328  bool prefersDedicatedAllocation,
        11329  VkBuffer dedicatedBuffer,
        11330  VkImage dedicatedImage,
        11331  const VmaAllocationCreateInfo& createInfo,
        11332  VmaSuballocationType suballocType,
        11333  VmaAllocation* pAllocation)
        11334 {
        11335  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
        11336  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11337  {
        11338  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        11339  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11340  }
        11341  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        11342  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
        11343  {
        11344  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
        11345  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11346  }
        11347  if(requiresDedicatedAllocation)
        11348  {
        11349  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11350  {
        11351  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
        11352  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11353  }
        11354  if(createInfo.pool != VK_NULL_HANDLE)
        11355  {
        11356  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
        11357  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11358  }
        11359  }
        11360  if((createInfo.pool != VK_NULL_HANDLE) &&
        11361  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
        11362  {
        11363  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
        11364  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11365  }
        11366 
        11367  if(createInfo.pool != VK_NULL_HANDLE)
        11368  {
        11369  const VkDeviceSize alignmentForPool = VMA_MAX(
        11370  vkMemReq.alignment,
        11371  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
        11372  return createInfo.pool->m_BlockVector.Allocate(
        11373  createInfo.pool,
        11374  m_CurrentFrameIndex.load(),
        11375  vkMemReq.size,
        11376  alignmentForPool,
        11377  createInfo,
        11378  suballocType,
        11379  pAllocation);
        11380  }
        11381  else
        11382  {
        11383  // Bit mask of memory Vulkan types acceptable for this allocation.
        11384  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        11385  uint32_t memTypeIndex = UINT32_MAX;
        11386  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        11387  if(res == VK_SUCCESS)
        11388  {
        11389  VkDeviceSize alignmentForMemType = VMA_MAX(
        11390  vkMemReq.alignment,
        11391  GetMemoryTypeMinAlignment(memTypeIndex));
        11392 
        11393  res = AllocateMemoryOfType(
        11394  vkMemReq.size,
        11395  alignmentForMemType,
        11396  requiresDedicatedAllocation || prefersDedicatedAllocation,
        11397  dedicatedBuffer,
        11398  dedicatedImage,
        11399  createInfo,
        11400  memTypeIndex,
        11401  suballocType,
        11402  pAllocation);
        11403  // Succeeded on first try.
        11404  if(res == VK_SUCCESS)
        11405  {
        11406  return res;
        11407  }
        11408  // Allocation from this memory type failed. Try other compatible memory types.
        11409  else
        11410  {
        11411  for(;;)
        11412  {
        11413  // Remove old memTypeIndex from list of possibilities.
        11414  memoryTypeBits &= ~(1u << memTypeIndex);
        11415  // Find alternative memTypeIndex.
        11416  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        11417  if(res == VK_SUCCESS)
        11418  {
        11419  alignmentForMemType = VMA_MAX(
        11420  vkMemReq.alignment,
        11421  GetMemoryTypeMinAlignment(memTypeIndex));
        11422 
        11423  res = AllocateMemoryOfType(
        11424  vkMemReq.size,
        11425  alignmentForMemType,
        11426  requiresDedicatedAllocation || prefersDedicatedAllocation,
        11427  dedicatedBuffer,
        11428  dedicatedImage,
        11429  createInfo,
        11430  memTypeIndex,
        11431  suballocType,
        11432  pAllocation);
        11433  // Allocation from this alternative memory type succeeded.
        11434  if(res == VK_SUCCESS)
        11435  {
        11436  return res;
        11437  }
        11438  // else: Allocation from this memory type failed. Try next one - next loop iteration.
        11439  }
        11440  // No other matching memory type index could be found.
        11441  else
        11442  {
        11443  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        11444  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11445  }
        11446  }
        11447  }
        11448  }
        11449  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        11450  else
        11451  return res;
        11452  }
        11453 }
        11454 
        11455 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
        11456 {
        11457  VMA_ASSERT(allocation);
        11458 
        11459  if(allocation->CanBecomeLost() == false ||
        11460  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        11461  {
        11462  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        11463  {
        11464  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
        11465  }
        11466 
        11467  switch(allocation->GetType())
        11468  {
        11469  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        11470  {
        11471  VmaBlockVector* pBlockVector = VMA_NULL;
        11472  VmaPool hPool = allocation->GetPool();
        11473  if(hPool != VK_NULL_HANDLE)
        11474  {
        11475  pBlockVector = &hPool->m_BlockVector;
        11476  }
        11477  else
        11478  {
        11479  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        11480  pBlockVector = m_pBlockVectors[memTypeIndex];
        11481  }
        11482  pBlockVector->Free(allocation);
        11483  }
        11484  break;
        11485  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        11486  FreeDedicatedMemory(allocation);
        11487  break;
        11488  default:
        11489  VMA_ASSERT(0);
        11490  }
        11491  }
        11492 
        11493  allocation->SetUserData(this, VMA_NULL);
        11494  vma_delete(this, allocation);
        11495 }
        11496 
        11497 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
        11498 {
        11499  // Initialize.
        11500  InitStatInfo(pStats->total);
        11501  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        11502  InitStatInfo(pStats->memoryType[i]);
        11503  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        11504  InitStatInfo(pStats->memoryHeap[i]);
        11505 
        11506  // Process default pools.
        11507  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        11508  {
        11509  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        11510  VMA_ASSERT(pBlockVector);
        11511  pBlockVector->AddStats(pStats);
        11512  }
        11513 
        11514  // Process custom pools.
        11515  {
        11516  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11517  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        11518  {
        11519  m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
        11520  }
        11521  }
        11522 
        11523  // Process dedicated allocations.
        11524  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        11525  {
        11526  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        11527  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        11528  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        11529  VMA_ASSERT(pDedicatedAllocVector);
        11530  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
        11531  {
        11532  VmaStatInfo allocationStatInfo;
        11533  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
        11534  VmaAddStatInfo(pStats->total, allocationStatInfo);
        11535  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        11536  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        11537  }
        11538  }
        11539 
        11540  // Postprocess.
        11541  VmaPostprocessCalcStatInfo(pStats->total);
        11542  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
        11543  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
        11544  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
        11545  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
        11546 }
        11547 
        11548 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
        11549 
        11550 VkResult VmaAllocator_T::Defragment(
        11551  VmaAllocation* pAllocations,
        11552  size_t allocationCount,
        11553  VkBool32* pAllocationsChanged,
        11554  const VmaDefragmentationInfo* pDefragmentationInfo,
        11555  VmaDefragmentationStats* pDefragmentationStats)
        11556 {
        11557  if(pAllocationsChanged != VMA_NULL)
        11558  {
        11559  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
        11560  }
        11561  if(pDefragmentationStats != VMA_NULL)
        11562  {
        11563  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
        11564  }
        11565 
        11566  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
        11567 
        11568  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
        11569 
        11570  const size_t poolCount = m_Pools.size();
        11571 
        11572  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
        11573  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        11574  {
        11575  VmaAllocation hAlloc = pAllocations[allocIndex];
        11576  VMA_ASSERT(hAlloc);
        11577  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
        11578  // DedicatedAlloc cannot be defragmented.
        11579  const VkMemoryPropertyFlags requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        11580  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
        11581  // Only HOST_VISIBLE and HOST_COHERENT memory types can be defragmented.
        11582  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags) &&
        11583  // Lost allocation cannot be defragmented.
        11584  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
        11585  {
        11586  VmaBlockVector* pAllocBlockVector = VMA_NULL;
        11587 
        11588  const VmaPool hAllocPool = hAlloc->GetPool();
        11589  // This allocation belongs to custom pool.
        11590  if(hAllocPool != VK_NULL_HANDLE)
        11591  {
        11592  // Pools with linear algorithm are not defragmented.
        11593  if(!hAllocPool->m_BlockVector.UsesLinearAlgorithm())
        11594  {
        11595  pAllocBlockVector = &hAllocPool->m_BlockVector;
        11596  }
        11597  }
        11598  // This allocation belongs to general pool.
        11599  else
        11600  {
        11601  pAllocBlockVector = m_pBlockVectors[memTypeIndex];
        11602  }
        11603 
        11604  if(pAllocBlockVector != VMA_NULL)
        11605  {
        11606  VmaDefragmentator* const pDefragmentator =
        11607  pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);
        11608  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
        11609  &pAllocationsChanged[allocIndex] : VMA_NULL;
        11610  pDefragmentator->AddAllocation(hAlloc, pChanged);
        11611  }
        11612  }
        11613  }
        11614 
        11615  VkResult result = VK_SUCCESS;
        11616 
        11617  // ======== Main processing.
        11618 
        11619  VkDeviceSize maxBytesToMove = SIZE_MAX;
        11620  uint32_t maxAllocationsToMove = UINT32_MAX;
        11621  if(pDefragmentationInfo != VMA_NULL)
        11622  {
        11623  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
        11624  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
        11625  }
        11626 
        11627  // Process standard memory.
        11628  for(uint32_t memTypeIndex = 0;
        11629  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
        11630  ++memTypeIndex)
        11631  {
        11632  // Only HOST_VISIBLE memory types can be defragmented.
        11633  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        11634  {
        11635  result = m_pBlockVectors[memTypeIndex]->Defragment(
        11636  pDefragmentationStats,
        11637  maxBytesToMove,
        11638  maxAllocationsToMove);
        11639  }
        11640  }
        11641 
        11642  // Process custom pools.
        11643  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
        11644  {
        11645  result = m_Pools[poolIndex]->m_BlockVector.Defragment(
        11646  pDefragmentationStats,
        11647  maxBytesToMove,
        11648  maxAllocationsToMove);
        11649  }
        11650 
        11651  // ======== Destroy defragmentators.
        11652 
        11653  // Process custom pools.
        11654  for(size_t poolIndex = poolCount; poolIndex--; )
        11655  {
        11656  m_Pools[poolIndex]->m_BlockVector.DestroyDefragmentator();
        11657  }
        11658 
        11659  // Process standard memory.
        11660  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
        11661  {
        11662  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        11663  {
        11664  m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();
        11665  }
        11666  }
        11667 
        11668  return result;
        11669 }
        11670 
        11671 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
        11672 {
        11673  if(hAllocation->CanBecomeLost())
        11674  {
        11675  /*
        11676  Warning: This is a carefully designed algorithm.
        11677  Do not modify unless you really know what you're doing :)
        11678  */
        11679  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11680  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11681  for(;;)
        11682  {
        11683  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        11684  {
        11685  pAllocationInfo->memoryType = UINT32_MAX;
        11686  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
        11687  pAllocationInfo->offset = 0;
        11688  pAllocationInfo->size = hAllocation->GetSize();
        11689  pAllocationInfo->pMappedData = VMA_NULL;
        11690  pAllocationInfo->pUserData = hAllocation->GetUserData();
        11691  return;
        11692  }
        11693  else if(localLastUseFrameIndex == localCurrFrameIndex)
        11694  {
        11695  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        11696  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        11697  pAllocationInfo->offset = hAllocation->GetOffset();
        11698  pAllocationInfo->size = hAllocation->GetSize();
        11699  pAllocationInfo->pMappedData = VMA_NULL;
        11700  pAllocationInfo->pUserData = hAllocation->GetUserData();
        11701  return;
        11702  }
        11703  else // Last use time earlier than current time.
        11704  {
        11705  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11706  {
        11707  localLastUseFrameIndex = localCurrFrameIndex;
        11708  }
        11709  }
        11710  }
        11711  }
        11712  else
        11713  {
        11714 #if VMA_STATS_STRING_ENABLED
        11715  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11716  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11717  for(;;)
        11718  {
        11719  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        11720  if(localLastUseFrameIndex == localCurrFrameIndex)
        11721  {
        11722  break;
        11723  }
        11724  else // Last use time earlier than current time.
        11725  {
        11726  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11727  {
        11728  localLastUseFrameIndex = localCurrFrameIndex;
        11729  }
        11730  }
        11731  }
        11732 #endif
        11733 
        11734  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        11735  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        11736  pAllocationInfo->offset = hAllocation->GetOffset();
        11737  pAllocationInfo->size = hAllocation->GetSize();
        11738  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        11739  pAllocationInfo->pUserData = hAllocation->GetUserData();
        11740  }
        11741 }
        11742 
        11743 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
        11744 {
        11745  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
        11746  if(hAllocation->CanBecomeLost())
        11747  {
        11748  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11749  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11750  for(;;)
        11751  {
        11752  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        11753  {
        11754  return false;
        11755  }
        11756  else if(localLastUseFrameIndex == localCurrFrameIndex)
        11757  {
        11758  return true;
        11759  }
        11760  else // Last use time earlier than current time.
        11761  {
        11762  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11763  {
        11764  localLastUseFrameIndex = localCurrFrameIndex;
        11765  }
        11766  }
        11767  }
        11768  }
        11769  else
        11770  {
        11771 #if VMA_STATS_STRING_ENABLED
        11772  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11773  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11774  for(;;)
        11775  {
        11776  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        11777  if(localLastUseFrameIndex == localCurrFrameIndex)
        11778  {
        11779  break;
        11780  }
        11781  else // Last use time earlier than current time.
        11782  {
        11783  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11784  {
        11785  localLastUseFrameIndex = localCurrFrameIndex;
        11786  }
        11787  }
        11788  }
        11789 #endif
        11790 
        11791  return true;
        11792  }
        11793 }
        11794 
        11795 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
        11796 {
        11797  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
        11798 
        11799  const bool isLinearAlgorithm = (pCreateInfo->flags & VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) != 0;
        11800 
        11801  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
        11802 
        11803  if(newCreateInfo.maxBlockCount == 0)
        11804  {
        11805  newCreateInfo.maxBlockCount = isLinearAlgorithm ? 1 : SIZE_MAX;
        11806  }
        11807  if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount ||
        11808  isLinearAlgorithm && newCreateInfo.maxBlockCount > 1)
        11809  {
        11810  return VK_ERROR_INITIALIZATION_FAILED;
        11811  }
        11812  if(newCreateInfo.blockSize == 0)
        11813  {
        11814  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
        11815  }
        11816 
        11817  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
        11818 
        11819  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
        11820  if(res != VK_SUCCESS)
        11821  {
        11822  vma_delete(this, *pPool);
        11823  *pPool = VMA_NULL;
        11824  return res;
        11825  }
        11826 
        11827  // Add to m_Pools.
        11828  {
        11829  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11830  (*pPool)->SetId(m_NextPoolId++);
        11831  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
        11832  }
        11833 
        11834  return VK_SUCCESS;
        11835 }
        11836 
        11837 void VmaAllocator_T::DestroyPool(VmaPool pool)
        11838 {
        11839  // Remove from m_Pools.
        11840  {
        11841  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11842  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
        11843  VMA_ASSERT(success && "Pool not found in Allocator.");
        11844  }
        11845 
        11846  vma_delete(this, pool);
        11847 }
        11848 
        11849 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
        11850 {
        11851  pool->m_BlockVector.GetPoolStats(pPoolStats);
        11852 }
        11853 
        11854 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
        11855 {
        11856  m_CurrentFrameIndex.store(frameIndex);
        11857 }
        11858 
        11859 void VmaAllocator_T::MakePoolAllocationsLost(
        11860  VmaPool hPool,
        11861  size_t* pLostAllocationCount)
        11862 {
        11863  hPool->m_BlockVector.MakePoolAllocationsLost(
        11864  m_CurrentFrameIndex.load(),
        11865  pLostAllocationCount);
        11866 }
        11867 
        11868 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
        11869 {
        11870  return hPool->m_BlockVector.CheckCorruption();
        11871 }
        11872 
        11873 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
        11874 {
        11875  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
        11876 
        11877  // Process default pools.
        11878  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        11879  {
        11880  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
        11881  {
        11882  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        11883  VMA_ASSERT(pBlockVector);
        11884  VkResult localRes = pBlockVector->CheckCorruption();
        11885  switch(localRes)
        11886  {
        11887  case VK_ERROR_FEATURE_NOT_PRESENT:
        11888  break;
        11889  case VK_SUCCESS:
        11890  finalRes = VK_SUCCESS;
        11891  break;
        11892  default:
        11893  return localRes;
        11894  }
        11895  }
        11896  }
        11897 
        11898  // Process custom pools.
        11899  {
        11900  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11901  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        11902  {
        11903  if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
        11904  {
        11905  VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
        11906  switch(localRes)
        11907  {
        11908  case VK_ERROR_FEATURE_NOT_PRESENT:
        11909  break;
        11910  case VK_SUCCESS:
        11911  finalRes = VK_SUCCESS;
        11912  break;
        11913  default:
        11914  return localRes;
        11915  }
        11916  }
        11917  }
        11918  }
        11919 
        11920  return finalRes;
        11921 }
        11922 
        11923 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
        11924 {
        11925  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);
        11926  (*pAllocation)->InitLost();
        11927 }
        11928 
        11929 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
        11930 {
        11931  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
        11932 
        11933  VkResult res;
        11934  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        11935  {
        11936  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
        11937  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
        11938  {
        11939  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        11940  if(res == VK_SUCCESS)
        11941  {
        11942  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
        11943  }
        11944  }
        11945  else
        11946  {
        11947  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11948  }
        11949  }
        11950  else
        11951  {
        11952  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        11953  }
        11954 
        11955  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        11956  {
        11957  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
        11958  }
        11959 
        11960  return res;
        11961 }
        11962 
        11963 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
        11964 {
        11965  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        11966  {
        11967  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
        11968  }
        11969 
        11970  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
        11971 
        11972  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
        11973  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        11974  {
        11975  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
        11976  m_HeapSizeLimit[heapIndex] += size;
        11977  }
        11978 }
        11979 
        11980 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
        11981 {
        11982  if(hAllocation->CanBecomeLost())
        11983  {
        11984  return VK_ERROR_MEMORY_MAP_FAILED;
        11985  }
        11986 
        11987  switch(hAllocation->GetType())
        11988  {
        11989  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        11990  {
        11991  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        11992  char *pBytes = VMA_NULL;
        11993  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
        11994  if(res == VK_SUCCESS)
        11995  {
        11996  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
        11997  hAllocation->BlockAllocMap();
        11998  }
        11999  return res;
        12000  }
        12001  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12002  return hAllocation->DedicatedAllocMap(this, ppData);
        12003  default:
        12004  VMA_ASSERT(0);
        12005  return VK_ERROR_MEMORY_MAP_FAILED;
        12006  }
        12007 }
        12008 
        12009 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
        12010 {
        12011  switch(hAllocation->GetType())
        12012  {
        12013  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12014  {
        12015  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        12016  hAllocation->BlockAllocUnmap();
        12017  pBlock->Unmap(this, 1);
        12018  }
        12019  break;
        12020  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12021  hAllocation->DedicatedAllocUnmap(this);
        12022  break;
        12023  default:
        12024  VMA_ASSERT(0);
        12025  }
        12026 }
        12027 
        12028 VkResult VmaAllocator_T::BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer)
        12029 {
        12030  VkResult res = VK_SUCCESS;
        12031  switch(hAllocation->GetType())
        12032  {
        12033  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12034  res = GetVulkanFunctions().vkBindBufferMemory(
        12035  m_hDevice,
        12036  hBuffer,
        12037  hAllocation->GetMemory(),
        12038  0); //memoryOffset
        12039  break;
        12040  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12041  {
        12042  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        12043  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
        12044  res = pBlock->BindBufferMemory(this, hAllocation, hBuffer);
        12045  break;
        12046  }
        12047  default:
        12048  VMA_ASSERT(0);
        12049  }
        12050  return res;
        12051 }
        12052 
        12053 VkResult VmaAllocator_T::BindImageMemory(VmaAllocation hAllocation, VkImage hImage)
        12054 {
        12055  VkResult res = VK_SUCCESS;
        12056  switch(hAllocation->GetType())
        12057  {
        12058  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12059  res = GetVulkanFunctions().vkBindImageMemory(
        12060  m_hDevice,
        12061  hImage,
        12062  hAllocation->GetMemory(),
        12063  0); //memoryOffset
        12064  break;
        12065  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12066  {
        12067  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        12068  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
        12069  res = pBlock->BindImageMemory(this, hAllocation, hImage);
        12070  break;
        12071  }
        12072  default:
        12073  VMA_ASSERT(0);
        12074  }
        12075  return res;
        12076 }
        12077 
        12078 void VmaAllocator_T::FlushOrInvalidateAllocation(
        12079  VmaAllocation hAllocation,
        12080  VkDeviceSize offset, VkDeviceSize size,
        12081  VMA_CACHE_OPERATION op)
        12082 {
        12083  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
        12084  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
        12085  {
        12086  const VkDeviceSize allocationSize = hAllocation->GetSize();
        12087  VMA_ASSERT(offset <= allocationSize);
        12088 
        12089  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        12090 
        12091  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
        12092  memRange.memory = hAllocation->GetMemory();
        12093 
        12094  switch(hAllocation->GetType())
        12095  {
        12096  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12097  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        12098  if(size == VK_WHOLE_SIZE)
        12099  {
        12100  memRange.size = allocationSize - memRange.offset;
        12101  }
        12102  else
        12103  {
        12104  VMA_ASSERT(offset + size <= allocationSize);
        12105  memRange.size = VMA_MIN(
        12106  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
        12107  allocationSize - memRange.offset);
        12108  }
        12109  break;
        12110 
        12111  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12112  {
        12113  // 1. Still within this allocation.
        12114  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        12115  if(size == VK_WHOLE_SIZE)
        12116  {
        12117  size = allocationSize - offset;
        12118  }
        12119  else
        12120  {
        12121  VMA_ASSERT(offset + size <= allocationSize);
        12122  }
        12123  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
        12124 
        12125  // 2. Adjust to whole block.
        12126  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
        12127  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
        12128  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
        12129  memRange.offset += allocationOffset;
        12130  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
        12131 
        12132  break;
        12133  }
        12134 
        12135  default:
        12136  VMA_ASSERT(0);
        12137  }
        12138 
        12139  switch(op)
        12140  {
        12141  case VMA_CACHE_FLUSH:
        12142  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
        12143  break;
        12144  case VMA_CACHE_INVALIDATE:
        12145  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
        12146  break;
        12147  default:
        12148  VMA_ASSERT(0);
        12149  }
        12150  }
        12151  // else: Just ignore this call.
        12152 }
        12153 
        12154 void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
        12155 {
        12156  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        12157 
        12158  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        12159  {
        12160  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        12161  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        12162  VMA_ASSERT(pDedicatedAllocations);
        12163  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
        12164  VMA_ASSERT(success);
        12165  }
        12166 
        12167  VkDeviceMemory hMemory = allocation->GetMemory();
        12168 
        12169  if(allocation->GetMappedData() != VMA_NULL)
        12170  {
        12171  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
        12172  }
        12173 
        12174  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
        12175 
        12176  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
        12177 }
        12178 
        12179 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
        12180 {
        12181  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
        12182  !hAllocation->CanBecomeLost() &&
        12183  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        12184  {
        12185  void* pData = VMA_NULL;
        12186  VkResult res = Map(hAllocation, &pData);
        12187  if(res == VK_SUCCESS)
        12188  {
        12189  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
        12190  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
        12191  Unmap(hAllocation);
        12192  }
        12193  else
        12194  {
        12195  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
        12196  }
        12197  }
        12198 }
        12199 
        12200 #if VMA_STATS_STRING_ENABLED
        12201 
        12202 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
        12203 {
        12204  bool dedicatedAllocationsStarted = false;
        12205  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        12206  {
        12207  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        12208  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        12209  VMA_ASSERT(pDedicatedAllocVector);
        12210  if(pDedicatedAllocVector->empty() == false)
        12211  {
        12212  if(dedicatedAllocationsStarted == false)
        12213  {
        12214  dedicatedAllocationsStarted = true;
        12215  json.WriteString("DedicatedAllocations");
        12216  json.BeginObject();
        12217  }
        12218 
        12219  json.BeginString("Type ");
        12220  json.ContinueString(memTypeIndex);
        12221  json.EndString();
        12222 
        12223  json.BeginArray();
        12224 
        12225  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
        12226  {
        12227  json.BeginObject(true);
        12228  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
        12229  hAlloc->PrintParameters(json);
        12230  json.EndObject();
        12231  }
        12232 
        12233  json.EndArray();
        12234  }
        12235  }
        12236  if(dedicatedAllocationsStarted)
        12237  {
        12238  json.EndObject();
        12239  }
        12240 
        12241  {
        12242  bool allocationsStarted = false;
        12243  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        12244  {
        12245  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
        12246  {
        12247  if(allocationsStarted == false)
        12248  {
        12249  allocationsStarted = true;
        12250  json.WriteString("DefaultPools");
        12251  json.BeginObject();
        12252  }
        12253 
        12254  json.BeginString("Type ");
        12255  json.ContinueString(memTypeIndex);
        12256  json.EndString();
        12257 
        12258  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
        12259  }
        12260  }
        12261  if(allocationsStarted)
        12262  {
        12263  json.EndObject();
        12264  }
        12265  }
        12266 
        12267  // Custom pools
        12268  {
        12269  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        12270  const size_t poolCount = m_Pools.size();
        12271  if(poolCount > 0)
        12272  {
        12273  json.WriteString("Pools");
        12274  json.BeginObject();
        12275  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        12276  {
        12277  json.BeginString();
        12278  json.ContinueString(m_Pools[poolIndex]->GetId());
        12279  json.EndString();
        12280 
        12281  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
        12282  }
        12283  json.EndObject();
        12284  }
        12285  }
        12286 }
        12287 
        12288 #endif // #if VMA_STATS_STRING_ENABLED
        12289 
        12291 // Public interface
        12292 
        12293 VkResult vmaCreateAllocator(
        12294  const VmaAllocatorCreateInfo* pCreateInfo,
        12295  VmaAllocator* pAllocator)
        12296 {
        12297  VMA_ASSERT(pCreateInfo && pAllocator);
        12298  VMA_DEBUG_LOG("vmaCreateAllocator");
        12299  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
        12300  return (*pAllocator)->Init(pCreateInfo);
        12301 }
        12302 
        12303 void vmaDestroyAllocator(
        12304  VmaAllocator allocator)
        12305 {
        12306  if(allocator != VK_NULL_HANDLE)
        12307  {
        12308  VMA_DEBUG_LOG("vmaDestroyAllocator");
        12309  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
        12310  vma_delete(&allocationCallbacks, allocator);
        12311  }
        12312 }
        12313 
        12314 void vmaGetPhysicalDeviceProperties(
        12315  VmaAllocator allocator,
        12316  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        12317 {
        12318  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
        12319  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
        12320 }
        12321 
        12322 void vmaGetMemoryProperties(
        12323  VmaAllocator allocator,
        12324  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
        12325 {
        12326  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
        12327  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
        12328 }
        12329 
        12330 void vmaGetMemoryTypeProperties(
        12331  VmaAllocator allocator,
        12332  uint32_t memoryTypeIndex,
        12333  VkMemoryPropertyFlags* pFlags)
        12334 {
        12335  VMA_ASSERT(allocator && pFlags);
        12336  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
        12337  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
        12338 }
        12339 
        12340 void vmaSetCurrentFrameIndex(
        12341  VmaAllocator allocator,
        12342  uint32_t frameIndex)
        12343 {
        12344  VMA_ASSERT(allocator);
        12345  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
        12346 
        12347  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12348 
        12349  allocator->SetCurrentFrameIndex(frameIndex);
        12350 }
        12351 
        12352 void vmaCalculateStats(
        12353  VmaAllocator allocator,
        12354  VmaStats* pStats)
        12355 {
        12356  VMA_ASSERT(allocator && pStats);
        12357  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12358  allocator->CalculateStats(pStats);
        12359 }
        12360 
        12361 #if VMA_STATS_STRING_ENABLED
        12362 
        12363 void vmaBuildStatsString(
        12364  VmaAllocator allocator,
        12365  char** ppStatsString,
        12366  VkBool32 detailedMap)
        12367 {
        12368  VMA_ASSERT(allocator && ppStatsString);
        12369  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12370 
        12371  VmaStringBuilder sb(allocator);
        12372  {
        12373  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        12374  json.BeginObject();
        12375 
        12376  VmaStats stats;
        12377  allocator->CalculateStats(&stats);
        12378 
        12379  json.WriteString("Total");
        12380  VmaPrintStatInfo(json, stats.total);
        12381 
        12382  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
        12383  {
        12384  json.BeginString("Heap ");
        12385  json.ContinueString(heapIndex);
        12386  json.EndString();
        12387  json.BeginObject();
        12388 
        12389  json.WriteString("Size");
        12390  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
        12391 
        12392  json.WriteString("Flags");
        12393  json.BeginArray(true);
        12394  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
        12395  {
        12396  json.WriteString("DEVICE_LOCAL");
        12397  }
        12398  json.EndArray();
        12399 
        12400  if(stats.memoryHeap[heapIndex].blockCount > 0)
        12401  {
        12402  json.WriteString("Stats");
        12403  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
        12404  }
        12405 
        12406  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
        12407  {
        12408  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
        12409  {
        12410  json.BeginString("Type ");
        12411  json.ContinueString(typeIndex);
        12412  json.EndString();
        12413 
        12414  json.BeginObject();
        12415 
        12416  json.WriteString("Flags");
        12417  json.BeginArray(true);
        12418  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
        12419  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        12420  {
        12421  json.WriteString("DEVICE_LOCAL");
        12422  }
        12423  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        12424  {
        12425  json.WriteString("HOST_VISIBLE");
        12426  }
        12427  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
        12428  {
        12429  json.WriteString("HOST_COHERENT");
        12430  }
        12431  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
        12432  {
        12433  json.WriteString("HOST_CACHED");
        12434  }
        12435  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        12436  {
        12437  json.WriteString("LAZILY_ALLOCATED");
        12438  }
        12439  json.EndArray();
        12440 
        12441  if(stats.memoryType[typeIndex].blockCount > 0)
        12442  {
        12443  json.WriteString("Stats");
        12444  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
        12445  }
        12446 
        12447  json.EndObject();
        12448  }
        12449  }
        12450 
        12451  json.EndObject();
        12452  }
        12453  if(detailedMap == VK_TRUE)
        12454  {
        12455  allocator->PrintDetailedMap(json);
        12456  }
        12457 
        12458  json.EndObject();
        12459  }
        12460 
        12461  const size_t len = sb.GetLength();
        12462  char* const pChars = vma_new_array(allocator, char, len + 1);
        12463  if(len > 0)
        12464  {
        12465  memcpy(pChars, sb.GetData(), len);
        12466  }
        12467  pChars[len] = '\0';
        12468  *ppStatsString = pChars;
        12469 }
        12470 
        12471 void vmaFreeStatsString(
        12472  VmaAllocator allocator,
        12473  char* pStatsString)
        12474 {
        12475  if(pStatsString != VMA_NULL)
        12476  {
        12477  VMA_ASSERT(allocator);
        12478  size_t len = strlen(pStatsString);
        12479  vma_delete_array(allocator, pStatsString, len + 1);
        12480  }
        12481 }
        12482 
        12483 #endif // #if VMA_STATS_STRING_ENABLED
        12484 
        12485 /*
        12486 This function is not protected by any mutex because it just reads immutable data.
        12487 */
        12488 VkResult vmaFindMemoryTypeIndex(
        12489  VmaAllocator allocator,
        12490  uint32_t memoryTypeBits,
        12491  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        12492  uint32_t* pMemoryTypeIndex)
        12493 {
        12494  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        12495  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        12496  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        12497 
        12498  if(pAllocationCreateInfo->memoryTypeBits != 0)
        12499  {
        12500  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
        12501  }
        12502 
        12503  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        12504  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
        12505 
        12506  const bool mapped = (pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        12507  if(mapped)
        12508  {
        12509  preferredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        12510  }
        12511 
        12512  // Convert usage to requiredFlags and preferredFlags.
        12513  switch(pAllocationCreateInfo->usage)
        12514  {
        12515  case VMA_MEMORY_USAGE_UNKNOWN:
        12516  break;
        12517  case VMA_MEMORY_USAGE_GPU_ONLY:
        12518  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        12519  {
        12520  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        12521  }
        12522  break;
        12523  case VMA_MEMORY_USAGE_CPU_ONLY:
        12524  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        12525  break;
        12526  case VMA_MEMORY_USAGE_CPU_TO_GPU:
        12527  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        12528  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        12529  {
        12530  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        12531  }
        12532  break;
        12533  case VMA_MEMORY_USAGE_GPU_TO_CPU:
        12534  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        12535  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        12536  break;
        12537  default:
        12538  break;
        12539  }
        12540 
        12541  *pMemoryTypeIndex = UINT32_MAX;
        12542  uint32_t minCost = UINT32_MAX;
        12543  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        12544  memTypeIndex < allocator->GetMemoryTypeCount();
        12545  ++memTypeIndex, memTypeBit <<= 1)
        12546  {
        12547  // This memory type is acceptable according to memoryTypeBits bitmask.
        12548  if((memTypeBit & memoryTypeBits) != 0)
        12549  {
        12550  const VkMemoryPropertyFlags currFlags =
        12551  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        12552  // This memory type contains requiredFlags.
        12553  if((requiredFlags & ~currFlags) == 0)
        12554  {
        12555  // Calculate cost as number of bits from preferredFlags not present in this memory type.
        12556  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
        12557  // Remember memory type with lowest cost.
        12558  if(currCost < minCost)
        12559  {
        12560  *pMemoryTypeIndex = memTypeIndex;
        12561  if(currCost == 0)
        12562  {
        12563  return VK_SUCCESS;
        12564  }
        12565  minCost = currCost;
        12566  }
        12567  }
        12568  }
        12569  }
        12570  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
        12571 }
        12572 
        12573 VkResult vmaFindMemoryTypeIndexForBufferInfo(
        12574  VmaAllocator allocator,
        12575  const VkBufferCreateInfo* pBufferCreateInfo,
        12576  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        12577  uint32_t* pMemoryTypeIndex)
        12578 {
        12579  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        12580  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
        12581  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        12582  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        12583 
        12584  const VkDevice hDev = allocator->m_hDevice;
        12585  VkBuffer hBuffer = VK_NULL_HANDLE;
        12586  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
        12587  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
        12588  if(res == VK_SUCCESS)
        12589  {
        12590  VkMemoryRequirements memReq = {};
        12591  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
        12592  hDev, hBuffer, &memReq);
        12593 
        12594  res = vmaFindMemoryTypeIndex(
        12595  allocator,
        12596  memReq.memoryTypeBits,
        12597  pAllocationCreateInfo,
        12598  pMemoryTypeIndex);
        12599 
        12600  allocator->GetVulkanFunctions().vkDestroyBuffer(
        12601  hDev, hBuffer, allocator->GetAllocationCallbacks());
        12602  }
        12603  return res;
        12604 }
        12605 
        12606 VkResult vmaFindMemoryTypeIndexForImageInfo(
        12607  VmaAllocator allocator,
        12608  const VkImageCreateInfo* pImageCreateInfo,
        12609  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        12610  uint32_t* pMemoryTypeIndex)
        12611 {
        12612  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        12613  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
        12614  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        12615  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        12616 
        12617  const VkDevice hDev = allocator->m_hDevice;
        12618  VkImage hImage = VK_NULL_HANDLE;
        12619  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
        12620  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
        12621  if(res == VK_SUCCESS)
        12622  {
        12623  VkMemoryRequirements memReq = {};
        12624  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
        12625  hDev, hImage, &memReq);
        12626 
        12627  res = vmaFindMemoryTypeIndex(
        12628  allocator,
        12629  memReq.memoryTypeBits,
        12630  pAllocationCreateInfo,
        12631  pMemoryTypeIndex);
        12632 
        12633  allocator->GetVulkanFunctions().vkDestroyImage(
        12634  hDev, hImage, allocator->GetAllocationCallbacks());
        12635  }
        12636  return res;
        12637 }
        12638 
        12639 VkResult vmaCreatePool(
        12640  VmaAllocator allocator,
        12641  const VmaPoolCreateInfo* pCreateInfo,
        12642  VmaPool* pPool)
        12643 {
        12644  VMA_ASSERT(allocator && pCreateInfo && pPool);
        12645 
        12646  VMA_DEBUG_LOG("vmaCreatePool");
        12647 
        12648  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12649 
        12650  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
        12651 
        12652 #if VMA_RECORDING_ENABLED
        12653  if(allocator->GetRecorder() != VMA_NULL)
        12654  {
        12655  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
        12656  }
        12657 #endif
        12658 
        12659  return res;
        12660 }
        12661 
        12662 void vmaDestroyPool(
        12663  VmaAllocator allocator,
        12664  VmaPool pool)
        12665 {
        12666  VMA_ASSERT(allocator);
        12667 
        12668  if(pool == VK_NULL_HANDLE)
        12669  {
        12670  return;
        12671  }
        12672 
        12673  VMA_DEBUG_LOG("vmaDestroyPool");
        12674 
        12675  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12676 
        12677 #if VMA_RECORDING_ENABLED
        12678  if(allocator->GetRecorder() != VMA_NULL)
        12679  {
        12680  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
        12681  }
        12682 #endif
        12683 
        12684  allocator->DestroyPool(pool);
        12685 }
        12686 
        12687 void vmaGetPoolStats(
        12688  VmaAllocator allocator,
        12689  VmaPool pool,
        12690  VmaPoolStats* pPoolStats)
        12691 {
        12692  VMA_ASSERT(allocator && pool && pPoolStats);
        12693 
        12694  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12695 
        12696  allocator->GetPoolStats(pool, pPoolStats);
        12697 }
        12698 
        12699 void vmaMakePoolAllocationsLost(
        12700  VmaAllocator allocator,
        12701  VmaPool pool,
        12702  size_t* pLostAllocationCount)
        12703 {
        12704  VMA_ASSERT(allocator && pool);
        12705 
        12706  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12707 
        12708 #if VMA_RECORDING_ENABLED
        12709  if(allocator->GetRecorder() != VMA_NULL)
        12710  {
        12711  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
        12712  }
        12713 #endif
        12714 
        12715  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
        12716 }
        12717 
        12718 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
        12719 {
        12720  VMA_ASSERT(allocator && pool);
        12721 
        12722  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12723 
        12724  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
        12725 
        12726  return allocator->CheckPoolCorruption(pool);
        12727 }
        12728 
        12729 VkResult vmaAllocateMemory(
        12730  VmaAllocator allocator,
        12731  const VkMemoryRequirements* pVkMemoryRequirements,
        12732  const VmaAllocationCreateInfo* pCreateInfo,
        12733  VmaAllocation* pAllocation,
        12734  VmaAllocationInfo* pAllocationInfo)
        12735 {
        12736  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
        12737 
        12738  VMA_DEBUG_LOG("vmaAllocateMemory");
        12739 
        12740  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12741 
        12742  VkResult result = allocator->AllocateMemory(
        12743  *pVkMemoryRequirements,
        12744  false, // requiresDedicatedAllocation
        12745  false, // prefersDedicatedAllocation
        12746  VK_NULL_HANDLE, // dedicatedBuffer
        12747  VK_NULL_HANDLE, // dedicatedImage
        12748  *pCreateInfo,
        12749  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        12750  pAllocation);
        12751 
        12752 #if VMA_RECORDING_ENABLED
        12753  if(allocator->GetRecorder() != VMA_NULL)
        12754  {
        12755  allocator->GetRecorder()->RecordAllocateMemory(
        12756  allocator->GetCurrentFrameIndex(),
        12757  *pVkMemoryRequirements,
        12758  *pCreateInfo,
        12759  *pAllocation);
        12760  }
        12761 #endif
        12762 
        12763  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
        12764  {
        12765  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        12766  }
        12767 
        12768  return result;
        12769 }
        12770 
        12771 VkResult vmaAllocateMemoryForBuffer(
        12772  VmaAllocator allocator,
        12773  VkBuffer buffer,
        12774  const VmaAllocationCreateInfo* pCreateInfo,
        12775  VmaAllocation* pAllocation,
        12776  VmaAllocationInfo* pAllocationInfo)
        12777 {
        12778  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        12779 
        12780  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
        12781 
        12782  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12783 
        12784  VkMemoryRequirements vkMemReq = {};
        12785  bool requiresDedicatedAllocation = false;
        12786  bool prefersDedicatedAllocation = false;
        12787  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
        12788  requiresDedicatedAllocation,
        12789  prefersDedicatedAllocation);
        12790 
        12791  VkResult result = allocator->AllocateMemory(
        12792  vkMemReq,
        12793  requiresDedicatedAllocation,
        12794  prefersDedicatedAllocation,
        12795  buffer, // dedicatedBuffer
        12796  VK_NULL_HANDLE, // dedicatedImage
        12797  *pCreateInfo,
        12798  VMA_SUBALLOCATION_TYPE_BUFFER,
        12799  pAllocation);
        12800 
        12801 #if VMA_RECORDING_ENABLED
        12802  if(allocator->GetRecorder() != VMA_NULL)
        12803  {
        12804  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
        12805  allocator->GetCurrentFrameIndex(),
        12806  vkMemReq,
        12807  requiresDedicatedAllocation,
        12808  prefersDedicatedAllocation,
        12809  *pCreateInfo,
        12810  *pAllocation);
        12811  }
        12812 #endif
        12813 
        12814  if(pAllocationInfo && result == VK_SUCCESS)
        12815  {
        12816  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        12817  }
        12818 
        12819  return result;
        12820 }
        12821 
        12822 VkResult vmaAllocateMemoryForImage(
        12823  VmaAllocator allocator,
        12824  VkImage image,
        12825  const VmaAllocationCreateInfo* pCreateInfo,
        12826  VmaAllocation* pAllocation,
        12827  VmaAllocationInfo* pAllocationInfo)
        12828 {
        12829  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        12830 
        12831  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
        12832 
        12833  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12834 
        12835  VkMemoryRequirements vkMemReq = {};
        12836  bool requiresDedicatedAllocation = false;
        12837  bool prefersDedicatedAllocation = false;
        12838  allocator->GetImageMemoryRequirements(image, vkMemReq,
        12839  requiresDedicatedAllocation, prefersDedicatedAllocation);
        12840 
        12841  VkResult result = allocator->AllocateMemory(
        12842  vkMemReq,
        12843  requiresDedicatedAllocation,
        12844  prefersDedicatedAllocation,
        12845  VK_NULL_HANDLE, // dedicatedBuffer
        12846  image, // dedicatedImage
        12847  *pCreateInfo,
        12848  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        12849  pAllocation);
        12850 
        12851 #if VMA_RECORDING_ENABLED
        12852  if(allocator->GetRecorder() != VMA_NULL)
        12853  {
        12854  allocator->GetRecorder()->RecordAllocateMemoryForImage(
        12855  allocator->GetCurrentFrameIndex(),
        12856  vkMemReq,
        12857  requiresDedicatedAllocation,
        12858  prefersDedicatedAllocation,
        12859  *pCreateInfo,
        12860  *pAllocation);
        12861  }
        12862 #endif
        12863 
        12864  if(pAllocationInfo && result == VK_SUCCESS)
        12865  {
        12866  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        12867  }
        12868 
        12869  return result;
        12870 }
        12871 
        12872 void vmaFreeMemory(
        12873  VmaAllocator allocator,
        12874  VmaAllocation allocation)
        12875 {
        12876  VMA_ASSERT(allocator);
        12877 
        12878  if(allocation == VK_NULL_HANDLE)
        12879  {
        12880  return;
        12881  }
        12882 
        12883  VMA_DEBUG_LOG("vmaFreeMemory");
        12884 
        12885  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12886 
        12887 #if VMA_RECORDING_ENABLED
        12888  if(allocator->GetRecorder() != VMA_NULL)
        12889  {
        12890  allocator->GetRecorder()->RecordFreeMemory(
        12891  allocator->GetCurrentFrameIndex(),
        12892  allocation);
        12893  }
        12894 #endif
        12895 
        12896  allocator->FreeMemory(allocation);
        12897 }
        12898 
        12899 void vmaGetAllocationInfo(
        12900  VmaAllocator allocator,
        12901  VmaAllocation allocation,
        12902  VmaAllocationInfo* pAllocationInfo)
        12903 {
        12904  VMA_ASSERT(allocator && allocation && pAllocationInfo);
        12905 
        12906  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12907 
        12908 #if VMA_RECORDING_ENABLED
        12909  if(allocator->GetRecorder() != VMA_NULL)
        12910  {
        12911  allocator->GetRecorder()->RecordGetAllocationInfo(
        12912  allocator->GetCurrentFrameIndex(),
        12913  allocation);
        12914  }
        12915 #endif
        12916 
        12917  allocator->GetAllocationInfo(allocation, pAllocationInfo);
        12918 }
        12919 
        12920 VkBool32 vmaTouchAllocation(
        12921  VmaAllocator allocator,
        12922  VmaAllocation allocation)
        12923 {
        12924  VMA_ASSERT(allocator && allocation);
        12925 
        12926  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12927 
        12928 #if VMA_RECORDING_ENABLED
        12929  if(allocator->GetRecorder() != VMA_NULL)
        12930  {
        12931  allocator->GetRecorder()->RecordTouchAllocation(
        12932  allocator->GetCurrentFrameIndex(),
        12933  allocation);
        12934  }
        12935 #endif
        12936 
        12937  return allocator->TouchAllocation(allocation);
        12938 }
        12939 
        12940 void vmaSetAllocationUserData(
        12941  VmaAllocator allocator,
        12942  VmaAllocation allocation,
        12943  void* pUserData)
        12944 {
        12945  VMA_ASSERT(allocator && allocation);
        12946 
        12947  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12948 
        12949  allocation->SetUserData(allocator, pUserData);
        12950 
        12951 #if VMA_RECORDING_ENABLED
        12952  if(allocator->GetRecorder() != VMA_NULL)
        12953  {
        12954  allocator->GetRecorder()->RecordSetAllocationUserData(
        12955  allocator->GetCurrentFrameIndex(),
        12956  allocation,
        12957  pUserData);
        12958  }
        12959 #endif
        12960 }
        12961 
        12962 void vmaCreateLostAllocation(
        12963  VmaAllocator allocator,
        12964  VmaAllocation* pAllocation)
        12965 {
        12966  VMA_ASSERT(allocator && pAllocation);
        12967 
        12968  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        12969 
        12970  allocator->CreateLostAllocation(pAllocation);
        12971 
        12972 #if VMA_RECORDING_ENABLED
        12973  if(allocator->GetRecorder() != VMA_NULL)
        12974  {
        12975  allocator->GetRecorder()->RecordCreateLostAllocation(
        12976  allocator->GetCurrentFrameIndex(),
        12977  *pAllocation);
        12978  }
        12979 #endif
        12980 }
        12981 
        12982 VkResult vmaMapMemory(
        12983  VmaAllocator allocator,
        12984  VmaAllocation allocation,
        12985  void** ppData)
        12986 {
        12987  VMA_ASSERT(allocator && allocation && ppData);
        12988 
        12989  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12990 
        12991  VkResult res = allocator->Map(allocation, ppData);
        12992 
        12993 #if VMA_RECORDING_ENABLED
        12994  if(allocator->GetRecorder() != VMA_NULL)
        12995  {
        12996  allocator->GetRecorder()->RecordMapMemory(
        12997  allocator->GetCurrentFrameIndex(),
        12998  allocation);
        12999  }
        13000 #endif
        13001 
        13002  return res;
        13003 }
        13004 
        13005 void vmaUnmapMemory(
        13006  VmaAllocator allocator,
        13007  VmaAllocation allocation)
        13008 {
        13009  VMA_ASSERT(allocator && allocation);
        13010 
        13011  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13012 
        13013 #if VMA_RECORDING_ENABLED
        13014  if(allocator->GetRecorder() != VMA_NULL)
        13015  {
        13016  allocator->GetRecorder()->RecordUnmapMemory(
        13017  allocator->GetCurrentFrameIndex(),
        13018  allocation);
        13019  }
        13020 #endif
        13021 
        13022  allocator->Unmap(allocation);
        13023 }
        13024 
        13025 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        13026 {
        13027  VMA_ASSERT(allocator && allocation);
        13028 
        13029  VMA_DEBUG_LOG("vmaFlushAllocation");
        13030 
        13031  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13032 
        13033  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
        13034 
        13035 #if VMA_RECORDING_ENABLED
        13036  if(allocator->GetRecorder() != VMA_NULL)
        13037  {
        13038  allocator->GetRecorder()->RecordFlushAllocation(
        13039  allocator->GetCurrentFrameIndex(),
        13040  allocation, offset, size);
        13041  }
        13042 #endif
        13043 }
        13044 
        13045 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        13046 {
        13047  VMA_ASSERT(allocator && allocation);
        13048 
        13049  VMA_DEBUG_LOG("vmaInvalidateAllocation");
        13050 
        13051  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13052 
        13053  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
        13054 
        13055 #if VMA_RECORDING_ENABLED
        13056  if(allocator->GetRecorder() != VMA_NULL)
        13057  {
        13058  allocator->GetRecorder()->RecordInvalidateAllocation(
        13059  allocator->GetCurrentFrameIndex(),
        13060  allocation, offset, size);
        13061  }
        13062 #endif
        13063 }
        13064 
        13065 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
        13066 {
        13067  VMA_ASSERT(allocator);
        13068 
        13069  VMA_DEBUG_LOG("vmaCheckCorruption");
        13070 
        13071  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13072 
        13073  return allocator->CheckCorruption(memoryTypeBits);
        13074 }
        13075 
        13076 VkResult vmaDefragment(
        13077  VmaAllocator allocator,
        13078  VmaAllocation* pAllocations,
        13079  size_t allocationCount,
        13080  VkBool32* pAllocationsChanged,
        13081  const VmaDefragmentationInfo *pDefragmentationInfo,
        13082  VmaDefragmentationStats* pDefragmentationStats)
        13083 {
        13084  VMA_ASSERT(allocator && pAllocations);
        13085 
        13086  VMA_DEBUG_LOG("vmaDefragment");
        13087 
        13088  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13089 
        13090  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
        13091 }
        13092 
        13093 VkResult vmaBindBufferMemory(
        13094  VmaAllocator allocator,
        13095  VmaAllocation allocation,
        13096  VkBuffer buffer)
        13097 {
        13098  VMA_ASSERT(allocator && allocation && buffer);
        13099 
        13100  VMA_DEBUG_LOG("vmaBindBufferMemory");
        13101 
        13102  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13103 
        13104  return allocator->BindBufferMemory(allocation, buffer);
        13105 }
        13106 
        13107 VkResult vmaBindImageMemory(
        13108  VmaAllocator allocator,
        13109  VmaAllocation allocation,
        13110  VkImage image)
        13111 {
        13112  VMA_ASSERT(allocator && allocation && image);
        13113 
        13114  VMA_DEBUG_LOG("vmaBindImageMemory");
        13115 
        13116  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13117 
        13118  return allocator->BindImageMemory(allocation, image);
        13119 }
        13120 
        13121 VkResult vmaCreateBuffer(
        13122  VmaAllocator allocator,
        13123  const VkBufferCreateInfo* pBufferCreateInfo,
        13124  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        13125  VkBuffer* pBuffer,
        13126  VmaAllocation* pAllocation,
        13127  VmaAllocationInfo* pAllocationInfo)
        13128 {
        13129  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
        13130 
        13131  VMA_DEBUG_LOG("vmaCreateBuffer");
        13132 
        13133  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13134 
        13135  *pBuffer = VK_NULL_HANDLE;
        13136  *pAllocation = VK_NULL_HANDLE;
        13137 
        13138  // 1. Create VkBuffer.
        13139  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        13140  allocator->m_hDevice,
        13141  pBufferCreateInfo,
        13142  allocator->GetAllocationCallbacks(),
        13143  pBuffer);
        13144  if(res >= 0)
        13145  {
        13146  // 2. vkGetBufferMemoryRequirements.
        13147  VkMemoryRequirements vkMemReq = {};
        13148  bool requiresDedicatedAllocation = false;
        13149  bool prefersDedicatedAllocation = false;
        13150  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
        13151  requiresDedicatedAllocation, prefersDedicatedAllocation);
        13152 
        13153  // Make sure alignment requirements for specific buffer usages reported
        13154  // in Physical Device Properties are included in alignment reported by memory requirements.
        13155  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
        13156  {
        13157  VMA_ASSERT(vkMemReq.alignment %
        13158  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
        13159  }
        13160  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
        13161  {
        13162  VMA_ASSERT(vkMemReq.alignment %
        13163  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
        13164  }
        13165  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
        13166  {
        13167  VMA_ASSERT(vkMemReq.alignment %
        13168  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
        13169  }
        13170 
        13171  // 3. Allocate memory using allocator.
        13172  res = allocator->AllocateMemory(
        13173  vkMemReq,
        13174  requiresDedicatedAllocation,
        13175  prefersDedicatedAllocation,
        13176  *pBuffer, // dedicatedBuffer
        13177  VK_NULL_HANDLE, // dedicatedImage
        13178  *pAllocationCreateInfo,
        13179  VMA_SUBALLOCATION_TYPE_BUFFER,
        13180  pAllocation);
        13181 
        13182 #if VMA_RECORDING_ENABLED
        13183  if(allocator->GetRecorder() != VMA_NULL)
        13184  {
        13185  allocator->GetRecorder()->RecordCreateBuffer(
        13186  allocator->GetCurrentFrameIndex(),
        13187  *pBufferCreateInfo,
        13188  *pAllocationCreateInfo,
        13189  *pAllocation);
        13190  }
        13191 #endif
        13192 
        13193  if(res >= 0)
        13194  {
        13195  // 3. Bind buffer with memory.
        13196  res = allocator->BindBufferMemory(*pAllocation, *pBuffer);
        13197  if(res >= 0)
        13198  {
        13199  // All steps succeeded.
        13200  #if VMA_STATS_STRING_ENABLED
        13201  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
        13202  #endif
        13203  if(pAllocationInfo != VMA_NULL)
        13204  {
        13205  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        13206  }
        13207 
        13208  return VK_SUCCESS;
        13209  }
        13210  allocator->FreeMemory(*pAllocation);
        13211  *pAllocation = VK_NULL_HANDLE;
        13212  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        13213  *pBuffer = VK_NULL_HANDLE;
        13214  return res;
        13215  }
        13216  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        13217  *pBuffer = VK_NULL_HANDLE;
        13218  return res;
        13219  }
        13220  return res;
        13221 }
        13222 
        13223 void vmaDestroyBuffer(
        13224  VmaAllocator allocator,
        13225  VkBuffer buffer,
        13226  VmaAllocation allocation)
        13227 {
        13228  VMA_ASSERT(allocator);
        13229 
        13230  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        13231  {
        13232  return;
        13233  }
        13234 
        13235  VMA_DEBUG_LOG("vmaDestroyBuffer");
        13236 
        13237  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13238 
        13239 #if VMA_RECORDING_ENABLED
        13240  if(allocator->GetRecorder() != VMA_NULL)
        13241  {
        13242  allocator->GetRecorder()->RecordDestroyBuffer(
        13243  allocator->GetCurrentFrameIndex(),
        13244  allocation);
        13245  }
        13246 #endif
        13247 
        13248  if(buffer != VK_NULL_HANDLE)
        13249  {
        13250  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        13251  }
        13252 
        13253  if(allocation != VK_NULL_HANDLE)
        13254  {
        13255  allocator->FreeMemory(allocation);
        13256  }
        13257 }
        13258 
        13259 VkResult vmaCreateImage(
        13260  VmaAllocator allocator,
        13261  const VkImageCreateInfo* pImageCreateInfo,
        13262  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        13263  VkImage* pImage,
        13264  VmaAllocation* pAllocation,
        13265  VmaAllocationInfo* pAllocationInfo)
        13266 {
        13267  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
        13268 
        13269  VMA_DEBUG_LOG("vmaCreateImage");
        13270 
        13271  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13272 
        13273  *pImage = VK_NULL_HANDLE;
        13274  *pAllocation = VK_NULL_HANDLE;
        13275 
        13276  // 1. Create VkImage.
        13277  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
        13278  allocator->m_hDevice,
        13279  pImageCreateInfo,
        13280  allocator->GetAllocationCallbacks(),
        13281  pImage);
        13282  if(res >= 0)
        13283  {
        13284  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
        13285  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
        13286  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
        13287 
        13288  // 2. Allocate memory using allocator.
        13289  VkMemoryRequirements vkMemReq = {};
        13290  bool requiresDedicatedAllocation = false;
        13291  bool prefersDedicatedAllocation = false;
        13292  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
        13293  requiresDedicatedAllocation, prefersDedicatedAllocation);
        13294 
        13295  res = allocator->AllocateMemory(
        13296  vkMemReq,
        13297  requiresDedicatedAllocation,
        13298  prefersDedicatedAllocation,
        13299  VK_NULL_HANDLE, // dedicatedBuffer
        13300  *pImage, // dedicatedImage
        13301  *pAllocationCreateInfo,
        13302  suballocType,
        13303  pAllocation);
        13304 
        13305 #if VMA_RECORDING_ENABLED
        13306  if(allocator->GetRecorder() != VMA_NULL)
        13307  {
        13308  allocator->GetRecorder()->RecordCreateImage(
        13309  allocator->GetCurrentFrameIndex(),
        13310  *pImageCreateInfo,
        13311  *pAllocationCreateInfo,
        13312  *pAllocation);
        13313  }
        13314 #endif
        13315 
        13316  if(res >= 0)
        13317  {
        13318  // 3. Bind image with memory.
        13319  res = allocator->BindImageMemory(*pAllocation, *pImage);
        13320  if(res >= 0)
        13321  {
        13322  // All steps succeeded.
        13323  #if VMA_STATS_STRING_ENABLED
        13324  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
        13325  #endif
        13326  if(pAllocationInfo != VMA_NULL)
        13327  {
        13328  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        13329  }
        13330 
        13331  return VK_SUCCESS;
        13332  }
        13333  allocator->FreeMemory(*pAllocation);
        13334  *pAllocation = VK_NULL_HANDLE;
        13335  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        13336  *pImage = VK_NULL_HANDLE;
        13337  return res;
        13338  }
        13339  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        13340  *pImage = VK_NULL_HANDLE;
        13341  return res;
        13342  }
        13343  return res;
        13344 }
        13345 
        13346 void vmaDestroyImage(
        13347  VmaAllocator allocator,
        13348  VkImage image,
        13349  VmaAllocation allocation)
        13350 {
        13351  VMA_ASSERT(allocator);
        13352 
        13353  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        13354  {
        13355  return;
        13356  }
        13357 
        13358  VMA_DEBUG_LOG("vmaDestroyImage");
        13359 
        13360  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13361 
        13362 #if VMA_RECORDING_ENABLED
        13363  if(allocator->GetRecorder() != VMA_NULL)
        13364  {
        13365  allocator->GetRecorder()->RecordDestroyImage(
        13366  allocator->GetCurrentFrameIndex(),
        13367  allocation);
        13368  }
        13369 #endif
        13370 
        13371  if(image != VK_NULL_HANDLE)
        13372  {
        13373  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
        13374  }
        13375  if(allocation != VK_NULL_HANDLE)
        13376  {
        13377  allocator->FreeMemory(allocation);
        13378  }
        13379 }
        13380 
        13381 #endif // #ifdef VMA_IMPLEMENTATION
        VmaVulkanFunctions::vkGetPhysicalDeviceProperties
        PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
        Definition: vk_mem_alloc.h:1430
        -
        VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
        Set this flag if the allocation should have its own memory block.
        Definition: vk_mem_alloc.h:1743
        +Go to the documentation of this file.
        1 //
        2 // Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved.
        3 //
        4 // Permission is hereby granted, free of charge, to any person obtaining a copy
        5 // of this software and associated documentation files (the "Software"), to deal
        6 // in the Software without restriction, including without limitation the rights
        7 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        8 // copies of the Software, and to permit persons to whom the Software is
        9 // furnished to do so, subject to the following conditions:
        10 //
        11 // The above copyright notice and this permission notice shall be included in
        12 // all copies or substantial portions of the Software.
        13 //
        14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        15 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        16 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        17 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        18 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        19 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        20 // THE SOFTWARE.
        21 //
        22 
        23 #ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
        24 #define AMD_VULKAN_MEMORY_ALLOCATOR_H
        25 
        26 #ifdef __cplusplus
        27 extern "C" {
        28 #endif
        29 
        1359 #include <vulkan/vulkan.h>
        1360 
        1361 #if !defined(VMA_DEDICATED_ALLOCATION)
        1362  #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
        1363  #define VMA_DEDICATED_ALLOCATION 1
        1364  #else
        1365  #define VMA_DEDICATED_ALLOCATION 0
        1366  #endif
        1367 #endif
        1368 
        1378 VK_DEFINE_HANDLE(VmaAllocator)
        1379 
        1380 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
        1382  VmaAllocator allocator,
        1383  uint32_t memoryType,
        1384  VkDeviceMemory memory,
        1385  VkDeviceSize size);
        1387 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
        1388  VmaAllocator allocator,
        1389  uint32_t memoryType,
        1390  VkDeviceMemory memory,
        1391  VkDeviceSize size);
        1392 
        1400 typedef struct VmaDeviceMemoryCallbacks {
        1402  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
        1404  PFN_vmaFreeDeviceMemoryFunction pfnFree;
        1405 } VmaDeviceMemoryCallbacks;
        1406 
        1408 typedef enum VmaAllocatorCreateFlagBits {
        1413  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
        1435  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
        1436 
        1437  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1438 } VmaAllocatorCreateFlagBits;
        1439 typedef VkFlags VmaAllocatorCreateFlags;
        1440 
        1445 typedef struct VmaVulkanFunctions {
        1446  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
        1447  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
        1448  PFN_vkAllocateMemory vkAllocateMemory;
        1449  PFN_vkFreeMemory vkFreeMemory;
        1450  PFN_vkMapMemory vkMapMemory;
        1451  PFN_vkUnmapMemory vkUnmapMemory;
        1452  PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
        1453  PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
        1454  PFN_vkBindBufferMemory vkBindBufferMemory;
        1455  PFN_vkBindImageMemory vkBindImageMemory;
        1456  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
        1457  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
        1458  PFN_vkCreateBuffer vkCreateBuffer;
        1459  PFN_vkDestroyBuffer vkDestroyBuffer;
        1460  PFN_vkCreateImage vkCreateImage;
        1461  PFN_vkDestroyImage vkDestroyImage;
        1462 #if VMA_DEDICATED_ALLOCATION
        1463  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
        1464  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
        1465 #endif
        1466 } VmaVulkanFunctions;
        1467 
        1469 typedef enum VmaRecordFlagBits {
        1475  VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,
        1476 
        1477  VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1478 } VmaRecordFlagBits;
        1479 typedef VkFlags VmaRecordFlags;
        1480 
        1481 /*
        1482 Define this macro to 0/1 to disable/enable support for recording functionality,
        1483 available through VmaAllocatorCreateInfo::pRecordSettings.
        1484 */
        1485 #ifndef VMA_RECORDING_ENABLED
        1486  #ifdef _WIN32
        1487  #define VMA_RECORDING_ENABLED 1
        1488  #else
        1489  #define VMA_RECORDING_ENABLED 0
        1490  #endif
        1491 #endif
        1492 
        1494 typedef struct VmaRecordSettings
        1495 {
        1497  VmaRecordFlags flags;
        1505  const char* pFilePath;
        1506 } VmaRecordSettings;
        1507 
        1509 typedef struct VmaAllocatorCreateInfo
        1510 {
        1512  VmaAllocatorCreateFlags flags;
        1514 
        1515  VkPhysicalDevice physicalDevice;
        1517 
        1518  VkDevice device;
        1520 
        1521  VkDeviceSize preferredLargeHeapBlockSize;
        1523 
        1524  const VkAllocationCallbacks* pAllocationCallbacks;
        1526 
        1527  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
        1541  uint32_t frameInUseCount;
        1565  const VkDeviceSize* pHeapSizeLimit;
        1577  const VmaVulkanFunctions* pVulkanFunctions;
        1584  const VmaRecordSettings* pRecordSettings;
        1585 } VmaAllocatorCreateInfo;
        1586 
        1588 VkResult vmaCreateAllocator(
        1589  const VmaAllocatorCreateInfo* pCreateInfo,
        1590  VmaAllocator* pAllocator);
        1591 
        1593 void vmaDestroyAllocator(
        1594  VmaAllocator allocator);
        1595 
        1600 void vmaGetPhysicalDeviceProperties(
        1601  VmaAllocator allocator,
        1602  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
        1603 
        1608 void vmaGetMemoryProperties(
        1609  VmaAllocator allocator,
        1610  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
        1611 
        1618 void vmaGetMemoryTypeProperties(
        1619  VmaAllocator allocator,
        1620  uint32_t memoryTypeIndex,
        1621  VkMemoryPropertyFlags* pFlags);
        1622 
        1631 void vmaSetCurrentFrameIndex(
        1632  VmaAllocator allocator,
        1633  uint32_t frameIndex);
        1634 
        1637 typedef struct VmaStatInfo
        1638 {
        1640  uint32_t blockCount;
        1642  uint32_t allocationCount;
        1644  uint32_t unusedRangeCount;
        1646  VkDeviceSize usedBytes;
        1648  VkDeviceSize unusedBytes;
        1649  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
        1650  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
        1651 } VmaStatInfo;
        1652 
        1654 typedef struct VmaStats
        1655 {
        1656  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
        1657  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
        1658  VmaStatInfo total;
        1659 } VmaStats;
        1660 
        1662 void vmaCalculateStats(
        1663  VmaAllocator allocator,
        1664  VmaStats* pStats);
        1665 
        1666 #define VMA_STATS_STRING_ENABLED 1
        1667 
        1668 #if VMA_STATS_STRING_ENABLED
        1669 
        1671 
        1673 void vmaBuildStatsString(
        1674  VmaAllocator allocator,
        1675  char** ppStatsString,
        1676  VkBool32 detailedMap);
        1677 
        1678 void vmaFreeStatsString(
        1679  VmaAllocator allocator,
        1680  char* pStatsString);
        1681 
        1682 #endif // #if VMA_STATS_STRING_ENABLED
        1683 
        1692 VK_DEFINE_HANDLE(VmaPool)
        1693 
        1694 typedef enum VmaMemoryUsage
        1695 {
        1699  VMA_MEMORY_USAGE_UNKNOWN = 0,
        1716  VMA_MEMORY_USAGE_GPU_ONLY = 1,
        1726  VMA_MEMORY_USAGE_CPU_ONLY = 2,
        1733  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
        1742  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
        1743  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
        1744 } VmaMemoryUsage;
        1745 
        1747 typedef enum VmaAllocationCreateFlagBits {
        1759  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
        1760 
        1770  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
        1783  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
        1796  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
        1803  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
        1809  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
        1814  VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
        1815 
        1816  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1817 } VmaAllocationCreateFlagBits;
        1818 typedef VkFlags VmaAllocationCreateFlags;
        1819 
        1820 typedef struct VmaAllocationCreateInfo
        1821 {
        1823  VmaAllocationCreateFlags flags;
        1829  VmaMemoryUsage usage;
        1834  VkMemoryPropertyFlags requiredFlags;
        1839  VkMemoryPropertyFlags preferredFlags;
        1847  uint32_t memoryTypeBits;
        1853  VmaPool pool;
        1860  void* pUserData;
        1861 } VmaAllocationCreateInfo;
        1862 
        1879 VkResult vmaFindMemoryTypeIndex(
        1880  VmaAllocator allocator,
        1881  uint32_t memoryTypeBits,
        1882  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1883  uint32_t* pMemoryTypeIndex);
        1884 
        1897 VkResult vmaFindMemoryTypeIndexForBufferInfo(
        1898  VmaAllocator allocator,
        1899  const VkBufferCreateInfo* pBufferCreateInfo,
        1900  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1901  uint32_t* pMemoryTypeIndex);
        1902 
        1915 VkResult vmaFindMemoryTypeIndexForImageInfo(
        1916  VmaAllocator allocator,
        1917  const VkImageCreateInfo* pImageCreateInfo,
        1918  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        1919  uint32_t* pMemoryTypeIndex);
        1920 
        1922 typedef enum VmaPoolCreateFlagBits {
        1940  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
        1941 
        1955  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
        1956 
        1957  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
        1958 } VmaPoolCreateFlagBits;
        1959 typedef VkFlags VmaPoolCreateFlags;
        1960 
        1963 typedef struct VmaPoolCreateInfo {
        1966  uint32_t memoryTypeIndex;
        1969  VmaPoolCreateFlags flags;
        1978  VkDeviceSize blockSize;
        1983  size_t minBlockCount;
        1991  size_t maxBlockCount;
        2005  uint32_t frameInUseCount;
        2006 } VmaPoolCreateInfo;
        2007 
        2010 typedef struct VmaPoolStats {
        2013  VkDeviceSize size;
        2016  VkDeviceSize unusedSize;
        2019  size_t allocationCount;
        2022  size_t unusedRangeCount;
        2029  VkDeviceSize unusedRangeSizeMax;
        2032  size_t blockCount;
        2033 } VmaPoolStats;
        2034 
        2041 VkResult vmaCreatePool(
        2042  VmaAllocator allocator,
        2043  const VmaPoolCreateInfo* pCreateInfo,
        2044  VmaPool* pPool);
        2045 
        2048 void vmaDestroyPool(
        2049  VmaAllocator allocator,
        2050  VmaPool pool);
        2051 
        2058 void vmaGetPoolStats(
        2059  VmaAllocator allocator,
        2060  VmaPool pool,
        2061  VmaPoolStats* pPoolStats);
        2062 
        2069 void vmaMakePoolAllocationsLost(
        2070  VmaAllocator allocator,
        2071  VmaPool pool,
        2072  size_t* pLostAllocationCount);
        2073 
        2088 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
        2089 
        2114 VK_DEFINE_HANDLE(VmaAllocation)
        2115 
        2116 
        2118 typedef struct VmaAllocationInfo {
        2123  uint32_t memoryType;
        2132  VkDeviceMemory deviceMemory;
        2137  VkDeviceSize offset;
        2142  VkDeviceSize size;
        2151  void* pMappedData;
        2156  void* pUserData;
        2157 } VmaAllocationInfo;
        2158 
        2169 VkResult vmaAllocateMemory(
        2170  VmaAllocator allocator,
        2171  const VkMemoryRequirements* pVkMemoryRequirements,
        2172  const VmaAllocationCreateInfo* pCreateInfo,
        2173  VmaAllocation* pAllocation,
        2174  VmaAllocationInfo* pAllocationInfo);
        2175 
        2182 VkResult vmaAllocateMemoryForBuffer(
        2183  VmaAllocator allocator,
        2184  VkBuffer buffer,
        2185  const VmaAllocationCreateInfo* pCreateInfo,
        2186  VmaAllocation* pAllocation,
        2187  VmaAllocationInfo* pAllocationInfo);
        2188 
        2190 VkResult vmaAllocateMemoryForImage(
        2191  VmaAllocator allocator,
        2192  VkImage image,
        2193  const VmaAllocationCreateInfo* pCreateInfo,
        2194  VmaAllocation* pAllocation,
        2195  VmaAllocationInfo* pAllocationInfo);
        2196 
        2198 void vmaFreeMemory(
        2199  VmaAllocator allocator,
        2200  VmaAllocation allocation);
        2201 
        2218 void vmaGetAllocationInfo(
        2219  VmaAllocator allocator,
        2220  VmaAllocation allocation,
        2221  VmaAllocationInfo* pAllocationInfo);
        2222 
        2237 VkBool32 vmaTouchAllocation(
        2238  VmaAllocator allocator,
        2239  VmaAllocation allocation);
        2240 
        2254 void vmaSetAllocationUserData(
        2255  VmaAllocator allocator,
        2256  VmaAllocation allocation,
        2257  void* pUserData);
        2258 
        2269 void vmaCreateLostAllocation(
        2270  VmaAllocator allocator,
        2271  VmaAllocation* pAllocation);
        2272 
        2307 VkResult vmaMapMemory(
        2308  VmaAllocator allocator,
        2309  VmaAllocation allocation,
        2310  void** ppData);
        2311 
        2316 void vmaUnmapMemory(
        2317  VmaAllocator allocator,
        2318  VmaAllocation allocation);
        2319 
        2332 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        2333 
        2346 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        2347 
        2364 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
        2365 
        2367 typedef struct VmaDefragmentationInfo {
        2372  VkDeviceSize maxBytesToMove;
        2377  uint32_t maxAllocationsToMove;
        2378 } VmaDefragmentationInfo;
        2379 
        2381 typedef struct VmaDefragmentationStats {
        2383  VkDeviceSize bytesMoved;
        2385  VkDeviceSize bytesFreed;
        2387  uint32_t allocationsMoved;
        2389  uint32_t deviceMemoryBlocksFreed;
        2390 } VmaDefragmentationStats;
        2391 
        2478 VkResult vmaDefragment(
        2479  VmaAllocator allocator,
        2480  VmaAllocation* pAllocations,
        2481  size_t allocationCount,
        2482  VkBool32* pAllocationsChanged,
        2483  const VmaDefragmentationInfo *pDefragmentationInfo,
        2484  VmaDefragmentationStats* pDefragmentationStats);
        2485 
        2498 VkResult vmaBindBufferMemory(
        2499  VmaAllocator allocator,
        2500  VmaAllocation allocation,
        2501  VkBuffer buffer);
        2502 
        2515 VkResult vmaBindImageMemory(
        2516  VmaAllocator allocator,
        2517  VmaAllocation allocation,
        2518  VkImage image);
        2519 
        2546 VkResult vmaCreateBuffer(
        2547  VmaAllocator allocator,
        2548  const VkBufferCreateInfo* pBufferCreateInfo,
        2549  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        2550  VkBuffer* pBuffer,
        2551  VmaAllocation* pAllocation,
        2552  VmaAllocationInfo* pAllocationInfo);
        2553 
        2565 void vmaDestroyBuffer(
        2566  VmaAllocator allocator,
        2567  VkBuffer buffer,
        2568  VmaAllocation allocation);
        2569 
        2571 VkResult vmaCreateImage(
        2572  VmaAllocator allocator,
        2573  const VkImageCreateInfo* pImageCreateInfo,
        2574  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        2575  VkImage* pImage,
        2576  VmaAllocation* pAllocation,
        2577  VmaAllocationInfo* pAllocationInfo);
        2578 
        2590 void vmaDestroyImage(
        2591  VmaAllocator allocator,
        2592  VkImage image,
        2593  VmaAllocation allocation);
        2594 
        2595 #ifdef __cplusplus
        2596 }
        2597 #endif
        2598 
        2599 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
        2600 
        2601 // For Visual Studio IntelliSense.
        2602 #if defined(__cplusplus) && defined(__INTELLISENSE__)
        2603 #define VMA_IMPLEMENTATION
        2604 #endif
        2605 
        2606 #ifdef VMA_IMPLEMENTATION
        2607 #undef VMA_IMPLEMENTATION
        2608 
        2609 #include <cstdint>
        2610 #include <cstdlib>
        2611 #include <cstring>
        2612 
        2613 /*******************************************************************************
        2614 CONFIGURATION SECTION
        2615 
        2616 Define some of these macros before each #include of this header or change them
        2617 here if you need other then default behavior depending on your environment.
        2618 */
        2619 
        2620 /*
        2621 Define this macro to 1 to make the library fetch pointers to Vulkan functions
        2622 internally, like:
        2623 
        2624  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
        2625 
        2626 Define to 0 if you are going to provide you own pointers to Vulkan functions via
        2627 VmaAllocatorCreateInfo::pVulkanFunctions.
        2628 */
        2629 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
        2630 #define VMA_STATIC_VULKAN_FUNCTIONS 1
        2631 #endif
        2632 
        2633 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
        2634 //#define VMA_USE_STL_CONTAINERS 1
        2635 
        2636 /* Set this macro to 1 to make the library including and using STL containers:
        2637 std::pair, std::vector, std::list, std::unordered_map.
        2638 
        2639 Set it to 0 or undefined to make the library using its own implementation of
        2640 the containers.
        2641 */
        2642 #if VMA_USE_STL_CONTAINERS
        2643  #define VMA_USE_STL_VECTOR 1
        2644  #define VMA_USE_STL_UNORDERED_MAP 1
        2645  #define VMA_USE_STL_LIST 1
        2646 #endif
        2647 
        2648 #if VMA_USE_STL_VECTOR
        2649  #include <vector>
        2650 #endif
        2651 
        2652 #if VMA_USE_STL_UNORDERED_MAP
        2653  #include <unordered_map>
        2654 #endif
        2655 
        2656 #if VMA_USE_STL_LIST
        2657  #include <list>
        2658 #endif
        2659 
        2660 /*
        2661 Following headers are used in this CONFIGURATION section only, so feel free to
        2662 remove them if not needed.
        2663 */
        2664 #include <cassert> // for assert
        2665 #include <algorithm> // for min, max
        2666 #include <mutex> // for std::mutex
        2667 #include <atomic> // for std::atomic
        2668 
        2669 #ifndef VMA_NULL
        2670  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
        2671  #define VMA_NULL nullptr
        2672 #endif
        2673 
        2674 #if defined(__APPLE__) || defined(__ANDROID__)
        2675 #include <cstdlib>
        2676 void *aligned_alloc(size_t alignment, size_t size)
        2677 {
        2678  // alignment must be >= sizeof(void*)
        2679  if(alignment < sizeof(void*))
        2680  {
        2681  alignment = sizeof(void*);
        2682  }
        2683 
        2684  void *pointer;
        2685  if(posix_memalign(&pointer, alignment, size) == 0)
        2686  return pointer;
        2687  return VMA_NULL;
        2688 }
        2689 #endif
        2690 
        2691 // If your compiler is not compatible with C++11 and definition of
        2692 // aligned_alloc() function is missing, uncommeting following line may help:
        2693 
        2694 //#include <malloc.h>
        2695 
        2696 // Normal assert to check for programmer's errors, especially in Debug configuration.
        2697 #ifndef VMA_ASSERT
        2698  #ifdef _DEBUG
        2699  #define VMA_ASSERT(expr) assert(expr)
        2700  #else
        2701  #define VMA_ASSERT(expr)
        2702  #endif
        2703 #endif
        2704 
        2705 // Assert that will be called very often, like inside data structures e.g. operator[].
        2706 // Making it non-empty can make program slow.
        2707 #ifndef VMA_HEAVY_ASSERT
        2708  #ifdef _DEBUG
        2709  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
        2710  #else
        2711  #define VMA_HEAVY_ASSERT(expr)
        2712  #endif
        2713 #endif
        2714 
        2715 #ifndef VMA_ALIGN_OF
        2716  #define VMA_ALIGN_OF(type) (__alignof(type))
        2717 #endif
        2718 
        2719 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
        2720  #if defined(_WIN32)
        2721  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
        2722  #else
        2723  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
        2724  #endif
        2725 #endif
        2726 
        2727 #ifndef VMA_SYSTEM_FREE
        2728  #if defined(_WIN32)
        2729  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
        2730  #else
        2731  #define VMA_SYSTEM_FREE(ptr) free(ptr)
        2732  #endif
        2733 #endif
        2734 
        2735 #ifndef VMA_MIN
        2736  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
        2737 #endif
        2738 
        2739 #ifndef VMA_MAX
        2740  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
        2741 #endif
        2742 
        2743 #ifndef VMA_SWAP
        2744  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
        2745 #endif
        2746 
        2747 #ifndef VMA_SORT
        2748  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
        2749 #endif
        2750 
        2751 #ifndef VMA_DEBUG_LOG
        2752  #define VMA_DEBUG_LOG(format, ...)
        2753  /*
        2754  #define VMA_DEBUG_LOG(format, ...) do { \
        2755  printf(format, __VA_ARGS__); \
        2756  printf("\n"); \
        2757  } while(false)
        2758  */
        2759 #endif
        2760 
        2761 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
        2762 #if VMA_STATS_STRING_ENABLED
        2763  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
        2764  {
        2765  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
        2766  }
        2767  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
        2768  {
        2769  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
        2770  }
        2771  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
        2772  {
        2773  snprintf(outStr, strLen, "%p", ptr);
        2774  }
        2775 #endif
        2776 
        2777 #ifndef VMA_MUTEX
        2778  class VmaMutex
        2779  {
        2780  public:
        2781  VmaMutex() { }
        2782  ~VmaMutex() { }
        2783  void Lock() { m_Mutex.lock(); }
        2784  void Unlock() { m_Mutex.unlock(); }
        2785  private:
        2786  std::mutex m_Mutex;
        2787  };
        2788  #define VMA_MUTEX VmaMutex
        2789 #endif
        2790 
        2791 /*
        2792 If providing your own implementation, you need to implement a subset of std::atomic:
        2793 
        2794 - Constructor(uint32_t desired)
        2795 - uint32_t load() const
        2796 - void store(uint32_t desired)
        2797 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
        2798 */
        2799 #ifndef VMA_ATOMIC_UINT32
        2800  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
        2801 #endif
        2802 
        2803 #ifndef VMA_BEST_FIT
        2804 
        2816  #define VMA_BEST_FIT (1)
        2817 #endif
        2818 
        2819 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
        2820 
        2824  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
        2825 #endif
        2826 
        2827 #ifndef VMA_DEBUG_ALIGNMENT
        2828 
        2832  #define VMA_DEBUG_ALIGNMENT (1)
        2833 #endif
        2834 
        2835 #ifndef VMA_DEBUG_MARGIN
        2836 
        2840  #define VMA_DEBUG_MARGIN (0)
        2841 #endif
        2842 
        2843 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
        2844 
        2848  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
        2849 #endif
        2850 
        2851 #ifndef VMA_DEBUG_DETECT_CORRUPTION
        2852 
        2857  #define VMA_DEBUG_DETECT_CORRUPTION (0)
        2858 #endif
        2859 
        2860 #ifndef VMA_DEBUG_GLOBAL_MUTEX
        2861 
        2865  #define VMA_DEBUG_GLOBAL_MUTEX (0)
        2866 #endif
        2867 
        2868 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
        2869 
        2873  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
        2874 #endif
        2875 
        2876 #ifndef VMA_SMALL_HEAP_MAX_SIZE
        2877  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
        2879 #endif
        2880 
        2881 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
        2882  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
        2884 #endif
        2885 
        2886 #ifndef VMA_CLASS_NO_COPY
        2887  #define VMA_CLASS_NO_COPY(className) \
        2888  private: \
        2889  className(const className&) = delete; \
        2890  className& operator=(const className&) = delete;
        2891 #endif
        2892 
        2893 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
        2894 
        2895 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
        2896 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
        2897 
        2898 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
        2899 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
        2900 
        2901 /*******************************************************************************
        2902 END OF CONFIGURATION
        2903 */
        2904 
        2905 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
        2906  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
        2907 
        2908 // Returns number of bits set to 1 in (v).
        2909 static inline uint32_t VmaCountBitsSet(uint32_t v)
        2910 {
        2911  uint32_t c = v - ((v >> 1) & 0x55555555);
        2912  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
        2913  c = ((c >> 4) + c) & 0x0F0F0F0F;
        2914  c = ((c >> 8) + c) & 0x00FF00FF;
        2915  c = ((c >> 16) + c) & 0x0000FFFF;
        2916  return c;
        2917 }
        2918 
        2919 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
        2920 // Use types like uint32_t, uint64_t as T.
        2921 template <typename T>
        2922 static inline T VmaAlignUp(T val, T align)
        2923 {
        2924  return (val + align - 1) / align * align;
        2925 }
        2926 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
        2927 // Use types like uint32_t, uint64_t as T.
        2928 template <typename T>
        2929 static inline T VmaAlignDown(T val, T align)
        2930 {
        2931  return val / align * align;
        2932 }
        2933 
        2934 // Division with mathematical rounding to nearest number.
        2935 template <typename T>
        2936 inline T VmaRoundDiv(T x, T y)
        2937 {
        2938  return (x + (y / (T)2)) / y;
        2939 }
        2940 
        2941 static inline bool VmaStrIsEmpty(const char* pStr)
        2942 {
        2943  return pStr == VMA_NULL || *pStr == '\0';
        2944 }
        2945 
        2946 #ifndef VMA_SORT
        2947 
        2948 template<typename Iterator, typename Compare>
        2949 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
        2950 {
        2951  Iterator centerValue = end; --centerValue;
        2952  Iterator insertIndex = beg;
        2953  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
        2954  {
        2955  if(cmp(*memTypeIndex, *centerValue))
        2956  {
        2957  if(insertIndex != memTypeIndex)
        2958  {
        2959  VMA_SWAP(*memTypeIndex, *insertIndex);
        2960  }
        2961  ++insertIndex;
        2962  }
        2963  }
        2964  if(insertIndex != centerValue)
        2965  {
        2966  VMA_SWAP(*insertIndex, *centerValue);
        2967  }
        2968  return insertIndex;
        2969 }
        2970 
        2971 template<typename Iterator, typename Compare>
        2972 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
        2973 {
        2974  if(beg < end)
        2975  {
        2976  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
        2977  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
        2978  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
        2979  }
        2980 }
        2981 
        2982 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
        2983 
        2984 #endif // #ifndef VMA_SORT
        2985 
        2986 /*
        2987 Returns true if two memory blocks occupy overlapping pages.
        2988 ResourceA must be in less memory offset than ResourceB.
        2989 
        2990 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
        2991 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
        2992 */
        2993 static inline bool VmaBlocksOnSamePage(
        2994  VkDeviceSize resourceAOffset,
        2995  VkDeviceSize resourceASize,
        2996  VkDeviceSize resourceBOffset,
        2997  VkDeviceSize pageSize)
        2998 {
        2999  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
        3000  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
        3001  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
        3002  VkDeviceSize resourceBStart = resourceBOffset;
        3003  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
        3004  return resourceAEndPage == resourceBStartPage;
        3005 }
        3006 
        3007 enum VmaSuballocationType
        3008 {
        3009  VMA_SUBALLOCATION_TYPE_FREE = 0,
        3010  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
        3011  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
        3012  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
        3013  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
        3014  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
        3015  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
        3016 };
        3017 
        3018 /*
        3019 Returns true if given suballocation types could conflict and must respect
        3020 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
        3021 or linear image and another one is optimal image. If type is unknown, behave
        3022 conservatively.
        3023 */
        3024 static inline bool VmaIsBufferImageGranularityConflict(
        3025  VmaSuballocationType suballocType1,
        3026  VmaSuballocationType suballocType2)
        3027 {
        3028  if(suballocType1 > suballocType2)
        3029  {
        3030  VMA_SWAP(suballocType1, suballocType2);
        3031  }
        3032 
        3033  switch(suballocType1)
        3034  {
        3035  case VMA_SUBALLOCATION_TYPE_FREE:
        3036  return false;
        3037  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
        3038  return true;
        3039  case VMA_SUBALLOCATION_TYPE_BUFFER:
        3040  return
        3041  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        3042  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        3043  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
        3044  return
        3045  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
        3046  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
        3047  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        3048  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
        3049  return
        3050  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
        3051  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
        3052  return false;
        3053  default:
        3054  VMA_ASSERT(0);
        3055  return true;
        3056  }
        3057 }
        3058 
        3059 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
        3060 {
        3061  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
        3062  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        3063  for(size_t i = 0; i < numberCount; ++i, ++pDst)
        3064  {
        3065  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
        3066  }
        3067 }
        3068 
        3069 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
        3070 {
        3071  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
        3072  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
        3073  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
        3074  {
        3075  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
        3076  {
        3077  return false;
        3078  }
        3079  }
        3080  return true;
        3081 }
        3082 
        3083 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
        3084 struct VmaMutexLock
        3085 {
        3086  VMA_CLASS_NO_COPY(VmaMutexLock)
        3087 public:
        3088  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
        3089  m_pMutex(useMutex ? &mutex : VMA_NULL)
        3090  {
        3091  if(m_pMutex)
        3092  {
        3093  m_pMutex->Lock();
        3094  }
        3095  }
        3096 
        3097  ~VmaMutexLock()
        3098  {
        3099  if(m_pMutex)
        3100  {
        3101  m_pMutex->Unlock();
        3102  }
        3103  }
        3104 
        3105 private:
        3106  VMA_MUTEX* m_pMutex;
        3107 };
        3108 
        3109 #if VMA_DEBUG_GLOBAL_MUTEX
        3110  static VMA_MUTEX gDebugGlobalMutex;
        3111  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
        3112 #else
        3113  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
        3114 #endif
        3115 
        3116 // Minimum size of a free suballocation to register it in the free suballocation collection.
        3117 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
        3118 
        3119 /*
        3120 Performs binary search and returns iterator to first element that is greater or
        3121 equal to (key), according to comparison (cmp).
        3122 
        3123 Cmp should return true if first argument is less than second argument.
        3124 
        3125 Returned value is the found element, if present in the collection or place where
        3126 new element with value (key) should be inserted.
        3127 */
        3128 template <typename CmpLess, typename IterT, typename KeyT>
        3129 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpLess cmp)
        3130 {
        3131  size_t down = 0, up = (end - beg);
        3132  while(down < up)
        3133  {
        3134  const size_t mid = (down + up) / 2;
        3135  if(cmp(*(beg+mid), key))
        3136  {
        3137  down = mid + 1;
        3138  }
        3139  else
        3140  {
        3141  up = mid;
        3142  }
        3143  }
        3144  return beg + down;
        3145 }
        3146 
        3148 // Memory allocation
        3149 
        3150 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
        3151 {
        3152  if((pAllocationCallbacks != VMA_NULL) &&
        3153  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
        3154  {
        3155  return (*pAllocationCallbacks->pfnAllocation)(
        3156  pAllocationCallbacks->pUserData,
        3157  size,
        3158  alignment,
        3159  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        3160  }
        3161  else
        3162  {
        3163  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
        3164  }
        3165 }
        3166 
        3167 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
        3168 {
        3169  if((pAllocationCallbacks != VMA_NULL) &&
        3170  (pAllocationCallbacks->pfnFree != VMA_NULL))
        3171  {
        3172  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
        3173  }
        3174  else
        3175  {
        3176  VMA_SYSTEM_FREE(ptr);
        3177  }
        3178 }
        3179 
        3180 template<typename T>
        3181 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
        3182 {
        3183  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
        3184 }
        3185 
        3186 template<typename T>
        3187 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
        3188 {
        3189  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
        3190 }
        3191 
        3192 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
        3193 
        3194 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
        3195 
        3196 template<typename T>
        3197 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
        3198 {
        3199  ptr->~T();
        3200  VmaFree(pAllocationCallbacks, ptr);
        3201 }
        3202 
        3203 template<typename T>
        3204 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
        3205 {
        3206  if(ptr != VMA_NULL)
        3207  {
        3208  for(size_t i = count; i--; )
        3209  {
        3210  ptr[i].~T();
        3211  }
        3212  VmaFree(pAllocationCallbacks, ptr);
        3213  }
        3214 }
        3215 
        3216 // STL-compatible allocator.
        3217 template<typename T>
        3218 class VmaStlAllocator
        3219 {
        3220 public:
        3221  const VkAllocationCallbacks* const m_pCallbacks;
        3222  typedef T value_type;
        3223 
        3224  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
        3225  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
        3226 
        3227  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
        3228  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
        3229 
        3230  template<typename U>
        3231  bool operator==(const VmaStlAllocator<U>& rhs) const
        3232  {
        3233  return m_pCallbacks == rhs.m_pCallbacks;
        3234  }
        3235  template<typename U>
        3236  bool operator!=(const VmaStlAllocator<U>& rhs) const
        3237  {
        3238  return m_pCallbacks != rhs.m_pCallbacks;
        3239  }
        3240 
        3241  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
        3242 };
        3243 
        3244 #if VMA_USE_STL_VECTOR
        3245 
        3246 #define VmaVector std::vector
        3247 
        3248 template<typename T, typename allocatorT>
        3249 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
        3250 {
        3251  vec.insert(vec.begin() + index, item);
        3252 }
        3253 
        3254 template<typename T, typename allocatorT>
        3255 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
        3256 {
        3257  vec.erase(vec.begin() + index);
        3258 }
        3259 
        3260 #else // #if VMA_USE_STL_VECTOR
        3261 
        3262 /* Class with interface compatible with subset of std::vector.
        3263 T must be POD because constructors and destructors are not called and memcpy is
        3264 used for these objects. */
        3265 template<typename T, typename AllocatorT>
        3266 class VmaVector
        3267 {
        3268 public:
        3269  typedef T value_type;
        3270 
        3271  VmaVector(const AllocatorT& allocator) :
        3272  m_Allocator(allocator),
        3273  m_pArray(VMA_NULL),
        3274  m_Count(0),
        3275  m_Capacity(0)
        3276  {
        3277  }
        3278 
        3279  VmaVector(size_t count, const AllocatorT& allocator) :
        3280  m_Allocator(allocator),
        3281  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
        3282  m_Count(count),
        3283  m_Capacity(count)
        3284  {
        3285  }
        3286 
        3287  VmaVector(const VmaVector<T, AllocatorT>& src) :
        3288  m_Allocator(src.m_Allocator),
        3289  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
        3290  m_Count(src.m_Count),
        3291  m_Capacity(src.m_Count)
        3292  {
        3293  if(m_Count != 0)
        3294  {
        3295  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
        3296  }
        3297  }
        3298 
        3299  ~VmaVector()
        3300  {
        3301  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        3302  }
        3303 
        3304  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
        3305  {
        3306  if(&rhs != this)
        3307  {
        3308  resize(rhs.m_Count);
        3309  if(m_Count != 0)
        3310  {
        3311  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
        3312  }
        3313  }
        3314  return *this;
        3315  }
        3316 
        3317  bool empty() const { return m_Count == 0; }
        3318  size_t size() const { return m_Count; }
        3319  T* data() { return m_pArray; }
        3320  const T* data() const { return m_pArray; }
        3321 
        3322  T& operator[](size_t index)
        3323  {
        3324  VMA_HEAVY_ASSERT(index < m_Count);
        3325  return m_pArray[index];
        3326  }
        3327  const T& operator[](size_t index) const
        3328  {
        3329  VMA_HEAVY_ASSERT(index < m_Count);
        3330  return m_pArray[index];
        3331  }
        3332 
        3333  T& front()
        3334  {
        3335  VMA_HEAVY_ASSERT(m_Count > 0);
        3336  return m_pArray[0];
        3337  }
        3338  const T& front() const
        3339  {
        3340  VMA_HEAVY_ASSERT(m_Count > 0);
        3341  return m_pArray[0];
        3342  }
        3343  T& back()
        3344  {
        3345  VMA_HEAVY_ASSERT(m_Count > 0);
        3346  return m_pArray[m_Count - 1];
        3347  }
        3348  const T& back() const
        3349  {
        3350  VMA_HEAVY_ASSERT(m_Count > 0);
        3351  return m_pArray[m_Count - 1];
        3352  }
        3353 
        3354  void reserve(size_t newCapacity, bool freeMemory = false)
        3355  {
        3356  newCapacity = VMA_MAX(newCapacity, m_Count);
        3357 
        3358  if((newCapacity < m_Capacity) && !freeMemory)
        3359  {
        3360  newCapacity = m_Capacity;
        3361  }
        3362 
        3363  if(newCapacity != m_Capacity)
        3364  {
        3365  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
        3366  if(m_Count != 0)
        3367  {
        3368  memcpy(newArray, m_pArray, m_Count * sizeof(T));
        3369  }
        3370  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        3371  m_Capacity = newCapacity;
        3372  m_pArray = newArray;
        3373  }
        3374  }
        3375 
        3376  void resize(size_t newCount, bool freeMemory = false)
        3377  {
        3378  size_t newCapacity = m_Capacity;
        3379  if(newCount > m_Capacity)
        3380  {
        3381  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
        3382  }
        3383  else if(freeMemory)
        3384  {
        3385  newCapacity = newCount;
        3386  }
        3387 
        3388  if(newCapacity != m_Capacity)
        3389  {
        3390  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
        3391  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
        3392  if(elementsToCopy != 0)
        3393  {
        3394  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
        3395  }
        3396  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
        3397  m_Capacity = newCapacity;
        3398  m_pArray = newArray;
        3399  }
        3400 
        3401  m_Count = newCount;
        3402  }
        3403 
        3404  void clear(bool freeMemory = false)
        3405  {
        3406  resize(0, freeMemory);
        3407  }
        3408 
        3409  void insert(size_t index, const T& src)
        3410  {
        3411  VMA_HEAVY_ASSERT(index <= m_Count);
        3412  const size_t oldCount = size();
        3413  resize(oldCount + 1);
        3414  if(index < oldCount)
        3415  {
        3416  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
        3417  }
        3418  m_pArray[index] = src;
        3419  }
        3420 
        3421  void remove(size_t index)
        3422  {
        3423  VMA_HEAVY_ASSERT(index < m_Count);
        3424  const size_t oldCount = size();
        3425  if(index < oldCount - 1)
        3426  {
        3427  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
        3428  }
        3429  resize(oldCount - 1);
        3430  }
        3431 
        3432  void push_back(const T& src)
        3433  {
        3434  const size_t newIndex = size();
        3435  resize(newIndex + 1);
        3436  m_pArray[newIndex] = src;
        3437  }
        3438 
        3439  void pop_back()
        3440  {
        3441  VMA_HEAVY_ASSERT(m_Count > 0);
        3442  resize(size() - 1);
        3443  }
        3444 
        3445  void push_front(const T& src)
        3446  {
        3447  insert(0, src);
        3448  }
        3449 
        3450  void pop_front()
        3451  {
        3452  VMA_HEAVY_ASSERT(m_Count > 0);
        3453  remove(0);
        3454  }
        3455 
        3456  typedef T* iterator;
        3457 
        3458  iterator begin() { return m_pArray; }
        3459  iterator end() { return m_pArray + m_Count; }
        3460 
        3461 private:
        3462  AllocatorT m_Allocator;
        3463  T* m_pArray;
        3464  size_t m_Count;
        3465  size_t m_Capacity;
        3466 };
        3467 
        3468 template<typename T, typename allocatorT>
        3469 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
        3470 {
        3471  vec.insert(index, item);
        3472 }
        3473 
        3474 template<typename T, typename allocatorT>
        3475 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
        3476 {
        3477  vec.remove(index);
        3478 }
        3479 
        3480 #endif // #if VMA_USE_STL_VECTOR
        3481 
        3482 template<typename CmpLess, typename VectorT>
        3483 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
        3484 {
        3485  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        3486  vector.data(),
        3487  vector.data() + vector.size(),
        3488  value,
        3489  CmpLess()) - vector.data();
        3490  VmaVectorInsert(vector, indexToInsert, value);
        3491  return indexToInsert;
        3492 }
        3493 
        3494 template<typename CmpLess, typename VectorT>
        3495 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
        3496 {
        3497  CmpLess comparator;
        3498  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
        3499  vector.begin(),
        3500  vector.end(),
        3501  value,
        3502  comparator);
        3503  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
        3504  {
        3505  size_t indexToRemove = it - vector.begin();
        3506  VmaVectorRemove(vector, indexToRemove);
        3507  return true;
        3508  }
        3509  return false;
        3510 }
        3511 
        3512 template<typename CmpLess, typename IterT, typename KeyT>
        3513 IterT VmaVectorFindSorted(const IterT& beg, const IterT& end, const KeyT& value)
        3514 {
        3515  CmpLess comparator;
        3516  typename IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
        3517  beg, end, value, comparator);
        3518  if(it == end ||
        3519  !comparator(*it, value) && !comparator(value, *it))
        3520  {
        3521  return it;
        3522  }
        3523  return end;
        3524 }
        3525 
        3527 // class VmaPoolAllocator
        3528 
        3529 /*
        3530 Allocator for objects of type T using a list of arrays (pools) to speed up
        3531 allocation. Number of elements that can be allocated is not bounded because
        3532 allocator can create multiple blocks.
        3533 */
        3534 template<typename T>
        3535 class VmaPoolAllocator
        3536 {
        3537  VMA_CLASS_NO_COPY(VmaPoolAllocator)
        3538 public:
        3539  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
        3540  ~VmaPoolAllocator();
        3541  void Clear();
        3542  T* Alloc();
        3543  void Free(T* ptr);
        3544 
        3545 private:
        3546  union Item
        3547  {
        3548  uint32_t NextFreeIndex;
        3549  T Value;
        3550  };
        3551 
        3552  struct ItemBlock
        3553  {
        3554  Item* pItems;
        3555  uint32_t FirstFreeIndex;
        3556  };
        3557 
        3558  const VkAllocationCallbacks* m_pAllocationCallbacks;
        3559  size_t m_ItemsPerBlock;
        3560  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
        3561 
        3562  ItemBlock& CreateNewBlock();
        3563 };
        3564 
        3565 template<typename T>
        3566 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
        3567  m_pAllocationCallbacks(pAllocationCallbacks),
        3568  m_ItemsPerBlock(itemsPerBlock),
        3569  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
        3570 {
        3571  VMA_ASSERT(itemsPerBlock > 0);
        3572 }
        3573 
        3574 template<typename T>
        3575 VmaPoolAllocator<T>::~VmaPoolAllocator()
        3576 {
        3577  Clear();
        3578 }
        3579 
        3580 template<typename T>
        3581 void VmaPoolAllocator<T>::Clear()
        3582 {
        3583  for(size_t i = m_ItemBlocks.size(); i--; )
        3584  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
        3585  m_ItemBlocks.clear();
        3586 }
        3587 
        3588 template<typename T>
        3589 T* VmaPoolAllocator<T>::Alloc()
        3590 {
        3591  for(size_t i = m_ItemBlocks.size(); i--; )
        3592  {
        3593  ItemBlock& block = m_ItemBlocks[i];
        3594  // This block has some free items: Use first one.
        3595  if(block.FirstFreeIndex != UINT32_MAX)
        3596  {
        3597  Item* const pItem = &block.pItems[block.FirstFreeIndex];
        3598  block.FirstFreeIndex = pItem->NextFreeIndex;
        3599  return &pItem->Value;
        3600  }
        3601  }
        3602 
        3603  // No block has free item: Create new one and use it.
        3604  ItemBlock& newBlock = CreateNewBlock();
        3605  Item* const pItem = &newBlock.pItems[0];
        3606  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
        3607  return &pItem->Value;
        3608 }
        3609 
        3610 template<typename T>
        3611 void VmaPoolAllocator<T>::Free(T* ptr)
        3612 {
        3613  // Search all memory blocks to find ptr.
        3614  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
        3615  {
        3616  ItemBlock& block = m_ItemBlocks[i];
        3617 
        3618  // Casting to union.
        3619  Item* pItemPtr;
        3620  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
        3621 
        3622  // Check if pItemPtr is in address range of this block.
        3623  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
        3624  {
        3625  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
        3626  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
        3627  block.FirstFreeIndex = index;
        3628  return;
        3629  }
        3630  }
        3631  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
        3632 }
        3633 
        3634 template<typename T>
        3635 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
        3636 {
        3637  ItemBlock newBlock = {
        3638  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
        3639 
        3640  m_ItemBlocks.push_back(newBlock);
        3641 
        3642  // Setup singly-linked list of all free items in this block.
        3643  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
        3644  newBlock.pItems[i].NextFreeIndex = i + 1;
        3645  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
        3646  return m_ItemBlocks.back();
        3647 }
        3648 
        3650 // class VmaRawList, VmaList
        3651 
        3652 #if VMA_USE_STL_LIST
        3653 
        3654 #define VmaList std::list
        3655 
        3656 #else // #if VMA_USE_STL_LIST
        3657 
        3658 template<typename T>
        3659 struct VmaListItem
        3660 {
        3661  VmaListItem* pPrev;
        3662  VmaListItem* pNext;
        3663  T Value;
        3664 };
        3665 
        3666 // Doubly linked list.
        3667 template<typename T>
        3668 class VmaRawList
        3669 {
        3670  VMA_CLASS_NO_COPY(VmaRawList)
        3671 public:
        3672  typedef VmaListItem<T> ItemType;
        3673 
        3674  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
        3675  ~VmaRawList();
        3676  void Clear();
        3677 
        3678  size_t GetCount() const { return m_Count; }
        3679  bool IsEmpty() const { return m_Count == 0; }
        3680 
        3681  ItemType* Front() { return m_pFront; }
        3682  const ItemType* Front() const { return m_pFront; }
        3683  ItemType* Back() { return m_pBack; }
        3684  const ItemType* Back() const { return m_pBack; }
        3685 
        3686  ItemType* PushBack();
        3687  ItemType* PushFront();
        3688  ItemType* PushBack(const T& value);
        3689  ItemType* PushFront(const T& value);
        3690  void PopBack();
        3691  void PopFront();
        3692 
        3693  // Item can be null - it means PushBack.
        3694  ItemType* InsertBefore(ItemType* pItem);
        3695  // Item can be null - it means PushFront.
        3696  ItemType* InsertAfter(ItemType* pItem);
        3697 
        3698  ItemType* InsertBefore(ItemType* pItem, const T& value);
        3699  ItemType* InsertAfter(ItemType* pItem, const T& value);
        3700 
        3701  void Remove(ItemType* pItem);
        3702 
        3703 private:
        3704  const VkAllocationCallbacks* const m_pAllocationCallbacks;
        3705  VmaPoolAllocator<ItemType> m_ItemAllocator;
        3706  ItemType* m_pFront;
        3707  ItemType* m_pBack;
        3708  size_t m_Count;
        3709 };
        3710 
        3711 template<typename T>
        3712 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
        3713  m_pAllocationCallbacks(pAllocationCallbacks),
        3714  m_ItemAllocator(pAllocationCallbacks, 128),
        3715  m_pFront(VMA_NULL),
        3716  m_pBack(VMA_NULL),
        3717  m_Count(0)
        3718 {
        3719 }
        3720 
        3721 template<typename T>
        3722 VmaRawList<T>::~VmaRawList()
        3723 {
        3724  // Intentionally not calling Clear, because that would be unnecessary
        3725  // computations to return all items to m_ItemAllocator as free.
        3726 }
        3727 
        3728 template<typename T>
        3729 void VmaRawList<T>::Clear()
        3730 {
        3731  if(IsEmpty() == false)
        3732  {
        3733  ItemType* pItem = m_pBack;
        3734  while(pItem != VMA_NULL)
        3735  {
        3736  ItemType* const pPrevItem = pItem->pPrev;
        3737  m_ItemAllocator.Free(pItem);
        3738  pItem = pPrevItem;
        3739  }
        3740  m_pFront = VMA_NULL;
        3741  m_pBack = VMA_NULL;
        3742  m_Count = 0;
        3743  }
        3744 }
        3745 
        3746 template<typename T>
        3747 VmaListItem<T>* VmaRawList<T>::PushBack()
        3748 {
        3749  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        3750  pNewItem->pNext = VMA_NULL;
        3751  if(IsEmpty())
        3752  {
        3753  pNewItem->pPrev = VMA_NULL;
        3754  m_pFront = pNewItem;
        3755  m_pBack = pNewItem;
        3756  m_Count = 1;
        3757  }
        3758  else
        3759  {
        3760  pNewItem->pPrev = m_pBack;
        3761  m_pBack->pNext = pNewItem;
        3762  m_pBack = pNewItem;
        3763  ++m_Count;
        3764  }
        3765  return pNewItem;
        3766 }
        3767 
        3768 template<typename T>
        3769 VmaListItem<T>* VmaRawList<T>::PushFront()
        3770 {
        3771  ItemType* const pNewItem = m_ItemAllocator.Alloc();
        3772  pNewItem->pPrev = VMA_NULL;
        3773  if(IsEmpty())
        3774  {
        3775  pNewItem->pNext = VMA_NULL;
        3776  m_pFront = pNewItem;
        3777  m_pBack = pNewItem;
        3778  m_Count = 1;
        3779  }
        3780  else
        3781  {
        3782  pNewItem->pNext = m_pFront;
        3783  m_pFront->pPrev = pNewItem;
        3784  m_pFront = pNewItem;
        3785  ++m_Count;
        3786  }
        3787  return pNewItem;
        3788 }
        3789 
        3790 template<typename T>
        3791 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
        3792 {
        3793  ItemType* const pNewItem = PushBack();
        3794  pNewItem->Value = value;
        3795  return pNewItem;
        3796 }
        3797 
        3798 template<typename T>
        3799 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
        3800 {
        3801  ItemType* const pNewItem = PushFront();
        3802  pNewItem->Value = value;
        3803  return pNewItem;
        3804 }
        3805 
        3806 template<typename T>
        3807 void VmaRawList<T>::PopBack()
        3808 {
        3809  VMA_HEAVY_ASSERT(m_Count > 0);
        3810  ItemType* const pBackItem = m_pBack;
        3811  ItemType* const pPrevItem = pBackItem->pPrev;
        3812  if(pPrevItem != VMA_NULL)
        3813  {
        3814  pPrevItem->pNext = VMA_NULL;
        3815  }
        3816  m_pBack = pPrevItem;
        3817  m_ItemAllocator.Free(pBackItem);
        3818  --m_Count;
        3819 }
        3820 
        3821 template<typename T>
        3822 void VmaRawList<T>::PopFront()
        3823 {
        3824  VMA_HEAVY_ASSERT(m_Count > 0);
        3825  ItemType* const pFrontItem = m_pFront;
        3826  ItemType* const pNextItem = pFrontItem->pNext;
        3827  if(pNextItem != VMA_NULL)
        3828  {
        3829  pNextItem->pPrev = VMA_NULL;
        3830  }
        3831  m_pFront = pNextItem;
        3832  m_ItemAllocator.Free(pFrontItem);
        3833  --m_Count;
        3834 }
        3835 
        3836 template<typename T>
        3837 void VmaRawList<T>::Remove(ItemType* pItem)
        3838 {
        3839  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
        3840  VMA_HEAVY_ASSERT(m_Count > 0);
        3841 
        3842  if(pItem->pPrev != VMA_NULL)
        3843  {
        3844  pItem->pPrev->pNext = pItem->pNext;
        3845  }
        3846  else
        3847  {
        3848  VMA_HEAVY_ASSERT(m_pFront == pItem);
        3849  m_pFront = pItem->pNext;
        3850  }
        3851 
        3852  if(pItem->pNext != VMA_NULL)
        3853  {
        3854  pItem->pNext->pPrev = pItem->pPrev;
        3855  }
        3856  else
        3857  {
        3858  VMA_HEAVY_ASSERT(m_pBack == pItem);
        3859  m_pBack = pItem->pPrev;
        3860  }
        3861 
        3862  m_ItemAllocator.Free(pItem);
        3863  --m_Count;
        3864 }
        3865 
        3866 template<typename T>
        3867 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
        3868 {
        3869  if(pItem != VMA_NULL)
        3870  {
        3871  ItemType* const prevItem = pItem->pPrev;
        3872  ItemType* const newItem = m_ItemAllocator.Alloc();
        3873  newItem->pPrev = prevItem;
        3874  newItem->pNext = pItem;
        3875  pItem->pPrev = newItem;
        3876  if(prevItem != VMA_NULL)
        3877  {
        3878  prevItem->pNext = newItem;
        3879  }
        3880  else
        3881  {
        3882  VMA_HEAVY_ASSERT(m_pFront == pItem);
        3883  m_pFront = newItem;
        3884  }
        3885  ++m_Count;
        3886  return newItem;
        3887  }
        3888  else
        3889  return PushBack();
        3890 }
        3891 
        3892 template<typename T>
        3893 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
        3894 {
        3895  if(pItem != VMA_NULL)
        3896  {
        3897  ItemType* const nextItem = pItem->pNext;
        3898  ItemType* const newItem = m_ItemAllocator.Alloc();
        3899  newItem->pNext = nextItem;
        3900  newItem->pPrev = pItem;
        3901  pItem->pNext = newItem;
        3902  if(nextItem != VMA_NULL)
        3903  {
        3904  nextItem->pPrev = newItem;
        3905  }
        3906  else
        3907  {
        3908  VMA_HEAVY_ASSERT(m_pBack == pItem);
        3909  m_pBack = newItem;
        3910  }
        3911  ++m_Count;
        3912  return newItem;
        3913  }
        3914  else
        3915  return PushFront();
        3916 }
        3917 
        3918 template<typename T>
        3919 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
        3920 {
        3921  ItemType* const newItem = InsertBefore(pItem);
        3922  newItem->Value = value;
        3923  return newItem;
        3924 }
        3925 
        3926 template<typename T>
        3927 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
        3928 {
        3929  ItemType* const newItem = InsertAfter(pItem);
        3930  newItem->Value = value;
        3931  return newItem;
        3932 }
        3933 
        3934 template<typename T, typename AllocatorT>
        3935 class VmaList
        3936 {
        3937  VMA_CLASS_NO_COPY(VmaList)
        3938 public:
        3939  class iterator
        3940  {
        3941  public:
        3942  iterator() :
        3943  m_pList(VMA_NULL),
        3944  m_pItem(VMA_NULL)
        3945  {
        3946  }
        3947 
        3948  T& operator*() const
        3949  {
        3950  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        3951  return m_pItem->Value;
        3952  }
        3953  T* operator->() const
        3954  {
        3955  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        3956  return &m_pItem->Value;
        3957  }
        3958 
        3959  iterator& operator++()
        3960  {
        3961  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        3962  m_pItem = m_pItem->pNext;
        3963  return *this;
        3964  }
        3965  iterator& operator--()
        3966  {
        3967  if(m_pItem != VMA_NULL)
        3968  {
        3969  m_pItem = m_pItem->pPrev;
        3970  }
        3971  else
        3972  {
        3973  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        3974  m_pItem = m_pList->Back();
        3975  }
        3976  return *this;
        3977  }
        3978 
        3979  iterator operator++(int)
        3980  {
        3981  iterator result = *this;
        3982  ++*this;
        3983  return result;
        3984  }
        3985  iterator operator--(int)
        3986  {
        3987  iterator result = *this;
        3988  --*this;
        3989  return result;
        3990  }
        3991 
        3992  bool operator==(const iterator& rhs) const
        3993  {
        3994  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        3995  return m_pItem == rhs.m_pItem;
        3996  }
        3997  bool operator!=(const iterator& rhs) const
        3998  {
        3999  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        4000  return m_pItem != rhs.m_pItem;
        4001  }
        4002 
        4003  private:
        4004  VmaRawList<T>* m_pList;
        4005  VmaListItem<T>* m_pItem;
        4006 
        4007  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
        4008  m_pList(pList),
        4009  m_pItem(pItem)
        4010  {
        4011  }
        4012 
        4013  friend class VmaList<T, AllocatorT>;
        4014  };
        4015 
        4016  class const_iterator
        4017  {
        4018  public:
        4019  const_iterator() :
        4020  m_pList(VMA_NULL),
        4021  m_pItem(VMA_NULL)
        4022  {
        4023  }
        4024 
        4025  const_iterator(const iterator& src) :
        4026  m_pList(src.m_pList),
        4027  m_pItem(src.m_pItem)
        4028  {
        4029  }
        4030 
        4031  const T& operator*() const
        4032  {
        4033  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        4034  return m_pItem->Value;
        4035  }
        4036  const T* operator->() const
        4037  {
        4038  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        4039  return &m_pItem->Value;
        4040  }
        4041 
        4042  const_iterator& operator++()
        4043  {
        4044  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
        4045  m_pItem = m_pItem->pNext;
        4046  return *this;
        4047  }
        4048  const_iterator& operator--()
        4049  {
        4050  if(m_pItem != VMA_NULL)
        4051  {
        4052  m_pItem = m_pItem->pPrev;
        4053  }
        4054  else
        4055  {
        4056  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
        4057  m_pItem = m_pList->Back();
        4058  }
        4059  return *this;
        4060  }
        4061 
        4062  const_iterator operator++(int)
        4063  {
        4064  const_iterator result = *this;
        4065  ++*this;
        4066  return result;
        4067  }
        4068  const_iterator operator--(int)
        4069  {
        4070  const_iterator result = *this;
        4071  --*this;
        4072  return result;
        4073  }
        4074 
        4075  bool operator==(const const_iterator& rhs) const
        4076  {
        4077  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        4078  return m_pItem == rhs.m_pItem;
        4079  }
        4080  bool operator!=(const const_iterator& rhs) const
        4081  {
        4082  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
        4083  return m_pItem != rhs.m_pItem;
        4084  }
        4085 
        4086  private:
        4087  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
        4088  m_pList(pList),
        4089  m_pItem(pItem)
        4090  {
        4091  }
        4092 
        4093  const VmaRawList<T>* m_pList;
        4094  const VmaListItem<T>* m_pItem;
        4095 
        4096  friend class VmaList<T, AllocatorT>;
        4097  };
        4098 
        4099  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
        4100 
        4101  bool empty() const { return m_RawList.IsEmpty(); }
        4102  size_t size() const { return m_RawList.GetCount(); }
        4103 
        4104  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
        4105  iterator end() { return iterator(&m_RawList, VMA_NULL); }
        4106 
        4107  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
        4108  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
        4109 
        4110  void clear() { m_RawList.Clear(); }
        4111  void push_back(const T& value) { m_RawList.PushBack(value); }
        4112  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
        4113  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
        4114 
        4115 private:
        4116  VmaRawList<T> m_RawList;
        4117 };
        4118 
        4119 #endif // #if VMA_USE_STL_LIST
        4120 
        4122 // class VmaMap
        4123 
        4124 // Unused in this version.
        4125 #if 0
        4126 
        4127 #if VMA_USE_STL_UNORDERED_MAP
        4128 
        4129 #define VmaPair std::pair
        4130 
        4131 #define VMA_MAP_TYPE(KeyT, ValueT) \
        4132  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
        4133 
        4134 #else // #if VMA_USE_STL_UNORDERED_MAP
        4135 
        4136 template<typename T1, typename T2>
        4137 struct VmaPair
        4138 {
        4139  T1 first;
        4140  T2 second;
        4141 
        4142  VmaPair() : first(), second() { }
        4143  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
        4144 };
        4145 
        4146 /* Class compatible with subset of interface of std::unordered_map.
        4147 KeyT, ValueT must be POD because they will be stored in VmaVector.
        4148 */
        4149 template<typename KeyT, typename ValueT>
        4150 class VmaMap
        4151 {
        4152 public:
        4153  typedef VmaPair<KeyT, ValueT> PairType;
        4154  typedef PairType* iterator;
        4155 
        4156  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
        4157 
        4158  iterator begin() { return m_Vector.begin(); }
        4159  iterator end() { return m_Vector.end(); }
        4160 
        4161  void insert(const PairType& pair);
        4162  iterator find(const KeyT& key);
        4163  void erase(iterator it);
        4164 
        4165 private:
        4166  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
        4167 };
        4168 
        4169 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
        4170 
        4171 template<typename FirstT, typename SecondT>
        4172 struct VmaPairFirstLess
        4173 {
        4174  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
        4175  {
        4176  return lhs.first < rhs.first;
        4177  }
        4178  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
        4179  {
        4180  return lhs.first < rhsFirst;
        4181  }
        4182 };
        4183 
        4184 template<typename KeyT, typename ValueT>
        4185 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
        4186 {
        4187  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
        4188  m_Vector.data(),
        4189  m_Vector.data() + m_Vector.size(),
        4190  pair,
        4191  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
        4192  VmaVectorInsert(m_Vector, indexToInsert, pair);
        4193 }
        4194 
        4195 template<typename KeyT, typename ValueT>
        4196 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
        4197 {
        4198  PairType* it = VmaBinaryFindFirstNotLess(
        4199  m_Vector.data(),
        4200  m_Vector.data() + m_Vector.size(),
        4201  key,
        4202  VmaPairFirstLess<KeyT, ValueT>());
        4203  if((it != m_Vector.end()) && (it->first == key))
        4204  {
        4205  return it;
        4206  }
        4207  else
        4208  {
        4209  return m_Vector.end();
        4210  }
        4211 }
        4212 
        4213 template<typename KeyT, typename ValueT>
        4214 void VmaMap<KeyT, ValueT>::erase(iterator it)
        4215 {
        4216  VmaVectorRemove(m_Vector, it - m_Vector.begin());
        4217 }
        4218 
        4219 #endif // #if VMA_USE_STL_UNORDERED_MAP
        4220 
        4221 #endif // #if 0
        4222 
        4224 
        4225 class VmaDeviceMemoryBlock;
        4226 
        4227 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
        4228 
        4229 struct VmaAllocation_T
        4230 {
        4231  VMA_CLASS_NO_COPY(VmaAllocation_T)
        4232 private:
        4233  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
        4234 
        4235  enum FLAGS
        4236  {
        4237  FLAG_USER_DATA_STRING = 0x01,
        4238  };
        4239 
        4240 public:
        4241  enum ALLOCATION_TYPE
        4242  {
        4243  ALLOCATION_TYPE_NONE,
        4244  ALLOCATION_TYPE_BLOCK,
        4245  ALLOCATION_TYPE_DEDICATED,
        4246  };
        4247 
        4248  VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
        4249  m_Alignment(1),
        4250  m_Size(0),
        4251  m_pUserData(VMA_NULL),
        4252  m_LastUseFrameIndex(currentFrameIndex),
        4253  m_Type((uint8_t)ALLOCATION_TYPE_NONE),
        4254  m_SuballocationType((uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN),
        4255  m_MapCount(0),
        4256  m_Flags(userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0)
        4257  {
        4258 #if VMA_STATS_STRING_ENABLED
        4259  m_CreationFrameIndex = currentFrameIndex;
        4260  m_BufferImageUsage = 0;
        4261 #endif
        4262  }
        4263 
        4264  ~VmaAllocation_T()
        4265  {
        4266  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
        4267 
        4268  // Check if owned string was freed.
        4269  VMA_ASSERT(m_pUserData == VMA_NULL);
        4270  }
        4271 
        4272  void InitBlockAllocation(
        4273  VmaPool hPool,
        4274  VmaDeviceMemoryBlock* block,
        4275  VkDeviceSize offset,
        4276  VkDeviceSize alignment,
        4277  VkDeviceSize size,
        4278  VmaSuballocationType suballocationType,
        4279  bool mapped,
        4280  bool canBecomeLost)
        4281  {
        4282  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        4283  VMA_ASSERT(block != VMA_NULL);
        4284  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        4285  m_Alignment = alignment;
        4286  m_Size = size;
        4287  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        4288  m_SuballocationType = (uint8_t)suballocationType;
        4289  m_BlockAllocation.m_hPool = hPool;
        4290  m_BlockAllocation.m_Block = block;
        4291  m_BlockAllocation.m_Offset = offset;
        4292  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
        4293  }
        4294 
        4295  void InitLost()
        4296  {
        4297  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        4298  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
        4299  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
        4300  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
        4301  m_BlockAllocation.m_Block = VMA_NULL;
        4302  m_BlockAllocation.m_Offset = 0;
        4303  m_BlockAllocation.m_CanBecomeLost = true;
        4304  }
        4305 
        4306  void ChangeBlockAllocation(
        4307  VmaAllocator hAllocator,
        4308  VmaDeviceMemoryBlock* block,
        4309  VkDeviceSize offset);
        4310 
        4311  // pMappedData not null means allocation is created with MAPPED flag.
        4312  void InitDedicatedAllocation(
        4313  uint32_t memoryTypeIndex,
        4314  VkDeviceMemory hMemory,
        4315  VmaSuballocationType suballocationType,
        4316  void* pMappedData,
        4317  VkDeviceSize size)
        4318  {
        4319  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
        4320  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
        4321  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
        4322  m_Alignment = 0;
        4323  m_Size = size;
        4324  m_SuballocationType = (uint8_t)suballocationType;
        4325  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
        4326  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
        4327  m_DedicatedAllocation.m_hMemory = hMemory;
        4328  m_DedicatedAllocation.m_pMappedData = pMappedData;
        4329  }
        4330 
        4331  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
        4332  VkDeviceSize GetAlignment() const { return m_Alignment; }
        4333  VkDeviceSize GetSize() const { return m_Size; }
        4334  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
        4335  void* GetUserData() const { return m_pUserData; }
        4336  void SetUserData(VmaAllocator hAllocator, void* pUserData);
        4337  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
        4338 
        4339  VmaDeviceMemoryBlock* GetBlock() const
        4340  {
        4341  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        4342  return m_BlockAllocation.m_Block;
        4343  }
        4344  VkDeviceSize GetOffset() const;
        4345  VkDeviceMemory GetMemory() const;
        4346  uint32_t GetMemoryTypeIndex() const;
        4347  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
        4348  void* GetMappedData() const;
        4349  bool CanBecomeLost() const;
        4350  VmaPool GetPool() const;
        4351 
        4352  uint32_t GetLastUseFrameIndex() const
        4353  {
        4354  return m_LastUseFrameIndex.load();
        4355  }
        4356  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
        4357  {
        4358  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
        4359  }
        4360  /*
        4361  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
        4362  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
        4363  - Else, returns false.
        4364 
        4365  If hAllocation is already lost, assert - you should not call it then.
        4366  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
        4367  */
        4368  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        4369 
        4370  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
        4371  {
        4372  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
        4373  outInfo.blockCount = 1;
        4374  outInfo.allocationCount = 1;
        4375  outInfo.unusedRangeCount = 0;
        4376  outInfo.usedBytes = m_Size;
        4377  outInfo.unusedBytes = 0;
        4378  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
        4379  outInfo.unusedRangeSizeMin = UINT64_MAX;
        4380  outInfo.unusedRangeSizeMax = 0;
        4381  }
        4382 
        4383  void BlockAllocMap();
        4384  void BlockAllocUnmap();
        4385  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
        4386  void DedicatedAllocUnmap(VmaAllocator hAllocator);
        4387 
        4388 #if VMA_STATS_STRING_ENABLED
        4389  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
        4390  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
        4391 
        4392  void InitBufferImageUsage(uint32_t bufferImageUsage)
        4393  {
        4394  VMA_ASSERT(m_BufferImageUsage == 0);
        4395  m_BufferImageUsage = bufferImageUsage;
        4396  }
        4397 
        4398  void PrintParameters(class VmaJsonWriter& json) const;
        4399 #endif
        4400 
        4401 private:
        4402  VkDeviceSize m_Alignment;
        4403  VkDeviceSize m_Size;
        4404  void* m_pUserData;
        4405  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
        4406  uint8_t m_Type; // ALLOCATION_TYPE
        4407  uint8_t m_SuballocationType; // VmaSuballocationType
        4408  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
        4409  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
        4410  uint8_t m_MapCount;
        4411  uint8_t m_Flags; // enum FLAGS
        4412 
        4413  // Allocation out of VmaDeviceMemoryBlock.
        4414  struct BlockAllocation
        4415  {
        4416  VmaPool m_hPool; // Null if belongs to general memory.
        4417  VmaDeviceMemoryBlock* m_Block;
        4418  VkDeviceSize m_Offset;
        4419  bool m_CanBecomeLost;
        4420  };
        4421 
        4422  // Allocation for an object that has its own private VkDeviceMemory.
        4423  struct DedicatedAllocation
        4424  {
        4425  uint32_t m_MemoryTypeIndex;
        4426  VkDeviceMemory m_hMemory;
        4427  void* m_pMappedData; // Not null means memory is mapped.
        4428  };
        4429 
        4430  union
        4431  {
        4432  // Allocation out of VmaDeviceMemoryBlock.
        4433  BlockAllocation m_BlockAllocation;
        4434  // Allocation for an object that has its own private VkDeviceMemory.
        4435  DedicatedAllocation m_DedicatedAllocation;
        4436  };
        4437 
        4438 #if VMA_STATS_STRING_ENABLED
        4439  uint32_t m_CreationFrameIndex;
        4440  uint32_t m_BufferImageUsage; // 0 if unknown.
        4441 #endif
        4442 
        4443  void FreeUserDataString(VmaAllocator hAllocator);
        4444 };
        4445 
        4446 /*
        4447 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
        4448 allocated memory block or free.
        4449 */
        4450 struct VmaSuballocation
        4451 {
        4452  VkDeviceSize offset;
        4453  VkDeviceSize size;
        4454  VmaAllocation hAllocation;
        4455  VmaSuballocationType type;
        4456 };
        4457 
        4458 // Comparator for offsets.
        4459 struct VmaSuballocationOffsetLess
        4460 {
        4461  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        4462  {
        4463  return lhs.offset < rhs.offset;
        4464  }
        4465 };
        4466 struct VmaSuballocationOffsetGreater
        4467 {
        4468  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
        4469  {
        4470  return lhs.offset > rhs.offset;
        4471  }
        4472 };
        4473 
        4474 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
        4475 
        4476 // Cost of one additional allocation lost, as equivalent in bytes.
        4477 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
        4478 
        4479 /*
        4480 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
        4481 
        4482 If canMakeOtherLost was false:
        4483 - item points to a FREE suballocation.
        4484 - itemsToMakeLostCount is 0.
        4485 
        4486 If canMakeOtherLost was true:
        4487 - item points to first of sequence of suballocations, which are either FREE,
        4488  or point to VmaAllocations that can become lost.
        4489 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
        4490  the requested allocation to succeed.
        4491 */
        4492 struct VmaAllocationRequest
        4493 {
        4494  VkDeviceSize offset;
        4495  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
        4496  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
        4497  VmaSuballocationList::iterator item;
        4498  size_t itemsToMakeLostCount;
        4499 
        4500  VkDeviceSize CalcCost() const
        4501  {
        4502  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
        4503  }
        4504 };
        4505 
        4506 /*
        4507 Data structure used for bookkeeping of allocations and unused ranges of memory
        4508 in a single VkDeviceMemory block.
        4509 */
        4510 class VmaBlockMetadata
        4511 {
        4512 public:
        4513  VmaBlockMetadata() : m_Size(0) { }
        4514  virtual ~VmaBlockMetadata() { }
        4515  virtual void Init(VkDeviceSize size) { m_Size = size; }
        4516 
        4517  // Validates all data structures inside this object. If not valid, returns false.
        4518  virtual bool Validate() const = 0;
        4519  VkDeviceSize GetSize() const { return m_Size; }
        4520  virtual size_t GetAllocationCount() const = 0;
        4521  virtual VkDeviceSize GetSumFreeSize() const = 0;
        4522  virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
        4523  // Returns true if this block is empty - contains only single free suballocation.
        4524  virtual bool IsEmpty() const = 0;
        4525 
        4526  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
        4527  // Shouldn't modify blockCount.
        4528  virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
        4529 
        4530 #if VMA_STATS_STRING_ENABLED
        4531  virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
        4532 #endif
        4533 
        4534  // Tries to find a place for suballocation with given parameters inside this block.
        4535  // If succeeded, fills pAllocationRequest and returns true.
        4536  // If failed, returns false.
        4537  virtual bool CreateAllocationRequest(
        4538  uint32_t currentFrameIndex,
        4539  uint32_t frameInUseCount,
        4540  VkDeviceSize bufferImageGranularity,
        4541  VkDeviceSize allocSize,
        4542  VkDeviceSize allocAlignment,
        4543  bool upperAddress,
        4544  VmaSuballocationType allocType,
        4545  bool canMakeOtherLost,
        4546  VmaAllocationRequest* pAllocationRequest) = 0;
        4547 
        4548  virtual bool MakeRequestedAllocationsLost(
        4549  uint32_t currentFrameIndex,
        4550  uint32_t frameInUseCount,
        4551  VmaAllocationRequest* pAllocationRequest) = 0;
        4552 
        4553  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
        4554 
        4555  virtual VkResult CheckCorruption(const void* pBlockData) = 0;
        4556 
        4557  // Makes actual allocation based on request. Request must already be checked and valid.
        4558  virtual void Alloc(
        4559  const VmaAllocationRequest& request,
        4560  VmaSuballocationType type,
        4561  VkDeviceSize allocSize,
        4562  bool upperAddress,
        4563  VmaAllocation hAllocation) = 0;
        4564 
        4565  // Frees suballocation assigned to given memory region.
        4566  virtual void Free(const VmaAllocation allocation) = 0;
        4567  virtual void FreeAtOffset(VkDeviceSize offset) = 0;
        4568 
        4569 protected:
        4570 #if VMA_STATS_STRING_ENABLED
        4571  void PrintDetailedMap_Begin(class VmaJsonWriter& json,
        4572  VkDeviceSize unusedBytes,
        4573  size_t allocationCount,
        4574  size_t unusedRangeCount) const;
        4575  void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        4576  VkDeviceSize offset,
        4577  VmaAllocation hAllocation) const;
        4578  void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        4579  VkDeviceSize offset,
        4580  VkDeviceSize size) const;
        4581  void PrintDetailedMap_End(class VmaJsonWriter& json) const;
        4582 #endif
        4583 
        4584 private:
        4585  VkDeviceSize m_Size;
        4586 };
        4587 
        4588 class VmaBlockMetadata_Generic : public VmaBlockMetadata
        4589 {
        4590  VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
        4591 public:
        4592  VmaBlockMetadata_Generic(VmaAllocator hAllocator);
        4593  virtual ~VmaBlockMetadata_Generic();
        4594  virtual void Init(VkDeviceSize size);
        4595 
        4596  virtual bool Validate() const;
        4597  virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
        4598  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        4599  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        4600  virtual bool IsEmpty() const;
        4601 
        4602  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        4603  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        4604 
        4605 #if VMA_STATS_STRING_ENABLED
        4606  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        4607 #endif
        4608 
        4609  virtual bool CreateAllocationRequest(
        4610  uint32_t currentFrameIndex,
        4611  uint32_t frameInUseCount,
        4612  VkDeviceSize bufferImageGranularity,
        4613  VkDeviceSize allocSize,
        4614  VkDeviceSize allocAlignment,
        4615  bool upperAddress,
        4616  VmaSuballocationType allocType,
        4617  bool canMakeOtherLost,
        4618  VmaAllocationRequest* pAllocationRequest);
        4619 
        4620  virtual bool MakeRequestedAllocationsLost(
        4621  uint32_t currentFrameIndex,
        4622  uint32_t frameInUseCount,
        4623  VmaAllocationRequest* pAllocationRequest);
        4624 
        4625  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        4626 
        4627  virtual VkResult CheckCorruption(const void* pBlockData);
        4628 
        4629  virtual void Alloc(
        4630  const VmaAllocationRequest& request,
        4631  VmaSuballocationType type,
        4632  VkDeviceSize allocSize,
        4633  bool upperAddress,
        4634  VmaAllocation hAllocation);
        4635 
        4636  virtual void Free(const VmaAllocation allocation);
        4637  virtual void FreeAtOffset(VkDeviceSize offset);
        4638 
        4639 private:
        4640  uint32_t m_FreeCount;
        4641  VkDeviceSize m_SumFreeSize;
        4642  VmaSuballocationList m_Suballocations;
        4643  // Suballocations that are free and have size greater than certain threshold.
        4644  // Sorted by size, ascending.
        4645  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
        4646 
        4647  bool ValidateFreeSuballocationList() const;
        4648 
        4649  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
        4650  // If yes, fills pOffset and returns true. If no, returns false.
        4651  bool CheckAllocation(
        4652  uint32_t currentFrameIndex,
        4653  uint32_t frameInUseCount,
        4654  VkDeviceSize bufferImageGranularity,
        4655  VkDeviceSize allocSize,
        4656  VkDeviceSize allocAlignment,
        4657  VmaSuballocationType allocType,
        4658  VmaSuballocationList::const_iterator suballocItem,
        4659  bool canMakeOtherLost,
        4660  VkDeviceSize* pOffset,
        4661  size_t* itemsToMakeLostCount,
        4662  VkDeviceSize* pSumFreeSize,
        4663  VkDeviceSize* pSumItemSize) const;
        4664  // Given free suballocation, it merges it with following one, which must also be free.
        4665  void MergeFreeWithNext(VmaSuballocationList::iterator item);
        4666  // Releases given suballocation, making it free.
        4667  // Merges it with adjacent free suballocations if applicable.
        4668  // Returns iterator to new free suballocation at this place.
        4669  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
        4670  // Given free suballocation, it inserts it into sorted list of
        4671  // m_FreeSuballocationsBySize if it's suitable.
        4672  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
        4673  // Given free suballocation, it removes it from sorted list of
        4674  // m_FreeSuballocationsBySize if it's suitable.
        4675  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
        4676 };
        4677 
        4678 /*
        4679 Allocations and their references in internal data structure look like this:
        4680 
        4681 if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
        4682 
        4683  0 +-------+
        4684  | |
        4685  | |
        4686  | |
        4687  +-------+
        4688  | Alloc | 1st[m_1stNullItemsBeginCount]
        4689  +-------+
        4690  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        4691  +-------+
        4692  | ... |
        4693  +-------+
        4694  | Alloc | 1st[1st.size() - 1]
        4695  +-------+
        4696  | |
        4697  | |
        4698  | |
        4699 GetSize() +-------+
        4700 
        4701 if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
        4702 
        4703  0 +-------+
        4704  | Alloc | 2nd[0]
        4705  +-------+
        4706  | Alloc | 2nd[1]
        4707  +-------+
        4708  | ... |
        4709  +-------+
        4710  | Alloc | 2nd[2nd.size() - 1]
        4711  +-------+
        4712  | |
        4713  | |
        4714  | |
        4715  +-------+
        4716  | Alloc | 1st[m_1stNullItemsBeginCount]
        4717  +-------+
        4718  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        4719  +-------+
        4720  | ... |
        4721  +-------+
        4722  | Alloc | 1st[1st.size() - 1]
        4723  +-------+
        4724  | |
        4725 GetSize() +-------+
        4726 
        4727 if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
        4728 
        4729  0 +-------+
        4730  | |
        4731  | |
        4732  | |
        4733  +-------+
        4734  | Alloc | 1st[m_1stNullItemsBeginCount]
        4735  +-------+
        4736  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
        4737  +-------+
        4738  | ... |
        4739  +-------+
        4740  | Alloc | 1st[1st.size() - 1]
        4741  +-------+
        4742  | |
        4743  | |
        4744  | |
        4745  +-------+
        4746  | Alloc | 2nd[2nd.size() - 1]
        4747  +-------+
        4748  | ... |
        4749  +-------+
        4750  | Alloc | 2nd[1]
        4751  +-------+
        4752  | Alloc | 2nd[0]
        4753 GetSize() +-------+
        4754 
        4755 */
        4756 class VmaBlockMetadata_Linear : public VmaBlockMetadata
        4757 {
        4758  VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
        4759 public:
        4760  VmaBlockMetadata_Linear(VmaAllocator hAllocator);
        4761  virtual ~VmaBlockMetadata_Linear();
        4762  virtual void Init(VkDeviceSize size);
        4763 
        4764  virtual bool Validate() const;
        4765  virtual size_t GetAllocationCount() const;
        4766  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
        4767  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
        4768  virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
        4769 
        4770  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
        4771  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
        4772 
        4773 #if VMA_STATS_STRING_ENABLED
        4774  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
        4775 #endif
        4776 
        4777  virtual bool CreateAllocationRequest(
        4778  uint32_t currentFrameIndex,
        4779  uint32_t frameInUseCount,
        4780  VkDeviceSize bufferImageGranularity,
        4781  VkDeviceSize allocSize,
        4782  VkDeviceSize allocAlignment,
        4783  bool upperAddress,
        4784  VmaSuballocationType allocType,
        4785  bool canMakeOtherLost,
        4786  VmaAllocationRequest* pAllocationRequest);
        4787 
        4788  virtual bool MakeRequestedAllocationsLost(
        4789  uint32_t currentFrameIndex,
        4790  uint32_t frameInUseCount,
        4791  VmaAllocationRequest* pAllocationRequest);
        4792 
        4793  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
        4794 
        4795  virtual VkResult CheckCorruption(const void* pBlockData);
        4796 
        4797  virtual void Alloc(
        4798  const VmaAllocationRequest& request,
        4799  VmaSuballocationType type,
        4800  VkDeviceSize allocSize,
        4801  bool upperAddress,
        4802  VmaAllocation hAllocation);
        4803 
        4804  virtual void Free(const VmaAllocation allocation);
        4805  virtual void FreeAtOffset(VkDeviceSize offset);
        4806 
        4807 private:
        4808  /*
        4809  There are two suballocation vectors, used in ping-pong way.
        4810  The one with index m_1stVectorIndex is called 1st.
        4811  The one with index (m_1stVectorIndex ^ 1) is called 2nd.
        4812  2nd can be non-empty only when 1st is not empty.
        4813  When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
        4814  */
        4815  typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
        4816 
        4817  enum SECOND_VECTOR_MODE
        4818  {
        4819  SECOND_VECTOR_EMPTY,
        4820  /*
        4821  Suballocations in 2nd vector are created later than the ones in 1st, but they
        4822  all have smaller offset.
        4823  */
        4824  SECOND_VECTOR_RING_BUFFER,
        4825  /*
        4826  Suballocations in 2nd vector are upper side of double stack.
        4827  They all have offsets higher than those in 1st vector.
        4828  Top of this stack means smaller offsets, but higher indices in this vector.
        4829  */
        4830  SECOND_VECTOR_DOUBLE_STACK,
        4831  };
        4832 
        4833  VkDeviceSize m_SumFreeSize;
        4834  SuballocationVectorType m_Suballocations0, m_Suballocations1;
        4835  uint32_t m_1stVectorIndex;
        4836  SECOND_VECTOR_MODE m_2ndVectorMode;
        4837 
        4838  SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        4839  SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        4840  const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
        4841  const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
        4842 
        4843  // Number of items in 1st vector with hAllocation = null at the beginning.
        4844  size_t m_1stNullItemsBeginCount;
        4845  // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
        4846  size_t m_1stNullItemsMiddleCount;
        4847  // Number of items in 2nd vector with hAllocation = null.
        4848  size_t m_2ndNullItemsCount;
        4849 
        4850  bool ShouldCompact1st() const;
        4851  void CleanupAfterFree();
        4852 };
        4853 
        4854 /*
        4855 Represents a single block of device memory (`VkDeviceMemory`) with all the
        4856 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
        4857 
        4858 Thread-safety: This class must be externally synchronized.
        4859 */
        4860 class VmaDeviceMemoryBlock
        4861 {
        4862  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
        4863 public:
        4864  VmaBlockMetadata* m_pMetadata;
        4865 
        4866  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
        4867 
        4868  ~VmaDeviceMemoryBlock()
        4869  {
        4870  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
        4871  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        4872  }
        4873 
        4874  // Always call after construction.
        4875  void Init(
        4876  VmaAllocator hAllocator,
        4877  uint32_t newMemoryTypeIndex,
        4878  VkDeviceMemory newMemory,
        4879  VkDeviceSize newSize,
        4880  uint32_t id,
        4881  bool linearAlgorithm);
        4882  // Always call before destruction.
        4883  void Destroy(VmaAllocator allocator);
        4884 
        4885  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
        4886  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        4887  uint32_t GetId() const { return m_Id; }
        4888  void* GetMappedData() const { return m_pMappedData; }
        4889 
        4890  // Validates all data structures inside this object. If not valid, returns false.
        4891  bool Validate() const;
        4892 
        4893  VkResult CheckCorruption(VmaAllocator hAllocator);
        4894 
        4895  // ppData can be null.
        4896  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
        4897  void Unmap(VmaAllocator hAllocator, uint32_t count);
        4898 
        4899  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        4900  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
        4901 
        4902  VkResult BindBufferMemory(
        4903  const VmaAllocator hAllocator,
        4904  const VmaAllocation hAllocation,
        4905  VkBuffer hBuffer);
        4906  VkResult BindImageMemory(
        4907  const VmaAllocator hAllocator,
        4908  const VmaAllocation hAllocation,
        4909  VkImage hImage);
        4910 
        4911 private:
        4912  uint32_t m_MemoryTypeIndex;
        4913  uint32_t m_Id;
        4914  VkDeviceMemory m_hMemory;
        4915 
        4916  // Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
        4917  // Also protects m_MapCount, m_pMappedData.
        4918  VMA_MUTEX m_Mutex;
        4919  uint32_t m_MapCount;
        4920  void* m_pMappedData;
        4921 };
        4922 
        4923 struct VmaPointerLess
        4924 {
        4925  bool operator()(const void* lhs, const void* rhs) const
        4926  {
        4927  return lhs < rhs;
        4928  }
        4929 };
        4930 
        4931 class VmaDefragmentator;
        4932 
        4933 /*
        4934 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
        4935 Vulkan memory type.
        4936 
        4937 Synchronized internally with a mutex.
        4938 */
        4939 struct VmaBlockVector
        4940 {
        4941  VMA_CLASS_NO_COPY(VmaBlockVector)
        4942 public:
        4943  VmaBlockVector(
        4944  VmaAllocator hAllocator,
        4945  uint32_t memoryTypeIndex,
        4946  VkDeviceSize preferredBlockSize,
        4947  size_t minBlockCount,
        4948  size_t maxBlockCount,
        4949  VkDeviceSize bufferImageGranularity,
        4950  uint32_t frameInUseCount,
        4951  bool isCustomPool,
        4952  bool explicitBlockSize,
        4953  bool linearAlgorithm);
        4954  ~VmaBlockVector();
        4955 
        4956  VkResult CreateMinBlocks();
        4957 
        4958  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
        4959  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
        4960  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
        4961  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
        4962  bool UsesLinearAlgorithm() const { return m_LinearAlgorithm; }
        4963 
        4964  void GetPoolStats(VmaPoolStats* pStats);
        4965 
        4966  bool IsEmpty() const { return m_Blocks.empty(); }
        4967  bool IsCorruptionDetectionEnabled() const;
        4968 
        4969  VkResult Allocate(
        4970  VmaPool hCurrentPool,
        4971  uint32_t currentFrameIndex,
        4972  VkDeviceSize size,
        4973  VkDeviceSize alignment,
        4974  const VmaAllocationCreateInfo& createInfo,
        4975  VmaSuballocationType suballocType,
        4976  VmaAllocation* pAllocation);
        4977 
        4978  void Free(
        4979  VmaAllocation hAllocation);
        4980 
        4981  // Adds statistics of this BlockVector to pStats.
        4982  void AddStats(VmaStats* pStats);
        4983 
        4984 #if VMA_STATS_STRING_ENABLED
        4985  void PrintDetailedMap(class VmaJsonWriter& json);
        4986 #endif
        4987 
        4988  void MakePoolAllocationsLost(
        4989  uint32_t currentFrameIndex,
        4990  size_t* pLostAllocationCount);
        4991  VkResult CheckCorruption();
        4992 
        4993  VmaDefragmentator* EnsureDefragmentator(
        4994  VmaAllocator hAllocator,
        4995  uint32_t currentFrameIndex);
        4996 
        4997  VkResult Defragment(
        4998  VmaDefragmentationStats* pDefragmentationStats,
        4999  VkDeviceSize& maxBytesToMove,
        5000  uint32_t& maxAllocationsToMove);
        5001 
        5002  void DestroyDefragmentator();
        5003 
        5004 private:
        5005  friend class VmaDefragmentator;
        5006 
        5007  const VmaAllocator m_hAllocator;
        5008  const uint32_t m_MemoryTypeIndex;
        5009  const VkDeviceSize m_PreferredBlockSize;
        5010  const size_t m_MinBlockCount;
        5011  const size_t m_MaxBlockCount;
        5012  const VkDeviceSize m_BufferImageGranularity;
        5013  const uint32_t m_FrameInUseCount;
        5014  const bool m_IsCustomPool;
        5015  const bool m_ExplicitBlockSize;
        5016  const bool m_LinearAlgorithm;
        5017  bool m_HasEmptyBlock;
        5018  VMA_MUTEX m_Mutex;
        5019  // Incrementally sorted by sumFreeSize, ascending.
        5020  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
        5021  /* There can be at most one allocation that is completely empty - a
        5022  hysteresis to avoid pessimistic case of alternating creation and destruction
        5023  of a VkDeviceMemory. */
        5024  VmaDefragmentator* m_pDefragmentator;
        5025  uint32_t m_NextBlockId;
        5026 
        5027  VkDeviceSize CalcMaxBlockSize() const;
        5028 
        5029  // Finds and removes given block from vector.
        5030  void Remove(VmaDeviceMemoryBlock* pBlock);
        5031 
        5032  // Performs single step in sorting m_Blocks. They may not be fully sorted
        5033  // after this call.
        5034  void IncrementallySortBlocks();
        5035 
        5036  // To be used only without CAN_MAKE_OTHER_LOST flag.
        5037  VkResult AllocateFromBlock(
        5038  VmaDeviceMemoryBlock* pBlock,
        5039  VmaPool hCurrentPool,
        5040  uint32_t currentFrameIndex,
        5041  VkDeviceSize size,
        5042  VkDeviceSize alignment,
        5043  VmaAllocationCreateFlags allocFlags,
        5044  void* pUserData,
        5045  VmaSuballocationType suballocType,
        5046  VmaAllocation* pAllocation);
        5047 
        5048  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
        5049 };
        5050 
        5051 struct VmaPool_T
        5052 {
        5053  VMA_CLASS_NO_COPY(VmaPool_T)
        5054 public:
        5055  VmaBlockVector m_BlockVector;
        5056 
        5057  VmaPool_T(
        5058  VmaAllocator hAllocator,
        5059  const VmaPoolCreateInfo& createInfo,
        5060  VkDeviceSize preferredBlockSize);
        5061  ~VmaPool_T();
        5062 
        5063  uint32_t GetId() const { return m_Id; }
        5064  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
        5065 
        5066 #if VMA_STATS_STRING_ENABLED
        5067  //void PrintDetailedMap(class VmaStringBuilder& sb);
        5068 #endif
        5069 
        5070 private:
        5071  uint32_t m_Id;
        5072 };
        5073 
        5074 class VmaDefragmentator
        5075 {
        5076  VMA_CLASS_NO_COPY(VmaDefragmentator)
        5077 private:
        5078  const VmaAllocator m_hAllocator;
        5079  VmaBlockVector* const m_pBlockVector;
        5080  uint32_t m_CurrentFrameIndex;
        5081  VkDeviceSize m_BytesMoved;
        5082  uint32_t m_AllocationsMoved;
        5083 
        5084  struct AllocationInfo
        5085  {
        5086  VmaAllocation m_hAllocation;
        5087  VkBool32* m_pChanged;
        5088 
        5089  AllocationInfo() :
        5090  m_hAllocation(VK_NULL_HANDLE),
        5091  m_pChanged(VMA_NULL)
        5092  {
        5093  }
        5094  };
        5095 
        5096  struct AllocationInfoSizeGreater
        5097  {
        5098  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
        5099  {
        5100  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
        5101  }
        5102  };
        5103 
        5104  // Used between AddAllocation and Defragment.
        5105  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        5106 
        5107  struct BlockInfo
        5108  {
        5109  VmaDeviceMemoryBlock* m_pBlock;
        5110  bool m_HasNonMovableAllocations;
        5111  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
        5112 
        5113  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
        5114  m_pBlock(VMA_NULL),
        5115  m_HasNonMovableAllocations(true),
        5116  m_Allocations(pAllocationCallbacks),
        5117  m_pMappedDataForDefragmentation(VMA_NULL)
        5118  {
        5119  }
        5120 
        5121  void CalcHasNonMovableAllocations()
        5122  {
        5123  const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
        5124  const size_t defragmentAllocCount = m_Allocations.size();
        5125  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
        5126  }
        5127 
        5128  void SortAllocationsBySizeDescecnding()
        5129  {
        5130  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
        5131  }
        5132 
        5133  VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);
        5134  void Unmap(VmaAllocator hAllocator);
        5135 
        5136  private:
        5137  // Not null if mapped for defragmentation only, not originally mapped.
        5138  void* m_pMappedDataForDefragmentation;
        5139  };
        5140 
        5141  struct BlockPointerLess
        5142  {
        5143  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
        5144  {
        5145  return pLhsBlockInfo->m_pBlock < pRhsBlock;
        5146  }
        5147  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        5148  {
        5149  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
        5150  }
        5151  };
        5152 
        5153  // 1. Blocks with some non-movable allocations go first.
        5154  // 2. Blocks with smaller sumFreeSize go first.
        5155  struct BlockInfoCompareMoveDestination
        5156  {
        5157  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
        5158  {
        5159  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
        5160  {
        5161  return true;
        5162  }
        5163  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
        5164  {
        5165  return false;
        5166  }
        5167  if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
        5168  {
        5169  return true;
        5170  }
        5171  return false;
        5172  }
        5173  };
        5174 
        5175  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
        5176  BlockInfoVector m_Blocks;
        5177 
        5178  VkResult DefragmentRound(
        5179  VkDeviceSize maxBytesToMove,
        5180  uint32_t maxAllocationsToMove);
        5181 
        5182  static bool MoveMakesSense(
        5183  size_t dstBlockIndex, VkDeviceSize dstOffset,
        5184  size_t srcBlockIndex, VkDeviceSize srcOffset);
        5185 
        5186 public:
        5187  VmaDefragmentator(
        5188  VmaAllocator hAllocator,
        5189  VmaBlockVector* pBlockVector,
        5190  uint32_t currentFrameIndex);
        5191 
        5192  ~VmaDefragmentator();
        5193 
        5194  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
        5195  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
        5196 
        5197  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
        5198 
        5199  VkResult Defragment(
        5200  VkDeviceSize maxBytesToMove,
        5201  uint32_t maxAllocationsToMove);
        5202 };
        5203 
        5204 #if VMA_RECORDING_ENABLED
        5205 
        5206 class VmaRecorder
        5207 {
        5208 public:
        5209  VmaRecorder();
        5210  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
        5211  void WriteConfiguration(
        5212  const VkPhysicalDeviceProperties& devProps,
        5213  const VkPhysicalDeviceMemoryProperties& memProps,
        5214  bool dedicatedAllocationExtensionEnabled);
        5215  ~VmaRecorder();
        5216 
        5217  void RecordCreateAllocator(uint32_t frameIndex);
        5218  void RecordDestroyAllocator(uint32_t frameIndex);
        5219  void RecordCreatePool(uint32_t frameIndex,
        5220  const VmaPoolCreateInfo& createInfo,
        5221  VmaPool pool);
        5222  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
        5223  void RecordAllocateMemory(uint32_t frameIndex,
        5224  const VkMemoryRequirements& vkMemReq,
        5225  const VmaAllocationCreateInfo& createInfo,
        5226  VmaAllocation allocation);
        5227  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        5228  const VkMemoryRequirements& vkMemReq,
        5229  bool requiresDedicatedAllocation,
        5230  bool prefersDedicatedAllocation,
        5231  const VmaAllocationCreateInfo& createInfo,
        5232  VmaAllocation allocation);
        5233  void RecordAllocateMemoryForImage(uint32_t frameIndex,
        5234  const VkMemoryRequirements& vkMemReq,
        5235  bool requiresDedicatedAllocation,
        5236  bool prefersDedicatedAllocation,
        5237  const VmaAllocationCreateInfo& createInfo,
        5238  VmaAllocation allocation);
        5239  void RecordFreeMemory(uint32_t frameIndex,
        5240  VmaAllocation allocation);
        5241  void RecordSetAllocationUserData(uint32_t frameIndex,
        5242  VmaAllocation allocation,
        5243  const void* pUserData);
        5244  void RecordCreateLostAllocation(uint32_t frameIndex,
        5245  VmaAllocation allocation);
        5246  void RecordMapMemory(uint32_t frameIndex,
        5247  VmaAllocation allocation);
        5248  void RecordUnmapMemory(uint32_t frameIndex,
        5249  VmaAllocation allocation);
        5250  void RecordFlushAllocation(uint32_t frameIndex,
        5251  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        5252  void RecordInvalidateAllocation(uint32_t frameIndex,
        5253  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
        5254  void RecordCreateBuffer(uint32_t frameIndex,
        5255  const VkBufferCreateInfo& bufCreateInfo,
        5256  const VmaAllocationCreateInfo& allocCreateInfo,
        5257  VmaAllocation allocation);
        5258  void RecordCreateImage(uint32_t frameIndex,
        5259  const VkImageCreateInfo& imageCreateInfo,
        5260  const VmaAllocationCreateInfo& allocCreateInfo,
        5261  VmaAllocation allocation);
        5262  void RecordDestroyBuffer(uint32_t frameIndex,
        5263  VmaAllocation allocation);
        5264  void RecordDestroyImage(uint32_t frameIndex,
        5265  VmaAllocation allocation);
        5266  void RecordTouchAllocation(uint32_t frameIndex,
        5267  VmaAllocation allocation);
        5268  void RecordGetAllocationInfo(uint32_t frameIndex,
        5269  VmaAllocation allocation);
        5270  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
        5271  VmaPool pool);
        5272 
        5273 private:
        5274  struct CallParams
        5275  {
        5276  uint32_t threadId;
        5277  double time;
        5278  };
        5279 
        5280  class UserDataString
        5281  {
        5282  public:
        5283  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
        5284  const char* GetString() const { return m_Str; }
        5285 
        5286  private:
        5287  char m_PtrStr[17];
        5288  const char* m_Str;
        5289  };
        5290 
        5291  bool m_UseMutex;
        5292  VmaRecordFlags m_Flags;
        5293  FILE* m_File;
        5294  VMA_MUTEX m_FileMutex;
        5295  int64_t m_Freq;
        5296  int64_t m_StartCounter;
        5297 
        5298  void GetBasicParams(CallParams& outParams);
        5299  void Flush();
        5300 };
        5301 
        5302 #endif // #if VMA_RECORDING_ENABLED
        5303 
        5304 // Main allocator object.
        5305 struct VmaAllocator_T
        5306 {
        5307  VMA_CLASS_NO_COPY(VmaAllocator_T)
        5308 public:
        5309  bool m_UseMutex;
        5310  bool m_UseKhrDedicatedAllocation;
        5311  VkDevice m_hDevice;
        5312  bool m_AllocationCallbacksSpecified;
        5313  VkAllocationCallbacks m_AllocationCallbacks;
        5314  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
        5315 
        5316  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
        5317  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
        5318  VMA_MUTEX m_HeapSizeLimitMutex;
        5319 
        5320  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
        5321  VkPhysicalDeviceMemoryProperties m_MemProps;
        5322 
        5323  // Default pools.
        5324  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
        5325 
        5326  // Each vector is sorted by memory (handle value).
        5327  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
        5328  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
        5329  VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
        5330 
        5331  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
        5332  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
        5333  ~VmaAllocator_T();
        5334 
        5335  const VkAllocationCallbacks* GetAllocationCallbacks() const
        5336  {
        5337  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
        5338  }
        5339  const VmaVulkanFunctions& GetVulkanFunctions() const
        5340  {
        5341  return m_VulkanFunctions;
        5342  }
        5343 
        5344  VkDeviceSize GetBufferImageGranularity() const
        5345  {
        5346  return VMA_MAX(
        5347  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
        5348  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
        5349  }
        5350 
        5351  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
        5352  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
        5353 
        5354  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
        5355  {
        5356  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
        5357  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
        5358  }
        5359  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
        5360  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
        5361  {
        5362  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
        5363  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        5364  }
        5365  // Minimum alignment for all allocations in specific memory type.
        5366  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
        5367  {
        5368  return IsMemoryTypeNonCoherent(memTypeIndex) ?
        5369  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
        5370  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
        5371  }
        5372 
        5373  bool IsIntegratedGpu() const
        5374  {
        5375  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
        5376  }
        5377 
        5378 #if VMA_RECORDING_ENABLED
        5379  VmaRecorder* GetRecorder() const { return m_pRecorder; }
        5380 #endif
        5381 
        5382  void GetBufferMemoryRequirements(
        5383  VkBuffer hBuffer,
        5384  VkMemoryRequirements& memReq,
        5385  bool& requiresDedicatedAllocation,
        5386  bool& prefersDedicatedAllocation) const;
        5387  void GetImageMemoryRequirements(
        5388  VkImage hImage,
        5389  VkMemoryRequirements& memReq,
        5390  bool& requiresDedicatedAllocation,
        5391  bool& prefersDedicatedAllocation) const;
        5392 
        5393  // Main allocation function.
        5394  VkResult AllocateMemory(
        5395  const VkMemoryRequirements& vkMemReq,
        5396  bool requiresDedicatedAllocation,
        5397  bool prefersDedicatedAllocation,
        5398  VkBuffer dedicatedBuffer,
        5399  VkImage dedicatedImage,
        5400  const VmaAllocationCreateInfo& createInfo,
        5401  VmaSuballocationType suballocType,
        5402  VmaAllocation* pAllocation);
        5403 
        5404  // Main deallocation function.
        5405  void FreeMemory(const VmaAllocation allocation);
        5406 
        5407  void CalculateStats(VmaStats* pStats);
        5408 
        5409 #if VMA_STATS_STRING_ENABLED
        5410  void PrintDetailedMap(class VmaJsonWriter& json);
        5411 #endif
        5412 
        5413  VkResult Defragment(
        5414  VmaAllocation* pAllocations,
        5415  size_t allocationCount,
        5416  VkBool32* pAllocationsChanged,
        5417  const VmaDefragmentationInfo* pDefragmentationInfo,
        5418  VmaDefragmentationStats* pDefragmentationStats);
        5419 
        5420  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
        5421  bool TouchAllocation(VmaAllocation hAllocation);
        5422 
        5423  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
        5424  void DestroyPool(VmaPool pool);
        5425  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
        5426 
        5427  void SetCurrentFrameIndex(uint32_t frameIndex);
        5428  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
        5429 
        5430  void MakePoolAllocationsLost(
        5431  VmaPool hPool,
        5432  size_t* pLostAllocationCount);
        5433  VkResult CheckPoolCorruption(VmaPool hPool);
        5434  VkResult CheckCorruption(uint32_t memoryTypeBits);
        5435 
        5436  void CreateLostAllocation(VmaAllocation* pAllocation);
        5437 
        5438  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
        5439  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
        5440 
        5441  VkResult Map(VmaAllocation hAllocation, void** ppData);
        5442  void Unmap(VmaAllocation hAllocation);
        5443 
        5444  VkResult BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer);
        5445  VkResult BindImageMemory(VmaAllocation hAllocation, VkImage hImage);
        5446 
        5447  void FlushOrInvalidateAllocation(
        5448  VmaAllocation hAllocation,
        5449  VkDeviceSize offset, VkDeviceSize size,
        5450  VMA_CACHE_OPERATION op);
        5451 
        5452  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
        5453 
        5454 private:
        5455  VkDeviceSize m_PreferredLargeHeapBlockSize;
        5456 
        5457  VkPhysicalDevice m_PhysicalDevice;
        5458  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
        5459 
        5460  VMA_MUTEX m_PoolsMutex;
        5461  // Protected by m_PoolsMutex. Sorted by pointer value.
        5462  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
        5463  uint32_t m_NextPoolId;
        5464 
        5465  VmaVulkanFunctions m_VulkanFunctions;
        5466 
        5467 #if VMA_RECORDING_ENABLED
        5468  VmaRecorder* m_pRecorder;
        5469 #endif
        5470 
        5471  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
        5472 
        5473  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
        5474 
        5475  VkResult AllocateMemoryOfType(
        5476  VkDeviceSize size,
        5477  VkDeviceSize alignment,
        5478  bool dedicatedAllocation,
        5479  VkBuffer dedicatedBuffer,
        5480  VkImage dedicatedImage,
        5481  const VmaAllocationCreateInfo& createInfo,
        5482  uint32_t memTypeIndex,
        5483  VmaSuballocationType suballocType,
        5484  VmaAllocation* pAllocation);
        5485 
        5486  // Allocates and registers new VkDeviceMemory specifically for single allocation.
        5487  VkResult AllocateDedicatedMemory(
        5488  VkDeviceSize size,
        5489  VmaSuballocationType suballocType,
        5490  uint32_t memTypeIndex,
        5491  bool map,
        5492  bool isUserDataString,
        5493  void* pUserData,
        5494  VkBuffer dedicatedBuffer,
        5495  VkImage dedicatedImage,
        5496  VmaAllocation* pAllocation);
        5497 
        5498  // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.
        5499  void FreeDedicatedMemory(VmaAllocation allocation);
        5500 };
        5501 
        5503 // Memory allocation #2 after VmaAllocator_T definition
        5504 
        5505 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
        5506 {
        5507  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
        5508 }
        5509 
        5510 static void VmaFree(VmaAllocator hAllocator, void* ptr)
        5511 {
        5512  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
        5513 }
        5514 
        5515 template<typename T>
        5516 static T* VmaAllocate(VmaAllocator hAllocator)
        5517 {
        5518  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
        5519 }
        5520 
        5521 template<typename T>
        5522 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
        5523 {
        5524  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
        5525 }
        5526 
        5527 template<typename T>
        5528 static void vma_delete(VmaAllocator hAllocator, T* ptr)
        5529 {
        5530  if(ptr != VMA_NULL)
        5531  {
        5532  ptr->~T();
        5533  VmaFree(hAllocator, ptr);
        5534  }
        5535 }
        5536 
        5537 template<typename T>
        5538 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
        5539 {
        5540  if(ptr != VMA_NULL)
        5541  {
        5542  for(size_t i = count; i--; )
        5543  ptr[i].~T();
        5544  VmaFree(hAllocator, ptr);
        5545  }
        5546 }
        5547 
        5549 // VmaStringBuilder
        5550 
        5551 #if VMA_STATS_STRING_ENABLED
        5552 
        5553 class VmaStringBuilder
        5554 {
        5555 public:
        5556  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
        5557  size_t GetLength() const { return m_Data.size(); }
        5558  const char* GetData() const { return m_Data.data(); }
        5559 
        5560  void Add(char ch) { m_Data.push_back(ch); }
        5561  void Add(const char* pStr);
        5562  void AddNewLine() { Add('\n'); }
        5563  void AddNumber(uint32_t num);
        5564  void AddNumber(uint64_t num);
        5565  void AddPointer(const void* ptr);
        5566 
        5567 private:
        5568  VmaVector< char, VmaStlAllocator<char> > m_Data;
        5569 };
        5570 
        5571 void VmaStringBuilder::Add(const char* pStr)
        5572 {
        5573  const size_t strLen = strlen(pStr);
        5574  if(strLen > 0)
        5575  {
        5576  const size_t oldCount = m_Data.size();
        5577  m_Data.resize(oldCount + strLen);
        5578  memcpy(m_Data.data() + oldCount, pStr, strLen);
        5579  }
        5580 }
        5581 
        5582 void VmaStringBuilder::AddNumber(uint32_t num)
        5583 {
        5584  char buf[11];
        5585  VmaUint32ToStr(buf, sizeof(buf), num);
        5586  Add(buf);
        5587 }
        5588 
        5589 void VmaStringBuilder::AddNumber(uint64_t num)
        5590 {
        5591  char buf[21];
        5592  VmaUint64ToStr(buf, sizeof(buf), num);
        5593  Add(buf);
        5594 }
        5595 
        5596 void VmaStringBuilder::AddPointer(const void* ptr)
        5597 {
        5598  char buf[21];
        5599  VmaPtrToStr(buf, sizeof(buf), ptr);
        5600  Add(buf);
        5601 }
        5602 
        5603 #endif // #if VMA_STATS_STRING_ENABLED
        5604 
        5606 // VmaJsonWriter
        5607 
        5608 #if VMA_STATS_STRING_ENABLED
        5609 
        5610 class VmaJsonWriter
        5611 {
        5612  VMA_CLASS_NO_COPY(VmaJsonWriter)
        5613 public:
        5614  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
        5615  ~VmaJsonWriter();
        5616 
        5617  void BeginObject(bool singleLine = false);
        5618  void EndObject();
        5619 
        5620  void BeginArray(bool singleLine = false);
        5621  void EndArray();
        5622 
        5623  void WriteString(const char* pStr);
        5624  void BeginString(const char* pStr = VMA_NULL);
        5625  void ContinueString(const char* pStr);
        5626  void ContinueString(uint32_t n);
        5627  void ContinueString(uint64_t n);
        5628  void ContinueString_Pointer(const void* ptr);
        5629  void EndString(const char* pStr = VMA_NULL);
        5630 
        5631  void WriteNumber(uint32_t n);
        5632  void WriteNumber(uint64_t n);
        5633  void WriteBool(bool b);
        5634  void WriteNull();
        5635 
        5636 private:
        5637  static const char* const INDENT;
        5638 
        5639  enum COLLECTION_TYPE
        5640  {
        5641  COLLECTION_TYPE_OBJECT,
        5642  COLLECTION_TYPE_ARRAY,
        5643  };
        5644  struct StackItem
        5645  {
        5646  COLLECTION_TYPE type;
        5647  uint32_t valueCount;
        5648  bool singleLineMode;
        5649  };
        5650 
        5651  VmaStringBuilder& m_SB;
        5652  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
        5653  bool m_InsideString;
        5654 
        5655  void BeginValue(bool isString);
        5656  void WriteIndent(bool oneLess = false);
        5657 };
        5658 
        5659 const char* const VmaJsonWriter::INDENT = " ";
        5660 
        5661 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
        5662  m_SB(sb),
        5663  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
        5664  m_InsideString(false)
        5665 {
        5666 }
        5667 
        5668 VmaJsonWriter::~VmaJsonWriter()
        5669 {
        5670  VMA_ASSERT(!m_InsideString);
        5671  VMA_ASSERT(m_Stack.empty());
        5672 }
        5673 
        5674 void VmaJsonWriter::BeginObject(bool singleLine)
        5675 {
        5676  VMA_ASSERT(!m_InsideString);
        5677 
        5678  BeginValue(false);
        5679  m_SB.Add('{');
        5680 
        5681  StackItem item;
        5682  item.type = COLLECTION_TYPE_OBJECT;
        5683  item.valueCount = 0;
        5684  item.singleLineMode = singleLine;
        5685  m_Stack.push_back(item);
        5686 }
        5687 
        5688 void VmaJsonWriter::EndObject()
        5689 {
        5690  VMA_ASSERT(!m_InsideString);
        5691 
        5692  WriteIndent(true);
        5693  m_SB.Add('}');
        5694 
        5695  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
        5696  m_Stack.pop_back();
        5697 }
        5698 
        5699 void VmaJsonWriter::BeginArray(bool singleLine)
        5700 {
        5701  VMA_ASSERT(!m_InsideString);
        5702 
        5703  BeginValue(false);
        5704  m_SB.Add('[');
        5705 
        5706  StackItem item;
        5707  item.type = COLLECTION_TYPE_ARRAY;
        5708  item.valueCount = 0;
        5709  item.singleLineMode = singleLine;
        5710  m_Stack.push_back(item);
        5711 }
        5712 
        5713 void VmaJsonWriter::EndArray()
        5714 {
        5715  VMA_ASSERT(!m_InsideString);
        5716 
        5717  WriteIndent(true);
        5718  m_SB.Add(']');
        5719 
        5720  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
        5721  m_Stack.pop_back();
        5722 }
        5723 
        5724 void VmaJsonWriter::WriteString(const char* pStr)
        5725 {
        5726  BeginString(pStr);
        5727  EndString();
        5728 }
        5729 
        5730 void VmaJsonWriter::BeginString(const char* pStr)
        5731 {
        5732  VMA_ASSERT(!m_InsideString);
        5733 
        5734  BeginValue(true);
        5735  m_SB.Add('"');
        5736  m_InsideString = true;
        5737  if(pStr != VMA_NULL && pStr[0] != '\0')
        5738  {
        5739  ContinueString(pStr);
        5740  }
        5741 }
        5742 
        5743 void VmaJsonWriter::ContinueString(const char* pStr)
        5744 {
        5745  VMA_ASSERT(m_InsideString);
        5746 
        5747  const size_t strLen = strlen(pStr);
        5748  for(size_t i = 0; i < strLen; ++i)
        5749  {
        5750  char ch = pStr[i];
        5751  if(ch == '\\')
        5752  {
        5753  m_SB.Add("\\\\");
        5754  }
        5755  else if(ch == '"')
        5756  {
        5757  m_SB.Add("\\\"");
        5758  }
        5759  else if(ch >= 32)
        5760  {
        5761  m_SB.Add(ch);
        5762  }
        5763  else switch(ch)
        5764  {
        5765  case '\b':
        5766  m_SB.Add("\\b");
        5767  break;
        5768  case '\f':
        5769  m_SB.Add("\\f");
        5770  break;
        5771  case '\n':
        5772  m_SB.Add("\\n");
        5773  break;
        5774  case '\r':
        5775  m_SB.Add("\\r");
        5776  break;
        5777  case '\t':
        5778  m_SB.Add("\\t");
        5779  break;
        5780  default:
        5781  VMA_ASSERT(0 && "Character not currently supported.");
        5782  break;
        5783  }
        5784  }
        5785 }
        5786 
        5787 void VmaJsonWriter::ContinueString(uint32_t n)
        5788 {
        5789  VMA_ASSERT(m_InsideString);
        5790  m_SB.AddNumber(n);
        5791 }
        5792 
        5793 void VmaJsonWriter::ContinueString(uint64_t n)
        5794 {
        5795  VMA_ASSERT(m_InsideString);
        5796  m_SB.AddNumber(n);
        5797 }
        5798 
        5799 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
        5800 {
        5801  VMA_ASSERT(m_InsideString);
        5802  m_SB.AddPointer(ptr);
        5803 }
        5804 
        5805 void VmaJsonWriter::EndString(const char* pStr)
        5806 {
        5807  VMA_ASSERT(m_InsideString);
        5808  if(pStr != VMA_NULL && pStr[0] != '\0')
        5809  {
        5810  ContinueString(pStr);
        5811  }
        5812  m_SB.Add('"');
        5813  m_InsideString = false;
        5814 }
        5815 
        5816 void VmaJsonWriter::WriteNumber(uint32_t n)
        5817 {
        5818  VMA_ASSERT(!m_InsideString);
        5819  BeginValue(false);
        5820  m_SB.AddNumber(n);
        5821 }
        5822 
        5823 void VmaJsonWriter::WriteNumber(uint64_t n)
        5824 {
        5825  VMA_ASSERT(!m_InsideString);
        5826  BeginValue(false);
        5827  m_SB.AddNumber(n);
        5828 }
        5829 
        5830 void VmaJsonWriter::WriteBool(bool b)
        5831 {
        5832  VMA_ASSERT(!m_InsideString);
        5833  BeginValue(false);
        5834  m_SB.Add(b ? "true" : "false");
        5835 }
        5836 
        5837 void VmaJsonWriter::WriteNull()
        5838 {
        5839  VMA_ASSERT(!m_InsideString);
        5840  BeginValue(false);
        5841  m_SB.Add("null");
        5842 }
        5843 
        5844 void VmaJsonWriter::BeginValue(bool isString)
        5845 {
        5846  if(!m_Stack.empty())
        5847  {
        5848  StackItem& currItem = m_Stack.back();
        5849  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        5850  currItem.valueCount % 2 == 0)
        5851  {
        5852  VMA_ASSERT(isString);
        5853  }
        5854 
        5855  if(currItem.type == COLLECTION_TYPE_OBJECT &&
        5856  currItem.valueCount % 2 != 0)
        5857  {
        5858  m_SB.Add(": ");
        5859  }
        5860  else if(currItem.valueCount > 0)
        5861  {
        5862  m_SB.Add(", ");
        5863  WriteIndent();
        5864  }
        5865  else
        5866  {
        5867  WriteIndent();
        5868  }
        5869  ++currItem.valueCount;
        5870  }
        5871 }
        5872 
        5873 void VmaJsonWriter::WriteIndent(bool oneLess)
        5874 {
        5875  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
        5876  {
        5877  m_SB.AddNewLine();
        5878 
        5879  size_t count = m_Stack.size();
        5880  if(count > 0 && oneLess)
        5881  {
        5882  --count;
        5883  }
        5884  for(size_t i = 0; i < count; ++i)
        5885  {
        5886  m_SB.Add(INDENT);
        5887  }
        5888  }
        5889 }
        5890 
        5891 #endif // #if VMA_STATS_STRING_ENABLED
        5892 
        5894 
        5895 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
        5896 {
        5897  if(IsUserDataString())
        5898  {
        5899  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
        5900 
        5901  FreeUserDataString(hAllocator);
        5902 
        5903  if(pUserData != VMA_NULL)
        5904  {
        5905  const char* const newStrSrc = (char*)pUserData;
        5906  const size_t newStrLen = strlen(newStrSrc);
        5907  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
        5908  memcpy(newStrDst, newStrSrc, newStrLen + 1);
        5909  m_pUserData = newStrDst;
        5910  }
        5911  }
        5912  else
        5913  {
        5914  m_pUserData = pUserData;
        5915  }
        5916 }
        5917 
        5918 void VmaAllocation_T::ChangeBlockAllocation(
        5919  VmaAllocator hAllocator,
        5920  VmaDeviceMemoryBlock* block,
        5921  VkDeviceSize offset)
        5922 {
        5923  VMA_ASSERT(block != VMA_NULL);
        5924  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        5925 
        5926  // Move mapping reference counter from old block to new block.
        5927  if(block != m_BlockAllocation.m_Block)
        5928  {
        5929  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
        5930  if(IsPersistentMap())
        5931  ++mapRefCount;
        5932  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
        5933  block->Map(hAllocator, mapRefCount, VMA_NULL);
        5934  }
        5935 
        5936  m_BlockAllocation.m_Block = block;
        5937  m_BlockAllocation.m_Offset = offset;
        5938 }
        5939 
        5940 VkDeviceSize VmaAllocation_T::GetOffset() const
        5941 {
        5942  switch(m_Type)
        5943  {
        5944  case ALLOCATION_TYPE_BLOCK:
        5945  return m_BlockAllocation.m_Offset;
        5946  case ALLOCATION_TYPE_DEDICATED:
        5947  return 0;
        5948  default:
        5949  VMA_ASSERT(0);
        5950  return 0;
        5951  }
        5952 }
        5953 
        5954 VkDeviceMemory VmaAllocation_T::GetMemory() const
        5955 {
        5956  switch(m_Type)
        5957  {
        5958  case ALLOCATION_TYPE_BLOCK:
        5959  return m_BlockAllocation.m_Block->GetDeviceMemory();
        5960  case ALLOCATION_TYPE_DEDICATED:
        5961  return m_DedicatedAllocation.m_hMemory;
        5962  default:
        5963  VMA_ASSERT(0);
        5964  return VK_NULL_HANDLE;
        5965  }
        5966 }
        5967 
        5968 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
        5969 {
        5970  switch(m_Type)
        5971  {
        5972  case ALLOCATION_TYPE_BLOCK:
        5973  return m_BlockAllocation.m_Block->GetMemoryTypeIndex();
        5974  case ALLOCATION_TYPE_DEDICATED:
        5975  return m_DedicatedAllocation.m_MemoryTypeIndex;
        5976  default:
        5977  VMA_ASSERT(0);
        5978  return UINT32_MAX;
        5979  }
        5980 }
        5981 
        5982 void* VmaAllocation_T::GetMappedData() const
        5983 {
        5984  switch(m_Type)
        5985  {
        5986  case ALLOCATION_TYPE_BLOCK:
        5987  if(m_MapCount != 0)
        5988  {
        5989  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
        5990  VMA_ASSERT(pBlockData != VMA_NULL);
        5991  return (char*)pBlockData + m_BlockAllocation.m_Offset;
        5992  }
        5993  else
        5994  {
        5995  return VMA_NULL;
        5996  }
        5997  break;
        5998  case ALLOCATION_TYPE_DEDICATED:
        5999  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
        6000  return m_DedicatedAllocation.m_pMappedData;
        6001  default:
        6002  VMA_ASSERT(0);
        6003  return VMA_NULL;
        6004  }
        6005 }
        6006 
        6007 bool VmaAllocation_T::CanBecomeLost() const
        6008 {
        6009  switch(m_Type)
        6010  {
        6011  case ALLOCATION_TYPE_BLOCK:
        6012  return m_BlockAllocation.m_CanBecomeLost;
        6013  case ALLOCATION_TYPE_DEDICATED:
        6014  return false;
        6015  default:
        6016  VMA_ASSERT(0);
        6017  return false;
        6018  }
        6019 }
        6020 
        6021 VmaPool VmaAllocation_T::GetPool() const
        6022 {
        6023  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
        6024  return m_BlockAllocation.m_hPool;
        6025 }
        6026 
        6027 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        6028 {
        6029  VMA_ASSERT(CanBecomeLost());
        6030 
        6031  /*
        6032  Warning: This is a carefully designed algorithm.
        6033  Do not modify unless you really know what you're doing :)
        6034  */
        6035  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
        6036  for(;;)
        6037  {
        6038  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        6039  {
        6040  VMA_ASSERT(0);
        6041  return false;
        6042  }
        6043  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
        6044  {
        6045  return false;
        6046  }
        6047  else // Last use time earlier than current time.
        6048  {
        6049  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
        6050  {
        6051  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
        6052  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
        6053  return true;
        6054  }
        6055  }
        6056  }
        6057 }
        6058 
        6059 #if VMA_STATS_STRING_ENABLED
        6060 
        6061 // Correspond to values of enum VmaSuballocationType.
        6062 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
        6063  "FREE",
        6064  "UNKNOWN",
        6065  "BUFFER",
        6066  "IMAGE_UNKNOWN",
        6067  "IMAGE_LINEAR",
        6068  "IMAGE_OPTIMAL",
        6069 };
        6070 
        6071 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
        6072 {
        6073  json.WriteString("Type");
        6074  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
        6075 
        6076  json.WriteString("Size");
        6077  json.WriteNumber(m_Size);
        6078 
        6079  if(m_pUserData != VMA_NULL)
        6080  {
        6081  json.WriteString("UserData");
        6082  if(IsUserDataString())
        6083  {
        6084  json.WriteString((const char*)m_pUserData);
        6085  }
        6086  else
        6087  {
        6088  json.BeginString();
        6089  json.ContinueString_Pointer(m_pUserData);
        6090  json.EndString();
        6091  }
        6092  }
        6093 
        6094  json.WriteString("CreationFrameIndex");
        6095  json.WriteNumber(m_CreationFrameIndex);
        6096 
        6097  json.WriteString("LastUseFrameIndex");
        6098  json.WriteNumber(GetLastUseFrameIndex());
        6099 
        6100  if(m_BufferImageUsage != 0)
        6101  {
        6102  json.WriteString("Usage");
        6103  json.WriteNumber(m_BufferImageUsage);
        6104  }
        6105 }
        6106 
        6107 #endif
        6108 
        6109 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
        6110 {
        6111  VMA_ASSERT(IsUserDataString());
        6112  if(m_pUserData != VMA_NULL)
        6113  {
        6114  char* const oldStr = (char*)m_pUserData;
        6115  const size_t oldStrLen = strlen(oldStr);
        6116  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
        6117  m_pUserData = VMA_NULL;
        6118  }
        6119 }
        6120 
        6121 void VmaAllocation_T::BlockAllocMap()
        6122 {
        6123  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        6124 
        6125  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        6126  {
        6127  ++m_MapCount;
        6128  }
        6129  else
        6130  {
        6131  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
        6132  }
        6133 }
        6134 
        6135 void VmaAllocation_T::BlockAllocUnmap()
        6136 {
        6137  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
        6138 
        6139  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        6140  {
        6141  --m_MapCount;
        6142  }
        6143  else
        6144  {
        6145  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
        6146  }
        6147 }
        6148 
        6149 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
        6150 {
        6151  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        6152 
        6153  if(m_MapCount != 0)
        6154  {
        6155  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
        6156  {
        6157  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
        6158  *ppData = m_DedicatedAllocation.m_pMappedData;
        6159  ++m_MapCount;
        6160  return VK_SUCCESS;
        6161  }
        6162  else
        6163  {
        6164  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
        6165  return VK_ERROR_MEMORY_MAP_FAILED;
        6166  }
        6167  }
        6168  else
        6169  {
        6170  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        6171  hAllocator->m_hDevice,
        6172  m_DedicatedAllocation.m_hMemory,
        6173  0, // offset
        6174  VK_WHOLE_SIZE,
        6175  0, // flags
        6176  ppData);
        6177  if(result == VK_SUCCESS)
        6178  {
        6179  m_DedicatedAllocation.m_pMappedData = *ppData;
        6180  m_MapCount = 1;
        6181  }
        6182  return result;
        6183  }
        6184 }
        6185 
        6186 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
        6187 {
        6188  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
        6189 
        6190  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
        6191  {
        6192  --m_MapCount;
        6193  if(m_MapCount == 0)
        6194  {
        6195  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
        6196  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
        6197  hAllocator->m_hDevice,
        6198  m_DedicatedAllocation.m_hMemory);
        6199  }
        6200  }
        6201  else
        6202  {
        6203  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
        6204  }
        6205 }
        6206 
        6207 #if VMA_STATS_STRING_ENABLED
        6208 
        6209 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
        6210 {
        6211  json.BeginObject();
        6212 
        6213  json.WriteString("Blocks");
        6214  json.WriteNumber(stat.blockCount);
        6215 
        6216  json.WriteString("Allocations");
        6217  json.WriteNumber(stat.allocationCount);
        6218 
        6219  json.WriteString("UnusedRanges");
        6220  json.WriteNumber(stat.unusedRangeCount);
        6221 
        6222  json.WriteString("UsedBytes");
        6223  json.WriteNumber(stat.usedBytes);
        6224 
        6225  json.WriteString("UnusedBytes");
        6226  json.WriteNumber(stat.unusedBytes);
        6227 
        6228  if(stat.allocationCount > 1)
        6229  {
        6230  json.WriteString("AllocationSize");
        6231  json.BeginObject(true);
        6232  json.WriteString("Min");
        6233  json.WriteNumber(stat.allocationSizeMin);
        6234  json.WriteString("Avg");
        6235  json.WriteNumber(stat.allocationSizeAvg);
        6236  json.WriteString("Max");
        6237  json.WriteNumber(stat.allocationSizeMax);
        6238  json.EndObject();
        6239  }
        6240 
        6241  if(stat.unusedRangeCount > 1)
        6242  {
        6243  json.WriteString("UnusedRangeSize");
        6244  json.BeginObject(true);
        6245  json.WriteString("Min");
        6246  json.WriteNumber(stat.unusedRangeSizeMin);
        6247  json.WriteString("Avg");
        6248  json.WriteNumber(stat.unusedRangeSizeAvg);
        6249  json.WriteString("Max");
        6250  json.WriteNumber(stat.unusedRangeSizeMax);
        6251  json.EndObject();
        6252  }
        6253 
        6254  json.EndObject();
        6255 }
        6256 
        6257 #endif // #if VMA_STATS_STRING_ENABLED
        6258 
        6259 struct VmaSuballocationItemSizeLess
        6260 {
        6261  bool operator()(
        6262  const VmaSuballocationList::iterator lhs,
        6263  const VmaSuballocationList::iterator rhs) const
        6264  {
        6265  return lhs->size < rhs->size;
        6266  }
        6267  bool operator()(
        6268  const VmaSuballocationList::iterator lhs,
        6269  VkDeviceSize rhsSize) const
        6270  {
        6271  return lhs->size < rhsSize;
        6272  }
        6273 };
        6274 
        6275 
        6277 // class VmaBlockMetadata
        6278 
        6279 #if VMA_STATS_STRING_ENABLED
        6280 
        6281 void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
        6282  VkDeviceSize unusedBytes,
        6283  size_t allocationCount,
        6284  size_t unusedRangeCount) const
        6285 {
        6286  json.BeginObject();
        6287 
        6288  json.WriteString("TotalBytes");
        6289  json.WriteNumber(GetSize());
        6290 
        6291  json.WriteString("UnusedBytes");
        6292  json.WriteNumber(unusedBytes);
        6293 
        6294  json.WriteString("Allocations");
        6295  json.WriteNumber((uint64_t)allocationCount);
        6296 
        6297  json.WriteString("UnusedRanges");
        6298  json.WriteNumber((uint64_t)unusedRangeCount);
        6299 
        6300  json.WriteString("Suballocations");
        6301  json.BeginArray();
        6302 }
        6303 
        6304 void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
        6305  VkDeviceSize offset,
        6306  VmaAllocation hAllocation) const
        6307 {
        6308  json.BeginObject(true);
        6309 
        6310  json.WriteString("Offset");
        6311  json.WriteNumber(offset);
        6312 
        6313  hAllocation->PrintParameters(json);
        6314 
        6315  json.EndObject();
        6316 }
        6317 
        6318 void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
        6319  VkDeviceSize offset,
        6320  VkDeviceSize size) const
        6321 {
        6322  json.BeginObject(true);
        6323 
        6324  json.WriteString("Offset");
        6325  json.WriteNumber(offset);
        6326 
        6327  json.WriteString("Type");
        6328  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
        6329 
        6330  json.WriteString("Size");
        6331  json.WriteNumber(size);
        6332 
        6333  json.EndObject();
        6334 }
        6335 
        6336 void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
        6337 {
        6338  json.EndArray();
        6339  json.EndObject();
        6340 }
        6341 
        6342 #endif // #if VMA_STATS_STRING_ENABLED
        6343 
        6345 // class VmaBlockMetadata_Generic
        6346 
        6347 VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
        6348  m_FreeCount(0),
        6349  m_SumFreeSize(0),
        6350  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        6351  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
        6352 {
        6353 }
        6354 
        6355 VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
        6356 {
        6357 }
        6358 
        6359 void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
        6360 {
        6361  VmaBlockMetadata::Init(size);
        6362  m_FreeCount = 1;
        6363  m_SumFreeSize = size;
        6364 
        6365  VmaSuballocation suballoc = {};
        6366  suballoc.offset = 0;
        6367  suballoc.size = size;
        6368  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        6369  suballoc.hAllocation = VK_NULL_HANDLE;
        6370 
        6371  m_Suballocations.push_back(suballoc);
        6372  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
        6373  --suballocItem;
        6374  m_FreeSuballocationsBySize.push_back(suballocItem);
        6375 }
        6376 
        6377 bool VmaBlockMetadata_Generic::Validate() const
        6378 {
        6379  if(m_Suballocations.empty())
        6380  {
        6381  return false;
        6382  }
        6383 
        6384  // Expected offset of new suballocation as calculated from previous ones.
        6385  VkDeviceSize calculatedOffset = 0;
        6386  // Expected number of free suballocations as calculated from traversing their list.
        6387  uint32_t calculatedFreeCount = 0;
        6388  // Expected sum size of free suballocations as calculated from traversing their list.
        6389  VkDeviceSize calculatedSumFreeSize = 0;
        6390  // Expected number of free suballocations that should be registered in
        6391  // m_FreeSuballocationsBySize calculated from traversing their list.
        6392  size_t freeSuballocationsToRegister = 0;
        6393  // True if previous visited suballocation was free.
        6394  bool prevFree = false;
        6395 
        6396  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        6397  suballocItem != m_Suballocations.cend();
        6398  ++suballocItem)
        6399  {
        6400  const VmaSuballocation& subAlloc = *suballocItem;
        6401 
        6402  // Actual offset of this suballocation doesn't match expected one.
        6403  if(subAlloc.offset != calculatedOffset)
        6404  {
        6405  return false;
        6406  }
        6407 
        6408  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
        6409  // Two adjacent free suballocations are invalid. They should be merged.
        6410  if(prevFree && currFree)
        6411  {
        6412  return false;
        6413  }
        6414 
        6415  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
        6416  {
        6417  return false;
        6418  }
        6419 
        6420  if(currFree)
        6421  {
        6422  calculatedSumFreeSize += subAlloc.size;
        6423  ++calculatedFreeCount;
        6424  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        6425  {
        6426  ++freeSuballocationsToRegister;
        6427  }
        6428 
        6429  // Margin required between allocations - every free space must be at least that large.
        6430  if(subAlloc.size < VMA_DEBUG_MARGIN)
        6431  {
        6432  return false;
        6433  }
        6434  }
        6435  else
        6436  {
        6437  if(subAlloc.hAllocation->GetOffset() != subAlloc.offset)
        6438  {
        6439  return false;
        6440  }
        6441  if(subAlloc.hAllocation->GetSize() != subAlloc.size)
        6442  {
        6443  return false;
        6444  }
        6445 
        6446  // Margin required between allocations - previous allocation must be free.
        6447  if(VMA_DEBUG_MARGIN > 0 && !prevFree)
        6448  {
        6449  return false;
        6450  }
        6451  }
        6452 
        6453  calculatedOffset += subAlloc.size;
        6454  prevFree = currFree;
        6455  }
        6456 
        6457  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
        6458  // match expected one.
        6459  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
        6460  {
        6461  return false;
        6462  }
        6463 
        6464  VkDeviceSize lastSize = 0;
        6465  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
        6466  {
        6467  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
        6468 
        6469  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
        6470  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
        6471  {
        6472  return false;
        6473  }
        6474  // They must be sorted by size ascending.
        6475  if(suballocItem->size < lastSize)
        6476  {
        6477  return false;
        6478  }
        6479 
        6480  lastSize = suballocItem->size;
        6481  }
        6482 
        6483  // Check if totals match calculacted values.
        6484  if(!ValidateFreeSuballocationList() ||
        6485  (calculatedOffset != GetSize()) ||
        6486  (calculatedSumFreeSize != m_SumFreeSize) ||
        6487  (calculatedFreeCount != m_FreeCount))
        6488  {
        6489  return false;
        6490  }
        6491 
        6492  return true;
        6493 }
        6494 
        6495 VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
        6496 {
        6497  if(!m_FreeSuballocationsBySize.empty())
        6498  {
        6499  return m_FreeSuballocationsBySize.back()->size;
        6500  }
        6501  else
        6502  {
        6503  return 0;
        6504  }
        6505 }
        6506 
        6507 bool VmaBlockMetadata_Generic::IsEmpty() const
        6508 {
        6509  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
        6510 }
        6511 
        6512 void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        6513 {
        6514  outInfo.blockCount = 1;
        6515 
        6516  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        6517  outInfo.allocationCount = rangeCount - m_FreeCount;
        6518  outInfo.unusedRangeCount = m_FreeCount;
        6519 
        6520  outInfo.unusedBytes = m_SumFreeSize;
        6521  outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
        6522 
        6523  outInfo.allocationSizeMin = UINT64_MAX;
        6524  outInfo.allocationSizeMax = 0;
        6525  outInfo.unusedRangeSizeMin = UINT64_MAX;
        6526  outInfo.unusedRangeSizeMax = 0;
        6527 
        6528  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        6529  suballocItem != m_Suballocations.cend();
        6530  ++suballocItem)
        6531  {
        6532  const VmaSuballocation& suballoc = *suballocItem;
        6533  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        6534  {
        6535  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        6536  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
        6537  }
        6538  else
        6539  {
        6540  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
        6541  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
        6542  }
        6543  }
        6544 }
        6545 
        6546 void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
        6547 {
        6548  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
        6549 
        6550  inoutStats.size += GetSize();
        6551  inoutStats.unusedSize += m_SumFreeSize;
        6552  inoutStats.allocationCount += rangeCount - m_FreeCount;
        6553  inoutStats.unusedRangeCount += m_FreeCount;
        6554  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
        6555 }
        6556 
        6557 #if VMA_STATS_STRING_ENABLED
        6558 
        6559 void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
        6560 {
        6561  PrintDetailedMap_Begin(json,
        6562  m_SumFreeSize, // unusedBytes
        6563  m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
        6564  m_FreeCount); // unusedRangeCount
        6565 
        6566  size_t i = 0;
        6567  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
        6568  suballocItem != m_Suballocations.cend();
        6569  ++suballocItem, ++i)
        6570  {
        6571  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        6572  {
        6573  PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
        6574  }
        6575  else
        6576  {
        6577  PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
        6578  }
        6579  }
        6580 
        6581  PrintDetailedMap_End(json);
        6582 }
        6583 
        6584 #endif // #if VMA_STATS_STRING_ENABLED
        6585 
        6586 /*
        6587 How many suitable free suballocations to analyze before choosing best one.
        6588 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
        6589  be chosen.
        6590 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
        6591  suballocations will be analized and best one will be chosen.
        6592 - Any other value is also acceptable.
        6593 */
        6594 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
        6595 
        6596 bool VmaBlockMetadata_Generic::CreateAllocationRequest(
        6597  uint32_t currentFrameIndex,
        6598  uint32_t frameInUseCount,
        6599  VkDeviceSize bufferImageGranularity,
        6600  VkDeviceSize allocSize,
        6601  VkDeviceSize allocAlignment,
        6602  bool upperAddress,
        6603  VmaSuballocationType allocType,
        6604  bool canMakeOtherLost,
        6605  VmaAllocationRequest* pAllocationRequest)
        6606 {
        6607  VMA_ASSERT(allocSize > 0);
        6608  VMA_ASSERT(!upperAddress);
        6609  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        6610  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        6611  VMA_HEAVY_ASSERT(Validate());
        6612 
        6613  // There is not enough total free space in this block to fullfill the request: Early return.
        6614  if(canMakeOtherLost == false && m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
        6615  {
        6616  return false;
        6617  }
        6618 
        6619  // New algorithm, efficiently searching freeSuballocationsBySize.
        6620  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
        6621  if(freeSuballocCount > 0)
        6622  {
        6623  if(VMA_BEST_FIT)
        6624  {
        6625  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
        6626  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        6627  m_FreeSuballocationsBySize.data(),
        6628  m_FreeSuballocationsBySize.data() + freeSuballocCount,
        6629  allocSize + 2 * VMA_DEBUG_MARGIN,
        6630  VmaSuballocationItemSizeLess());
        6631  size_t index = it - m_FreeSuballocationsBySize.data();
        6632  for(; index < freeSuballocCount; ++index)
        6633  {
        6634  if(CheckAllocation(
        6635  currentFrameIndex,
        6636  frameInUseCount,
        6637  bufferImageGranularity,
        6638  allocSize,
        6639  allocAlignment,
        6640  allocType,
        6641  m_FreeSuballocationsBySize[index],
        6642  false, // canMakeOtherLost
        6643  &pAllocationRequest->offset,
        6644  &pAllocationRequest->itemsToMakeLostCount,
        6645  &pAllocationRequest->sumFreeSize,
        6646  &pAllocationRequest->sumItemSize))
        6647  {
        6648  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        6649  return true;
        6650  }
        6651  }
        6652  }
        6653  else
        6654  {
        6655  // Search staring from biggest suballocations.
        6656  for(size_t index = freeSuballocCount; index--; )
        6657  {
        6658  if(CheckAllocation(
        6659  currentFrameIndex,
        6660  frameInUseCount,
        6661  bufferImageGranularity,
        6662  allocSize,
        6663  allocAlignment,
        6664  allocType,
        6665  m_FreeSuballocationsBySize[index],
        6666  false, // canMakeOtherLost
        6667  &pAllocationRequest->offset,
        6668  &pAllocationRequest->itemsToMakeLostCount,
        6669  &pAllocationRequest->sumFreeSize,
        6670  &pAllocationRequest->sumItemSize))
        6671  {
        6672  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
        6673  return true;
        6674  }
        6675  }
        6676  }
        6677  }
        6678 
        6679  if(canMakeOtherLost)
        6680  {
        6681  // Brute-force algorithm. TODO: Come up with something better.
        6682 
        6683  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
        6684  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
        6685 
        6686  VmaAllocationRequest tmpAllocRequest = {};
        6687  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
        6688  suballocIt != m_Suballocations.end();
        6689  ++suballocIt)
        6690  {
        6691  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
        6692  suballocIt->hAllocation->CanBecomeLost())
        6693  {
        6694  if(CheckAllocation(
        6695  currentFrameIndex,
        6696  frameInUseCount,
        6697  bufferImageGranularity,
        6698  allocSize,
        6699  allocAlignment,
        6700  allocType,
        6701  suballocIt,
        6702  canMakeOtherLost,
        6703  &tmpAllocRequest.offset,
        6704  &tmpAllocRequest.itemsToMakeLostCount,
        6705  &tmpAllocRequest.sumFreeSize,
        6706  &tmpAllocRequest.sumItemSize))
        6707  {
        6708  tmpAllocRequest.item = suballocIt;
        6709 
        6710  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
        6711  {
        6712  *pAllocationRequest = tmpAllocRequest;
        6713  }
        6714  }
        6715  }
        6716  }
        6717 
        6718  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
        6719  {
        6720  return true;
        6721  }
        6722  }
        6723 
        6724  return false;
        6725 }
        6726 
        6727 bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
        6728  uint32_t currentFrameIndex,
        6729  uint32_t frameInUseCount,
        6730  VmaAllocationRequest* pAllocationRequest)
        6731 {
        6732  while(pAllocationRequest->itemsToMakeLostCount > 0)
        6733  {
        6734  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
        6735  {
        6736  ++pAllocationRequest->item;
        6737  }
        6738  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        6739  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
        6740  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
        6741  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        6742  {
        6743  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
        6744  --pAllocationRequest->itemsToMakeLostCount;
        6745  }
        6746  else
        6747  {
        6748  return false;
        6749  }
        6750  }
        6751 
        6752  VMA_HEAVY_ASSERT(Validate());
        6753  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
        6754  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
        6755 
        6756  return true;
        6757 }
        6758 
        6759 uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        6760 {
        6761  uint32_t lostAllocationCount = 0;
        6762  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        6763  it != m_Suballocations.end();
        6764  ++it)
        6765  {
        6766  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
        6767  it->hAllocation->CanBecomeLost() &&
        6768  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        6769  {
        6770  it = FreeSuballocation(it);
        6771  ++lostAllocationCount;
        6772  }
        6773  }
        6774  return lostAllocationCount;
        6775 }
        6776 
        6777 VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
        6778 {
        6779  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
        6780  it != m_Suballocations.end();
        6781  ++it)
        6782  {
        6783  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        6784  {
        6785  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
        6786  {
        6787  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        6788  return VK_ERROR_VALIDATION_FAILED_EXT;
        6789  }
        6790  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
        6791  {
        6792  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        6793  return VK_ERROR_VALIDATION_FAILED_EXT;
        6794  }
        6795  }
        6796  }
        6797 
        6798  return VK_SUCCESS;
        6799 }
        6800 
        6801 void VmaBlockMetadata_Generic::Alloc(
        6802  const VmaAllocationRequest& request,
        6803  VmaSuballocationType type,
        6804  VkDeviceSize allocSize,
        6805  bool upperAddress,
        6806  VmaAllocation hAllocation)
        6807 {
        6808  VMA_ASSERT(!upperAddress);
        6809  VMA_ASSERT(request.item != m_Suballocations.end());
        6810  VmaSuballocation& suballoc = *request.item;
        6811  // Given suballocation is a free block.
        6812  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        6813  // Given offset is inside this suballocation.
        6814  VMA_ASSERT(request.offset >= suballoc.offset);
        6815  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
        6816  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
        6817  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
        6818 
        6819  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
        6820  // it to become used.
        6821  UnregisterFreeSuballocation(request.item);
        6822 
        6823  suballoc.offset = request.offset;
        6824  suballoc.size = allocSize;
        6825  suballoc.type = type;
        6826  suballoc.hAllocation = hAllocation;
        6827 
        6828  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
        6829  if(paddingEnd)
        6830  {
        6831  VmaSuballocation paddingSuballoc = {};
        6832  paddingSuballoc.offset = request.offset + allocSize;
        6833  paddingSuballoc.size = paddingEnd;
        6834  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        6835  VmaSuballocationList::iterator next = request.item;
        6836  ++next;
        6837  const VmaSuballocationList::iterator paddingEndItem =
        6838  m_Suballocations.insert(next, paddingSuballoc);
        6839  RegisterFreeSuballocation(paddingEndItem);
        6840  }
        6841 
        6842  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
        6843  if(paddingBegin)
        6844  {
        6845  VmaSuballocation paddingSuballoc = {};
        6846  paddingSuballoc.offset = request.offset - paddingBegin;
        6847  paddingSuballoc.size = paddingBegin;
        6848  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        6849  const VmaSuballocationList::iterator paddingBeginItem =
        6850  m_Suballocations.insert(request.item, paddingSuballoc);
        6851  RegisterFreeSuballocation(paddingBeginItem);
        6852  }
        6853 
        6854  // Update totals.
        6855  m_FreeCount = m_FreeCount - 1;
        6856  if(paddingBegin > 0)
        6857  {
        6858  ++m_FreeCount;
        6859  }
        6860  if(paddingEnd > 0)
        6861  {
        6862  ++m_FreeCount;
        6863  }
        6864  m_SumFreeSize -= allocSize;
        6865 }
        6866 
        6867 void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
        6868 {
        6869  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        6870  suballocItem != m_Suballocations.end();
        6871  ++suballocItem)
        6872  {
        6873  VmaSuballocation& suballoc = *suballocItem;
        6874  if(suballoc.hAllocation == allocation)
        6875  {
        6876  FreeSuballocation(suballocItem);
        6877  VMA_HEAVY_ASSERT(Validate());
        6878  return;
        6879  }
        6880  }
        6881  VMA_ASSERT(0 && "Not found!");
        6882 }
        6883 
        6884 void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
        6885 {
        6886  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
        6887  suballocItem != m_Suballocations.end();
        6888  ++suballocItem)
        6889  {
        6890  VmaSuballocation& suballoc = *suballocItem;
        6891  if(suballoc.offset == offset)
        6892  {
        6893  FreeSuballocation(suballocItem);
        6894  return;
        6895  }
        6896  }
        6897  VMA_ASSERT(0 && "Not found!");
        6898 }
        6899 
        6900 bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
        6901 {
        6902  VkDeviceSize lastSize = 0;
        6903  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
        6904  {
        6905  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
        6906 
        6907  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
        6908  {
        6909  VMA_ASSERT(0);
        6910  return false;
        6911  }
        6912  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        6913  {
        6914  VMA_ASSERT(0);
        6915  return false;
        6916  }
        6917  if(it->size < lastSize)
        6918  {
        6919  VMA_ASSERT(0);
        6920  return false;
        6921  }
        6922 
        6923  lastSize = it->size;
        6924  }
        6925  return true;
        6926 }
        6927 
        6928 bool VmaBlockMetadata_Generic::CheckAllocation(
        6929  uint32_t currentFrameIndex,
        6930  uint32_t frameInUseCount,
        6931  VkDeviceSize bufferImageGranularity,
        6932  VkDeviceSize allocSize,
        6933  VkDeviceSize allocAlignment,
        6934  VmaSuballocationType allocType,
        6935  VmaSuballocationList::const_iterator suballocItem,
        6936  bool canMakeOtherLost,
        6937  VkDeviceSize* pOffset,
        6938  size_t* itemsToMakeLostCount,
        6939  VkDeviceSize* pSumFreeSize,
        6940  VkDeviceSize* pSumItemSize) const
        6941 {
        6942  VMA_ASSERT(allocSize > 0);
        6943  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        6944  VMA_ASSERT(suballocItem != m_Suballocations.cend());
        6945  VMA_ASSERT(pOffset != VMA_NULL);
        6946 
        6947  *itemsToMakeLostCount = 0;
        6948  *pSumFreeSize = 0;
        6949  *pSumItemSize = 0;
        6950 
        6951  if(canMakeOtherLost)
        6952  {
        6953  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        6954  {
        6955  *pSumFreeSize = suballocItem->size;
        6956  }
        6957  else
        6958  {
        6959  if(suballocItem->hAllocation->CanBecomeLost() &&
        6960  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        6961  {
        6962  ++*itemsToMakeLostCount;
        6963  *pSumItemSize = suballocItem->size;
        6964  }
        6965  else
        6966  {
        6967  return false;
        6968  }
        6969  }
        6970 
        6971  // Remaining size is too small for this request: Early return.
        6972  if(GetSize() - suballocItem->offset < allocSize)
        6973  {
        6974  return false;
        6975  }
        6976 
        6977  // Start from offset equal to beginning of this suballocation.
        6978  *pOffset = suballocItem->offset;
        6979 
        6980  // Apply VMA_DEBUG_MARGIN at the beginning.
        6981  if(VMA_DEBUG_MARGIN > 0)
        6982  {
        6983  *pOffset += VMA_DEBUG_MARGIN;
        6984  }
        6985 
        6986  // Apply alignment.
        6987  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        6988 
        6989  // Check previous suballocations for BufferImageGranularity conflicts.
        6990  // Make bigger alignment if necessary.
        6991  if(bufferImageGranularity > 1)
        6992  {
        6993  bool bufferImageGranularityConflict = false;
        6994  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        6995  while(prevSuballocItem != m_Suballocations.cbegin())
        6996  {
        6997  --prevSuballocItem;
        6998  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        6999  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        7000  {
        7001  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        7002  {
        7003  bufferImageGranularityConflict = true;
        7004  break;
        7005  }
        7006  }
        7007  else
        7008  // Already on previous page.
        7009  break;
        7010  }
        7011  if(bufferImageGranularityConflict)
        7012  {
        7013  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        7014  }
        7015  }
        7016 
        7017  // Now that we have final *pOffset, check if we are past suballocItem.
        7018  // If yes, return false - this function should be called for another suballocItem as starting point.
        7019  if(*pOffset >= suballocItem->offset + suballocItem->size)
        7020  {
        7021  return false;
        7022  }
        7023 
        7024  // Calculate padding at the beginning based on current offset.
        7025  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
        7026 
        7027  // Calculate required margin at the end.
        7028  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        7029 
        7030  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
        7031  // Another early return check.
        7032  if(suballocItem->offset + totalSize > GetSize())
        7033  {
        7034  return false;
        7035  }
        7036 
        7037  // Advance lastSuballocItem until desired size is reached.
        7038  // Update itemsToMakeLostCount.
        7039  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
        7040  if(totalSize > suballocItem->size)
        7041  {
        7042  VkDeviceSize remainingSize = totalSize - suballocItem->size;
        7043  while(remainingSize > 0)
        7044  {
        7045  ++lastSuballocItem;
        7046  if(lastSuballocItem == m_Suballocations.cend())
        7047  {
        7048  return false;
        7049  }
        7050  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        7051  {
        7052  *pSumFreeSize += lastSuballocItem->size;
        7053  }
        7054  else
        7055  {
        7056  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
        7057  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
        7058  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        7059  {
        7060  ++*itemsToMakeLostCount;
        7061  *pSumItemSize += lastSuballocItem->size;
        7062  }
        7063  else
        7064  {
        7065  return false;
        7066  }
        7067  }
        7068  remainingSize = (lastSuballocItem->size < remainingSize) ?
        7069  remainingSize - lastSuballocItem->size : 0;
        7070  }
        7071  }
        7072 
        7073  // Check next suballocations for BufferImageGranularity conflicts.
        7074  // If conflict exists, we must mark more allocations lost or fail.
        7075  if(bufferImageGranularity > 1)
        7076  {
        7077  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
        7078  ++nextSuballocItem;
        7079  while(nextSuballocItem != m_Suballocations.cend())
        7080  {
        7081  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        7082  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        7083  {
        7084  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        7085  {
        7086  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
        7087  if(nextSuballoc.hAllocation->CanBecomeLost() &&
        7088  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        7089  {
        7090  ++*itemsToMakeLostCount;
        7091  }
        7092  else
        7093  {
        7094  return false;
        7095  }
        7096  }
        7097  }
        7098  else
        7099  {
        7100  // Already on next page.
        7101  break;
        7102  }
        7103  ++nextSuballocItem;
        7104  }
        7105  }
        7106  }
        7107  else
        7108  {
        7109  const VmaSuballocation& suballoc = *suballocItem;
        7110  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7111 
        7112  *pSumFreeSize = suballoc.size;
        7113 
        7114  // Size of this suballocation is too small for this request: Early return.
        7115  if(suballoc.size < allocSize)
        7116  {
        7117  return false;
        7118  }
        7119 
        7120  // Start from offset equal to beginning of this suballocation.
        7121  *pOffset = suballoc.offset;
        7122 
        7123  // Apply VMA_DEBUG_MARGIN at the beginning.
        7124  if(VMA_DEBUG_MARGIN > 0)
        7125  {
        7126  *pOffset += VMA_DEBUG_MARGIN;
        7127  }
        7128 
        7129  // Apply alignment.
        7130  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
        7131 
        7132  // Check previous suballocations for BufferImageGranularity conflicts.
        7133  // Make bigger alignment if necessary.
        7134  if(bufferImageGranularity > 1)
        7135  {
        7136  bool bufferImageGranularityConflict = false;
        7137  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
        7138  while(prevSuballocItem != m_Suballocations.cbegin())
        7139  {
        7140  --prevSuballocItem;
        7141  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
        7142  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
        7143  {
        7144  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        7145  {
        7146  bufferImageGranularityConflict = true;
        7147  break;
        7148  }
        7149  }
        7150  else
        7151  // Already on previous page.
        7152  break;
        7153  }
        7154  if(bufferImageGranularityConflict)
        7155  {
        7156  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
        7157  }
        7158  }
        7159 
        7160  // Calculate padding at the beginning based on current offset.
        7161  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
        7162 
        7163  // Calculate required margin at the end.
        7164  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
        7165 
        7166  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
        7167  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
        7168  {
        7169  return false;
        7170  }
        7171 
        7172  // Check next suballocations for BufferImageGranularity conflicts.
        7173  // If conflict exists, allocation cannot be made here.
        7174  if(bufferImageGranularity > 1)
        7175  {
        7176  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
        7177  ++nextSuballocItem;
        7178  while(nextSuballocItem != m_Suballocations.cend())
        7179  {
        7180  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
        7181  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        7182  {
        7183  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        7184  {
        7185  return false;
        7186  }
        7187  }
        7188  else
        7189  {
        7190  // Already on next page.
        7191  break;
        7192  }
        7193  ++nextSuballocItem;
        7194  }
        7195  }
        7196  }
        7197 
        7198  // All tests passed: Success. pOffset is already filled.
        7199  return true;
        7200 }
        7201 
        7202 void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
        7203 {
        7204  VMA_ASSERT(item != m_Suballocations.end());
        7205  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        7206 
        7207  VmaSuballocationList::iterator nextItem = item;
        7208  ++nextItem;
        7209  VMA_ASSERT(nextItem != m_Suballocations.end());
        7210  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
        7211 
        7212  item->size += nextItem->size;
        7213  --m_FreeCount;
        7214  m_Suballocations.erase(nextItem);
        7215 }
        7216 
        7217 VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
        7218 {
        7219  // Change this suballocation to be marked as free.
        7220  VmaSuballocation& suballoc = *suballocItem;
        7221  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        7222  suballoc.hAllocation = VK_NULL_HANDLE;
        7223 
        7224  // Update totals.
        7225  ++m_FreeCount;
        7226  m_SumFreeSize += suballoc.size;
        7227 
        7228  // Merge with previous and/or next suballocation if it's also free.
        7229  bool mergeWithNext = false;
        7230  bool mergeWithPrev = false;
        7231 
        7232  VmaSuballocationList::iterator nextItem = suballocItem;
        7233  ++nextItem;
        7234  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
        7235  {
        7236  mergeWithNext = true;
        7237  }
        7238 
        7239  VmaSuballocationList::iterator prevItem = suballocItem;
        7240  if(suballocItem != m_Suballocations.begin())
        7241  {
        7242  --prevItem;
        7243  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
        7244  {
        7245  mergeWithPrev = true;
        7246  }
        7247  }
        7248 
        7249  if(mergeWithNext)
        7250  {
        7251  UnregisterFreeSuballocation(nextItem);
        7252  MergeFreeWithNext(suballocItem);
        7253  }
        7254 
        7255  if(mergeWithPrev)
        7256  {
        7257  UnregisterFreeSuballocation(prevItem);
        7258  MergeFreeWithNext(prevItem);
        7259  RegisterFreeSuballocation(prevItem);
        7260  return prevItem;
        7261  }
        7262  else
        7263  {
        7264  RegisterFreeSuballocation(suballocItem);
        7265  return suballocItem;
        7266  }
        7267 }
        7268 
        7269 void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
        7270 {
        7271  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        7272  VMA_ASSERT(item->size > 0);
        7273 
        7274  // You may want to enable this validation at the beginning or at the end of
        7275  // this function, depending on what do you want to check.
        7276  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7277 
        7278  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        7279  {
        7280  if(m_FreeSuballocationsBySize.empty())
        7281  {
        7282  m_FreeSuballocationsBySize.push_back(item);
        7283  }
        7284  else
        7285  {
        7286  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
        7287  }
        7288  }
        7289 
        7290  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7291 }
        7292 
        7293 
        7294 void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
        7295 {
        7296  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
        7297  VMA_ASSERT(item->size > 0);
        7298 
        7299  // You may want to enable this validation at the beginning or at the end of
        7300  // this function, depending on what do you want to check.
        7301  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7302 
        7303  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
        7304  {
        7305  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
        7306  m_FreeSuballocationsBySize.data(),
        7307  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
        7308  item,
        7309  VmaSuballocationItemSizeLess());
        7310  for(size_t index = it - m_FreeSuballocationsBySize.data();
        7311  index < m_FreeSuballocationsBySize.size();
        7312  ++index)
        7313  {
        7314  if(m_FreeSuballocationsBySize[index] == item)
        7315  {
        7316  VmaVectorRemove(m_FreeSuballocationsBySize, index);
        7317  return;
        7318  }
        7319  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
        7320  }
        7321  VMA_ASSERT(0 && "Not found.");
        7322  }
        7323 
        7324  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
        7325 }
        7326 
        7328 // class VmaBlockMetadata_Linear
        7329 
        7330 VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
        7331  m_SumFreeSize(0),
        7332  m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        7333  m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
        7334  m_1stVectorIndex(0),
        7335  m_2ndVectorMode(SECOND_VECTOR_EMPTY),
        7336  m_1stNullItemsBeginCount(0),
        7337  m_1stNullItemsMiddleCount(0),
        7338  m_2ndNullItemsCount(0)
        7339 {
        7340 }
        7341 
        7342 VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
        7343 {
        7344 }
        7345 
        7346 void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
        7347 {
        7348  VmaBlockMetadata::Init(size);
        7349  m_SumFreeSize = size;
        7350 }
        7351 
        7352 bool VmaBlockMetadata_Linear::Validate() const
        7353 {
        7354  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7355  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7356 
        7357  if(suballocations2nd.empty() != (m_2ndVectorMode == SECOND_VECTOR_EMPTY))
        7358  {
        7359  return false;
        7360  }
        7361  if(suballocations1st.empty() && !suballocations2nd.empty() &&
        7362  m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7363  {
        7364  return false;
        7365  }
        7366  if(!suballocations1st.empty())
        7367  {
        7368  // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
        7369  if(suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        7370  {
        7371  return false;
        7372  }
        7373  // Null item at the end should be just pop_back().
        7374  if(suballocations1st.back().hAllocation == VK_NULL_HANDLE)
        7375  {
        7376  return false;
        7377  }
        7378  }
        7379  if(!suballocations2nd.empty())
        7380  {
        7381  // Null item at the end should be just pop_back().
        7382  if(suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
        7383  {
        7384  return false;
        7385  }
        7386  }
        7387 
        7388  if(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount > suballocations1st.size())
        7389  {
        7390  return false;
        7391  }
        7392  if(m_2ndNullItemsCount > suballocations2nd.size())
        7393  {
        7394  return false;
        7395  }
        7396 
        7397  VkDeviceSize sumUsedSize = 0;
        7398  const size_t suballoc1stCount = suballocations1st.size();
        7399  VkDeviceSize offset = VMA_DEBUG_MARGIN;
        7400 
        7401  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7402  {
        7403  const size_t suballoc2ndCount = suballocations2nd.size();
        7404  size_t nullItem2ndCount = 0;
        7405  for(size_t i = 0; i < suballoc2ndCount; ++i)
        7406  {
        7407  const VmaSuballocation& suballoc = suballocations2nd[i];
        7408  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7409 
        7410  if(currFree != (suballoc.hAllocation == VK_NULL_HANDLE))
        7411  {
        7412  return false;
        7413  }
        7414  if(suballoc.offset < offset)
        7415  {
        7416  return false;
        7417  }
        7418 
        7419  if(!currFree)
        7420  {
        7421  if(suballoc.hAllocation->GetOffset() != suballoc.offset)
        7422  {
        7423  return false;
        7424  }
        7425  if(suballoc.hAllocation->GetSize() != suballoc.size)
        7426  {
        7427  return false;
        7428  }
        7429  sumUsedSize += suballoc.size;
        7430  }
        7431  else
        7432  {
        7433  ++nullItem2ndCount;
        7434  }
        7435 
        7436  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        7437  }
        7438 
        7439  if(nullItem2ndCount != m_2ndNullItemsCount)
        7440  {
        7441  return false;
        7442  }
        7443  }
        7444 
        7445  for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
        7446  {
        7447  const VmaSuballocation& suballoc = suballocations1st[i];
        7448  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE ||
        7449  suballoc.hAllocation != VK_NULL_HANDLE)
        7450  {
        7451  return false;
        7452  }
        7453  }
        7454 
        7455  size_t nullItem1stCount = m_1stNullItemsBeginCount;
        7456 
        7457  for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
        7458  {
        7459  const VmaSuballocation& suballoc = suballocations1st[i];
        7460  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7461 
        7462  if(currFree != (suballoc.hAllocation == VK_NULL_HANDLE))
        7463  {
        7464  return false;
        7465  }
        7466  if(suballoc.offset < offset)
        7467  {
        7468  return false;
        7469  }
        7470  if(i < m_1stNullItemsBeginCount && !currFree)
        7471  {
        7472  return false;
        7473  }
        7474 
        7475  if(!currFree)
        7476  {
        7477  if(suballoc.hAllocation->GetOffset() != suballoc.offset)
        7478  {
        7479  return false;
        7480  }
        7481  if(suballoc.hAllocation->GetSize() != suballoc.size)
        7482  {
        7483  return false;
        7484  }
        7485  sumUsedSize += suballoc.size;
        7486  }
        7487  else
        7488  {
        7489  ++nullItem1stCount;
        7490  }
        7491 
        7492  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        7493  }
        7494  if(nullItem1stCount != m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount)
        7495  {
        7496  return false;
        7497  }
        7498 
        7499  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        7500  {
        7501  const size_t suballoc2ndCount = suballocations2nd.size();
        7502  size_t nullItem2ndCount = 0;
        7503  for(size_t i = suballoc2ndCount; i--; )
        7504  {
        7505  const VmaSuballocation& suballoc = suballocations2nd[i];
        7506  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
        7507 
        7508  if(currFree != (suballoc.hAllocation == VK_NULL_HANDLE))
        7509  {
        7510  return false;
        7511  }
        7512  if(suballoc.offset < offset)
        7513  {
        7514  return false;
        7515  }
        7516 
        7517  if(!currFree)
        7518  {
        7519  if(suballoc.hAllocation->GetOffset() != suballoc.offset)
        7520  {
        7521  return false;
        7522  }
        7523  if(suballoc.hAllocation->GetSize() != suballoc.size)
        7524  {
        7525  return false;
        7526  }
        7527  sumUsedSize += suballoc.size;
        7528  }
        7529  else
        7530  {
        7531  ++nullItem2ndCount;
        7532  }
        7533 
        7534  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
        7535  }
        7536 
        7537  if(nullItem2ndCount != m_2ndNullItemsCount)
        7538  {
        7539  return false;
        7540  }
        7541  }
        7542 
        7543  if(offset > GetSize())
        7544  {
        7545  return false;
        7546  }
        7547  if(m_SumFreeSize != GetSize() - sumUsedSize)
        7548  {
        7549  return false;
        7550  }
        7551 
        7552  return true;
        7553 }
        7554 
        7555 size_t VmaBlockMetadata_Linear::GetAllocationCount() const
        7556 {
        7557  return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
        7558  AccessSuballocations2nd().size() - m_2ndNullItemsCount;
        7559 }
        7560 
        7561 VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
        7562 {
        7563  const VkDeviceSize size = GetSize();
        7564 
        7565  /*
        7566  We don't consider gaps inside allocation vectors with freed allocations because
        7567  they are not suitable for reuse in linear allocator. We consider only space that
        7568  is available for new allocations.
        7569  */
        7570  if(IsEmpty())
        7571  {
        7572  return size;
        7573  }
        7574 
        7575  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7576 
        7577  switch(m_2ndVectorMode)
        7578  {
        7579  case SECOND_VECTOR_EMPTY:
        7580  /*
        7581  Available space is after end of 1st, as well as before beginning of 1st (which
        7582  whould make it a ring buffer).
        7583  */
        7584  {
        7585  const size_t suballocations1stCount = suballocations1st.size();
        7586  VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
        7587  const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        7588  const VmaSuballocation& lastSuballoc = suballocations1st[suballocations1stCount - 1];
        7589  return VMA_MAX(
        7590  firstSuballoc.offset,
        7591  size - (lastSuballoc.offset + lastSuballoc.size));
        7592  }
        7593  break;
        7594 
        7595  case SECOND_VECTOR_RING_BUFFER:
        7596  /*
        7597  Available space is only between end of 2nd and beginning of 1st.
        7598  */
        7599  {
        7600  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7601  const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
        7602  const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
        7603  return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
        7604  }
        7605  break;
        7606 
        7607  case SECOND_VECTOR_DOUBLE_STACK:
        7608  /*
        7609  Available space is only between end of 1st and top of 2nd.
        7610  */
        7611  {
        7612  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7613  const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
        7614  const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
        7615  return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
        7616  }
        7617  break;
        7618 
        7619  default:
        7620  VMA_ASSERT(0);
        7621  return 0;
        7622  }
        7623 }
        7624 
        7625 void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
        7626 {
        7627  const VkDeviceSize size = GetSize();
        7628  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7629  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7630  const size_t suballoc1stCount = suballocations1st.size();
        7631  const size_t suballoc2ndCount = suballocations2nd.size();
        7632 
        7633  outInfo.blockCount = 1;
        7634  outInfo.allocationCount = (uint32_t)GetAllocationCount();
        7635  outInfo.unusedRangeCount = 0;
        7636  outInfo.usedBytes = 0;
        7637  outInfo.allocationSizeMin = UINT64_MAX;
        7638  outInfo.allocationSizeMax = 0;
        7639  outInfo.unusedRangeSizeMin = UINT64_MAX;
        7640  outInfo.unusedRangeSizeMax = 0;
        7641 
        7642  VkDeviceSize lastOffset = 0;
        7643 
        7644  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7645  {
        7646  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        7647  size_t nextAlloc2ndIndex = 0;
        7648  while(lastOffset < freeSpace2ndTo1stEnd)
        7649  {
        7650  // Find next non-null allocation or move nextAllocIndex to the end.
        7651  while(nextAlloc2ndIndex < suballoc2ndCount &&
        7652  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7653  {
        7654  ++nextAlloc2ndIndex;
        7655  }
        7656 
        7657  // Found non-null allocation.
        7658  if(nextAlloc2ndIndex < suballoc2ndCount)
        7659  {
        7660  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7661 
        7662  // 1. Process free space before this allocation.
        7663  if(lastOffset < suballoc.offset)
        7664  {
        7665  // There is free space from lastOffset to suballoc.offset.
        7666  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7667  ++outInfo.unusedRangeCount;
        7668  outInfo.unusedBytes += unusedRangeSize;
        7669  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7670  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7671  }
        7672 
        7673  // 2. Process this allocation.
        7674  // There is allocation with suballoc.offset, suballoc.size.
        7675  outInfo.usedBytes += suballoc.size;
        7676  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        7677  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        7678 
        7679  // 3. Prepare for next iteration.
        7680  lastOffset = suballoc.offset + suballoc.size;
        7681  ++nextAlloc2ndIndex;
        7682  }
        7683  // We are at the end.
        7684  else
        7685  {
        7686  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        7687  if(lastOffset < freeSpace2ndTo1stEnd)
        7688  {
        7689  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        7690  ++outInfo.unusedRangeCount;
        7691  outInfo.unusedBytes += unusedRangeSize;
        7692  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7693  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7694  }
        7695 
        7696  // End of loop.
        7697  lastOffset = freeSpace2ndTo1stEnd;
        7698  }
        7699  }
        7700  }
        7701 
        7702  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        7703  const VkDeviceSize freeSpace1stTo2ndEnd =
        7704  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        7705  while(lastOffset < freeSpace1stTo2ndEnd)
        7706  {
        7707  // Find next non-null allocation or move nextAllocIndex to the end.
        7708  while(nextAlloc1stIndex < suballoc1stCount &&
        7709  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        7710  {
        7711  ++nextAlloc1stIndex;
        7712  }
        7713 
        7714  // Found non-null allocation.
        7715  if(nextAlloc1stIndex < suballoc1stCount)
        7716  {
        7717  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        7718 
        7719  // 1. Process free space before this allocation.
        7720  if(lastOffset < suballoc.offset)
        7721  {
        7722  // There is free space from lastOffset to suballoc.offset.
        7723  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7724  ++outInfo.unusedRangeCount;
        7725  outInfo.unusedBytes += unusedRangeSize;
        7726  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7727  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7728  }
        7729 
        7730  // 2. Process this allocation.
        7731  // There is allocation with suballoc.offset, suballoc.size.
        7732  outInfo.usedBytes += suballoc.size;
        7733  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        7734  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        7735 
        7736  // 3. Prepare for next iteration.
        7737  lastOffset = suballoc.offset + suballoc.size;
        7738  ++nextAlloc1stIndex;
        7739  }
        7740  // We are at the end.
        7741  else
        7742  {
        7743  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        7744  if(lastOffset < freeSpace1stTo2ndEnd)
        7745  {
        7746  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        7747  ++outInfo.unusedRangeCount;
        7748  outInfo.unusedBytes += unusedRangeSize;
        7749  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7750  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7751  }
        7752 
        7753  // End of loop.
        7754  lastOffset = freeSpace1stTo2ndEnd;
        7755  }
        7756  }
        7757 
        7758  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        7759  {
        7760  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        7761  while(lastOffset < size)
        7762  {
        7763  // Find next non-null allocation or move nextAllocIndex to the end.
        7764  while(nextAlloc2ndIndex != SIZE_MAX &&
        7765  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7766  {
        7767  --nextAlloc2ndIndex;
        7768  }
        7769 
        7770  // Found non-null allocation.
        7771  if(nextAlloc2ndIndex != SIZE_MAX)
        7772  {
        7773  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7774 
        7775  // 1. Process free space before this allocation.
        7776  if(lastOffset < suballoc.offset)
        7777  {
        7778  // There is free space from lastOffset to suballoc.offset.
        7779  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7780  ++outInfo.unusedRangeCount;
        7781  outInfo.unusedBytes += unusedRangeSize;
        7782  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7783  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7784  }
        7785 
        7786  // 2. Process this allocation.
        7787  // There is allocation with suballoc.offset, suballoc.size.
        7788  outInfo.usedBytes += suballoc.size;
        7789  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
        7790  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
        7791 
        7792  // 3. Prepare for next iteration.
        7793  lastOffset = suballoc.offset + suballoc.size;
        7794  --nextAlloc2ndIndex;
        7795  }
        7796  // We are at the end.
        7797  else
        7798  {
        7799  // There is free space from lastOffset to size.
        7800  if(lastOffset < size)
        7801  {
        7802  const VkDeviceSize unusedRangeSize = size - lastOffset;
        7803  ++outInfo.unusedRangeCount;
        7804  outInfo.unusedBytes += unusedRangeSize;
        7805  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
        7806  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
        7807  }
        7808 
        7809  // End of loop.
        7810  lastOffset = size;
        7811  }
        7812  }
        7813  }
        7814 
        7815  outInfo.unusedBytes = size - outInfo.usedBytes;
        7816 }
        7817 
        7818 void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
        7819 {
        7820  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7821  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7822  const VkDeviceSize size = GetSize();
        7823  const size_t suballoc1stCount = suballocations1st.size();
        7824  const size_t suballoc2ndCount = suballocations2nd.size();
        7825 
        7826  inoutStats.size += size;
        7827 
        7828  VkDeviceSize lastOffset = 0;
        7829 
        7830  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        7831  {
        7832  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        7833  size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
        7834  while(lastOffset < freeSpace2ndTo1stEnd)
        7835  {
        7836  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        7837  while(nextAlloc2ndIndex < suballoc2ndCount &&
        7838  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7839  {
        7840  ++nextAlloc2ndIndex;
        7841  }
        7842 
        7843  // Found non-null allocation.
        7844  if(nextAlloc2ndIndex < suballoc2ndCount)
        7845  {
        7846  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7847 
        7848  // 1. Process free space before this allocation.
        7849  if(lastOffset < suballoc.offset)
        7850  {
        7851  // There is free space from lastOffset to suballoc.offset.
        7852  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7853  inoutStats.unusedSize += unusedRangeSize;
        7854  ++inoutStats.unusedRangeCount;
        7855  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7856  }
        7857 
        7858  // 2. Process this allocation.
        7859  // There is allocation with suballoc.offset, suballoc.size.
        7860  ++inoutStats.allocationCount;
        7861 
        7862  // 3. Prepare for next iteration.
        7863  lastOffset = suballoc.offset + suballoc.size;
        7864  ++nextAlloc2ndIndex;
        7865  }
        7866  // We are at the end.
        7867  else
        7868  {
        7869  if(lastOffset < freeSpace2ndTo1stEnd)
        7870  {
        7871  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        7872  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        7873  inoutStats.unusedSize += unusedRangeSize;
        7874  ++inoutStats.unusedRangeCount;
        7875  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7876  }
        7877 
        7878  // End of loop.
        7879  lastOffset = freeSpace2ndTo1stEnd;
        7880  }
        7881  }
        7882  }
        7883 
        7884  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        7885  const VkDeviceSize freeSpace1stTo2ndEnd =
        7886  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        7887  while(lastOffset < freeSpace1stTo2ndEnd)
        7888  {
        7889  // Find next non-null allocation or move nextAllocIndex to the end.
        7890  while(nextAlloc1stIndex < suballoc1stCount &&
        7891  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        7892  {
        7893  ++nextAlloc1stIndex;
        7894  }
        7895 
        7896  // Found non-null allocation.
        7897  if(nextAlloc1stIndex < suballoc1stCount)
        7898  {
        7899  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        7900 
        7901  // 1. Process free space before this allocation.
        7902  if(lastOffset < suballoc.offset)
        7903  {
        7904  // There is free space from lastOffset to suballoc.offset.
        7905  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7906  inoutStats.unusedSize += unusedRangeSize;
        7907  ++inoutStats.unusedRangeCount;
        7908  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7909  }
        7910 
        7911  // 2. Process this allocation.
        7912  // There is allocation with suballoc.offset, suballoc.size.
        7913  ++inoutStats.allocationCount;
        7914 
        7915  // 3. Prepare for next iteration.
        7916  lastOffset = suballoc.offset + suballoc.size;
        7917  ++nextAlloc1stIndex;
        7918  }
        7919  // We are at the end.
        7920  else
        7921  {
        7922  if(lastOffset < freeSpace1stTo2ndEnd)
        7923  {
        7924  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        7925  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        7926  inoutStats.unusedSize += unusedRangeSize;
        7927  ++inoutStats.unusedRangeCount;
        7928  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7929  }
        7930 
        7931  // End of loop.
        7932  lastOffset = freeSpace1stTo2ndEnd;
        7933  }
        7934  }
        7935 
        7936  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        7937  {
        7938  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        7939  while(lastOffset < size)
        7940  {
        7941  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        7942  while(nextAlloc2ndIndex != SIZE_MAX &&
        7943  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        7944  {
        7945  --nextAlloc2ndIndex;
        7946  }
        7947 
        7948  // Found non-null allocation.
        7949  if(nextAlloc2ndIndex != SIZE_MAX)
        7950  {
        7951  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        7952 
        7953  // 1. Process free space before this allocation.
        7954  if(lastOffset < suballoc.offset)
        7955  {
        7956  // There is free space from lastOffset to suballoc.offset.
        7957  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        7958  inoutStats.unusedSize += unusedRangeSize;
        7959  ++inoutStats.unusedRangeCount;
        7960  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7961  }
        7962 
        7963  // 2. Process this allocation.
        7964  // There is allocation with suballoc.offset, suballoc.size.
        7965  ++inoutStats.allocationCount;
        7966 
        7967  // 3. Prepare for next iteration.
        7968  lastOffset = suballoc.offset + suballoc.size;
        7969  --nextAlloc2ndIndex;
        7970  }
        7971  // We are at the end.
        7972  else
        7973  {
        7974  if(lastOffset < size)
        7975  {
        7976  // There is free space from lastOffset to size.
        7977  const VkDeviceSize unusedRangeSize = size - lastOffset;
        7978  inoutStats.unusedSize += unusedRangeSize;
        7979  ++inoutStats.unusedRangeCount;
        7980  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
        7981  }
        7982 
        7983  // End of loop.
        7984  lastOffset = size;
        7985  }
        7986  }
        7987  }
        7988 }
        7989 
        7990 #if VMA_STATS_STRING_ENABLED
        7991 void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
        7992 {
        7993  const VkDeviceSize size = GetSize();
        7994  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        7995  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        7996  const size_t suballoc1stCount = suballocations1st.size();
        7997  const size_t suballoc2ndCount = suballocations2nd.size();
        7998 
        7999  // FIRST PASS
        8000 
        8001  size_t unusedRangeCount = 0;
        8002  VkDeviceSize usedBytes = 0;
        8003 
        8004  VkDeviceSize lastOffset = 0;
        8005 
        8006  size_t alloc2ndCount = 0;
        8007  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8008  {
        8009  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        8010  size_t nextAlloc2ndIndex = 0;
        8011  while(lastOffset < freeSpace2ndTo1stEnd)
        8012  {
        8013  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8014  while(nextAlloc2ndIndex < suballoc2ndCount &&
        8015  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8016  {
        8017  ++nextAlloc2ndIndex;
        8018  }
        8019 
        8020  // Found non-null allocation.
        8021  if(nextAlloc2ndIndex < suballoc2ndCount)
        8022  {
        8023  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8024 
        8025  // 1. Process free space before this allocation.
        8026  if(lastOffset < suballoc.offset)
        8027  {
        8028  // There is free space from lastOffset to suballoc.offset.
        8029  ++unusedRangeCount;
        8030  }
        8031 
        8032  // 2. Process this allocation.
        8033  // There is allocation with suballoc.offset, suballoc.size.
        8034  ++alloc2ndCount;
        8035  usedBytes += suballoc.size;
        8036 
        8037  // 3. Prepare for next iteration.
        8038  lastOffset = suballoc.offset + suballoc.size;
        8039  ++nextAlloc2ndIndex;
        8040  }
        8041  // We are at the end.
        8042  else
        8043  {
        8044  if(lastOffset < freeSpace2ndTo1stEnd)
        8045  {
        8046  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        8047  ++unusedRangeCount;
        8048  }
        8049 
        8050  // End of loop.
        8051  lastOffset = freeSpace2ndTo1stEnd;
        8052  }
        8053  }
        8054  }
        8055 
        8056  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
        8057  size_t alloc1stCount = 0;
        8058  const VkDeviceSize freeSpace1stTo2ndEnd =
        8059  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
        8060  while(lastOffset < freeSpace1stTo2ndEnd)
        8061  {
        8062  // Find next non-null allocation or move nextAllocIndex to the end.
        8063  while(nextAlloc1stIndex < suballoc1stCount &&
        8064  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        8065  {
        8066  ++nextAlloc1stIndex;
        8067  }
        8068 
        8069  // Found non-null allocation.
        8070  if(nextAlloc1stIndex < suballoc1stCount)
        8071  {
        8072  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        8073 
        8074  // 1. Process free space before this allocation.
        8075  if(lastOffset < suballoc.offset)
        8076  {
        8077  // There is free space from lastOffset to suballoc.offset.
        8078  ++unusedRangeCount;
        8079  }
        8080 
        8081  // 2. Process this allocation.
        8082  // There is allocation with suballoc.offset, suballoc.size.
        8083  ++alloc1stCount;
        8084  usedBytes += suballoc.size;
        8085 
        8086  // 3. Prepare for next iteration.
        8087  lastOffset = suballoc.offset + suballoc.size;
        8088  ++nextAlloc1stIndex;
        8089  }
        8090  // We are at the end.
        8091  else
        8092  {
        8093  if(lastOffset < size)
        8094  {
        8095  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        8096  ++unusedRangeCount;
        8097  }
        8098 
        8099  // End of loop.
        8100  lastOffset = freeSpace1stTo2ndEnd;
        8101  }
        8102  }
        8103 
        8104  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8105  {
        8106  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        8107  while(lastOffset < size)
        8108  {
        8109  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8110  while(nextAlloc2ndIndex != SIZE_MAX &&
        8111  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8112  {
        8113  --nextAlloc2ndIndex;
        8114  }
        8115 
        8116  // Found non-null allocation.
        8117  if(nextAlloc2ndIndex != SIZE_MAX)
        8118  {
        8119  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8120 
        8121  // 1. Process free space before this allocation.
        8122  if(lastOffset < suballoc.offset)
        8123  {
        8124  // There is free space from lastOffset to suballoc.offset.
        8125  ++unusedRangeCount;
        8126  }
        8127 
        8128  // 2. Process this allocation.
        8129  // There is allocation with suballoc.offset, suballoc.size.
        8130  ++alloc2ndCount;
        8131  usedBytes += suballoc.size;
        8132 
        8133  // 3. Prepare for next iteration.
        8134  lastOffset = suballoc.offset + suballoc.size;
        8135  --nextAlloc2ndIndex;
        8136  }
        8137  // We are at the end.
        8138  else
        8139  {
        8140  if(lastOffset < size)
        8141  {
        8142  // There is free space from lastOffset to size.
        8143  ++unusedRangeCount;
        8144  }
        8145 
        8146  // End of loop.
        8147  lastOffset = size;
        8148  }
        8149  }
        8150  }
        8151 
        8152  const VkDeviceSize unusedBytes = size - usedBytes;
        8153  PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
        8154 
        8155  // SECOND PASS
        8156  lastOffset = 0;
        8157 
        8158  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8159  {
        8160  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
        8161  size_t nextAlloc2ndIndex = 0;
        8162  while(lastOffset < freeSpace2ndTo1stEnd)
        8163  {
        8164  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8165  while(nextAlloc2ndIndex < suballoc2ndCount &&
        8166  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8167  {
        8168  ++nextAlloc2ndIndex;
        8169  }
        8170 
        8171  // Found non-null allocation.
        8172  if(nextAlloc2ndIndex < suballoc2ndCount)
        8173  {
        8174  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8175 
        8176  // 1. Process free space before this allocation.
        8177  if(lastOffset < suballoc.offset)
        8178  {
        8179  // There is free space from lastOffset to suballoc.offset.
        8180  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        8181  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8182  }
        8183 
        8184  // 2. Process this allocation.
        8185  // There is allocation with suballoc.offset, suballoc.size.
        8186  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        8187 
        8188  // 3. Prepare for next iteration.
        8189  lastOffset = suballoc.offset + suballoc.size;
        8190  ++nextAlloc2ndIndex;
        8191  }
        8192  // We are at the end.
        8193  else
        8194  {
        8195  if(lastOffset < freeSpace2ndTo1stEnd)
        8196  {
        8197  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
        8198  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
        8199  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8200  }
        8201 
        8202  // End of loop.
        8203  lastOffset = freeSpace2ndTo1stEnd;
        8204  }
        8205  }
        8206  }
        8207 
        8208  nextAlloc1stIndex = m_1stNullItemsBeginCount;
        8209  while(lastOffset < freeSpace1stTo2ndEnd)
        8210  {
        8211  // Find next non-null allocation or move nextAllocIndex to the end.
        8212  while(nextAlloc1stIndex < suballoc1stCount &&
        8213  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
        8214  {
        8215  ++nextAlloc1stIndex;
        8216  }
        8217 
        8218  // Found non-null allocation.
        8219  if(nextAlloc1stIndex < suballoc1stCount)
        8220  {
        8221  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
        8222 
        8223  // 1. Process free space before this allocation.
        8224  if(lastOffset < suballoc.offset)
        8225  {
        8226  // There is free space from lastOffset to suballoc.offset.
        8227  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        8228  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8229  }
        8230 
        8231  // 2. Process this allocation.
        8232  // There is allocation with suballoc.offset, suballoc.size.
        8233  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        8234 
        8235  // 3. Prepare for next iteration.
        8236  lastOffset = suballoc.offset + suballoc.size;
        8237  ++nextAlloc1stIndex;
        8238  }
        8239  // We are at the end.
        8240  else
        8241  {
        8242  if(lastOffset < freeSpace1stTo2ndEnd)
        8243  {
        8244  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
        8245  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
        8246  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8247  }
        8248 
        8249  // End of loop.
        8250  lastOffset = freeSpace1stTo2ndEnd;
        8251  }
        8252  }
        8253 
        8254  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8255  {
        8256  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
        8257  while(lastOffset < size)
        8258  {
        8259  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
        8260  while(nextAlloc2ndIndex != SIZE_MAX &&
        8261  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
        8262  {
        8263  --nextAlloc2ndIndex;
        8264  }
        8265 
        8266  // Found non-null allocation.
        8267  if(nextAlloc2ndIndex != SIZE_MAX)
        8268  {
        8269  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
        8270 
        8271  // 1. Process free space before this allocation.
        8272  if(lastOffset < suballoc.offset)
        8273  {
        8274  // There is free space from lastOffset to suballoc.offset.
        8275  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
        8276  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8277  }
        8278 
        8279  // 2. Process this allocation.
        8280  // There is allocation with suballoc.offset, suballoc.size.
        8281  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
        8282 
        8283  // 3. Prepare for next iteration.
        8284  lastOffset = suballoc.offset + suballoc.size;
        8285  --nextAlloc2ndIndex;
        8286  }
        8287  // We are at the end.
        8288  else
        8289  {
        8290  if(lastOffset < size)
        8291  {
        8292  // There is free space from lastOffset to size.
        8293  const VkDeviceSize unusedRangeSize = size - lastOffset;
        8294  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
        8295  }
        8296 
        8297  // End of loop.
        8298  lastOffset = size;
        8299  }
        8300  }
        8301  }
        8302 
        8303  PrintDetailedMap_End(json);
        8304 }
        8305 #endif // #if VMA_STATS_STRING_ENABLED
        8306 
        8307 bool VmaBlockMetadata_Linear::CreateAllocationRequest(
        8308  uint32_t currentFrameIndex,
        8309  uint32_t frameInUseCount,
        8310  VkDeviceSize bufferImageGranularity,
        8311  VkDeviceSize allocSize,
        8312  VkDeviceSize allocAlignment,
        8313  bool upperAddress,
        8314  VmaSuballocationType allocType,
        8315  bool canMakeOtherLost,
        8316  VmaAllocationRequest* pAllocationRequest)
        8317 {
        8318  VMA_ASSERT(allocSize > 0);
        8319  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
        8320  VMA_ASSERT(pAllocationRequest != VMA_NULL);
        8321  VMA_HEAVY_ASSERT(Validate());
        8322 
        8323  const VkDeviceSize size = GetSize();
        8324  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8325  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8326 
        8327  if(upperAddress)
        8328  {
        8329  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8330  {
        8331  VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
        8332  return false;
        8333  }
        8334 
        8335  // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
        8336  if(allocSize > size)
        8337  {
        8338  return false;
        8339  }
        8340  VkDeviceSize resultBaseOffset = size - allocSize;
        8341  if(!suballocations2nd.empty())
        8342  {
        8343  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        8344  resultBaseOffset = lastSuballoc.offset - allocSize;
        8345  if(allocSize > lastSuballoc.offset)
        8346  {
        8347  return false;
        8348  }
        8349  }
        8350 
        8351  // Start from offset equal to end of free space.
        8352  VkDeviceSize resultOffset = resultBaseOffset;
        8353 
        8354  // Apply VMA_DEBUG_MARGIN at the end.
        8355  if(VMA_DEBUG_MARGIN > 0)
        8356  {
        8357  if(resultOffset < VMA_DEBUG_MARGIN)
        8358  {
        8359  return false;
        8360  }
        8361  resultOffset -= VMA_DEBUG_MARGIN;
        8362  }
        8363 
        8364  // Apply alignment.
        8365  resultOffset = VmaAlignDown(resultOffset, allocAlignment);
        8366 
        8367  // Check next suballocations from 2nd for BufferImageGranularity conflicts.
        8368  // Make bigger alignment if necessary.
        8369  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        8370  {
        8371  bool bufferImageGranularityConflict = false;
        8372  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        8373  {
        8374  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        8375  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        8376  {
        8377  if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
        8378  {
        8379  bufferImageGranularityConflict = true;
        8380  break;
        8381  }
        8382  }
        8383  else
        8384  // Already on previous page.
        8385  break;
        8386  }
        8387  if(bufferImageGranularityConflict)
        8388  {
        8389  resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
        8390  }
        8391  }
        8392 
        8393  // There is enough free space.
        8394  const VkDeviceSize endOf1st = !suballocations1st.empty() ?
        8395  suballocations1st.back().offset + suballocations1st.back().size :
        8396  0;
        8397  if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
        8398  {
        8399  // Check previous suballocations for BufferImageGranularity conflicts.
        8400  // If conflict exists, allocation cannot be made here.
        8401  if(bufferImageGranularity > 1)
        8402  {
        8403  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        8404  {
        8405  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        8406  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        8407  {
        8408  if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
        8409  {
        8410  return false;
        8411  }
        8412  }
        8413  else
        8414  {
        8415  // Already on next page.
        8416  break;
        8417  }
        8418  }
        8419  }
        8420 
        8421  // All tests passed: Success.
        8422  pAllocationRequest->offset = resultOffset;
        8423  pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
        8424  pAllocationRequest->sumItemSize = 0;
        8425  // pAllocationRequest->item unused.
        8426  pAllocationRequest->itemsToMakeLostCount = 0;
        8427  return true;
        8428  }
        8429  }
        8430  else // !upperAddress
        8431  {
        8432  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8433  {
        8434  // Try to allocate at the end of 1st vector.
        8435 
        8436  VkDeviceSize resultBaseOffset = 0;
        8437  if(!suballocations1st.empty())
        8438  {
        8439  const VmaSuballocation& lastSuballoc = suballocations1st.back();
        8440  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        8441  }
        8442 
        8443  // Start from offset equal to beginning of free space.
        8444  VkDeviceSize resultOffset = resultBaseOffset;
        8445 
        8446  // Apply VMA_DEBUG_MARGIN at the beginning.
        8447  if(VMA_DEBUG_MARGIN > 0)
        8448  {
        8449  resultOffset += VMA_DEBUG_MARGIN;
        8450  }
        8451 
        8452  // Apply alignment.
        8453  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        8454 
        8455  // Check previous suballocations for BufferImageGranularity conflicts.
        8456  // Make bigger alignment if necessary.
        8457  if(bufferImageGranularity > 1 && !suballocations1st.empty())
        8458  {
        8459  bool bufferImageGranularityConflict = false;
        8460  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
        8461  {
        8462  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
        8463  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        8464  {
        8465  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        8466  {
        8467  bufferImageGranularityConflict = true;
        8468  break;
        8469  }
        8470  }
        8471  else
        8472  // Already on previous page.
        8473  break;
        8474  }
        8475  if(bufferImageGranularityConflict)
        8476  {
        8477  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        8478  }
        8479  }
        8480 
        8481  const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
        8482  suballocations2nd.back().offset : size;
        8483 
        8484  // There is enough free space at the end after alignment.
        8485  if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
        8486  {
        8487  // Check next suballocations for BufferImageGranularity conflicts.
        8488  // If conflict exists, allocation cannot be made here.
        8489  if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8490  {
        8491  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
        8492  {
        8493  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
        8494  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        8495  {
        8496  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        8497  {
        8498  return false;
        8499  }
        8500  }
        8501  else
        8502  {
        8503  // Already on previous page.
        8504  break;
        8505  }
        8506  }
        8507  }
        8508 
        8509  // All tests passed: Success.
        8510  pAllocationRequest->offset = resultOffset;
        8511  pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
        8512  pAllocationRequest->sumItemSize = 0;
        8513  // pAllocationRequest->item unused.
        8514  pAllocationRequest->itemsToMakeLostCount = 0;
        8515  return true;
        8516  }
        8517  }
        8518 
        8519  // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
        8520  // beginning of 1st vector as the end of free space.
        8521  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        8522  {
        8523  VMA_ASSERT(!suballocations1st.empty());
        8524 
        8525  VkDeviceSize resultBaseOffset = 0;
        8526  if(!suballocations2nd.empty())
        8527  {
        8528  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
        8529  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
        8530  }
        8531 
        8532  // Start from offset equal to beginning of free space.
        8533  VkDeviceSize resultOffset = resultBaseOffset;
        8534 
        8535  // Apply VMA_DEBUG_MARGIN at the beginning.
        8536  if(VMA_DEBUG_MARGIN > 0)
        8537  {
        8538  resultOffset += VMA_DEBUG_MARGIN;
        8539  }
        8540 
        8541  // Apply alignment.
        8542  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
        8543 
        8544  // Check previous suballocations for BufferImageGranularity conflicts.
        8545  // Make bigger alignment if necessary.
        8546  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
        8547  {
        8548  bool bufferImageGranularityConflict = false;
        8549  for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
        8550  {
        8551  const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
        8552  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
        8553  {
        8554  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
        8555  {
        8556  bufferImageGranularityConflict = true;
        8557  break;
        8558  }
        8559  }
        8560  else
        8561  // Already on previous page.
        8562  break;
        8563  }
        8564  if(bufferImageGranularityConflict)
        8565  {
        8566  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
        8567  }
        8568  }
        8569 
        8570  pAllocationRequest->itemsToMakeLostCount = 0;
        8571  pAllocationRequest->sumItemSize = 0;
        8572  size_t index1st = m_1stNullItemsBeginCount;
        8573 
        8574  if(canMakeOtherLost)
        8575  {
        8576  while(index1st < suballocations1st.size() &&
        8577  resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
        8578  {
        8579  // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
        8580  const VmaSuballocation& suballoc = suballocations1st[index1st];
        8581  if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
        8582  {
        8583  // No problem.
        8584  }
        8585  else
        8586  {
        8587  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        8588  if(suballoc.hAllocation->CanBecomeLost() &&
        8589  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        8590  {
        8591  ++pAllocationRequest->itemsToMakeLostCount;
        8592  pAllocationRequest->sumItemSize += suballoc.size;
        8593  }
        8594  else
        8595  {
        8596  return false;
        8597  }
        8598  }
        8599  ++index1st;
        8600  }
        8601 
        8602  // Check next suballocations for BufferImageGranularity conflicts.
        8603  // If conflict exists, we must mark more allocations lost or fail.
        8604  if(bufferImageGranularity > 1)
        8605  {
        8606  while(index1st < suballocations1st.size())
        8607  {
        8608  const VmaSuballocation& suballoc = suballocations1st[index1st];
        8609  if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
        8610  {
        8611  if(suballoc.hAllocation != VK_NULL_HANDLE)
        8612  {
        8613  // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
        8614  if(suballoc.hAllocation->CanBecomeLost() &&
        8615  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
        8616  {
        8617  ++pAllocationRequest->itemsToMakeLostCount;
        8618  pAllocationRequest->sumItemSize += suballoc.size;
        8619  }
        8620  else
        8621  {
        8622  return false;
        8623  }
        8624  }
        8625  }
        8626  else
        8627  {
        8628  // Already on next page.
        8629  break;
        8630  }
        8631  ++index1st;
        8632  }
        8633  }
        8634  }
        8635 
        8636  // There is enough free space at the end after alignment.
        8637  if(index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN < size ||
        8638  index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset)
        8639  {
        8640  // Check next suballocations for BufferImageGranularity conflicts.
        8641  // If conflict exists, allocation cannot be made here.
        8642  if(bufferImageGranularity > 1)
        8643  {
        8644  for(size_t nextSuballocIndex = index1st;
        8645  nextSuballocIndex < suballocations1st.size();
        8646  nextSuballocIndex++)
        8647  {
        8648  const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
        8649  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
        8650  {
        8651  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
        8652  {
        8653  return false;
        8654  }
        8655  }
        8656  else
        8657  {
        8658  // Already on next page.
        8659  break;
        8660  }
        8661  }
        8662  }
        8663 
        8664  // All tests passed: Success.
        8665  pAllocationRequest->offset = resultOffset;
        8666  pAllocationRequest->sumFreeSize =
        8667  (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
        8668  - resultBaseOffset
        8669  - pAllocationRequest->sumItemSize;
        8670  // pAllocationRequest->item unused.
        8671  return true;
        8672  }
        8673  }
        8674  }
        8675 
        8676  return false;
        8677 }
        8678 
        8679 bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
        8680  uint32_t currentFrameIndex,
        8681  uint32_t frameInUseCount,
        8682  VmaAllocationRequest* pAllocationRequest)
        8683 {
        8684  if(pAllocationRequest->itemsToMakeLostCount == 0)
        8685  {
        8686  return true;
        8687  }
        8688 
        8689  VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
        8690 
        8691  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8692  size_t index1st = m_1stNullItemsBeginCount;
        8693  size_t madeLostCount = 0;
        8694  while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
        8695  {
        8696  VMA_ASSERT(index1st < suballocations1st.size());
        8697  VmaSuballocation& suballoc = suballocations1st[index1st];
        8698  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        8699  {
        8700  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
        8701  VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
        8702  if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        8703  {
        8704  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8705  suballoc.hAllocation = VK_NULL_HANDLE;
        8706  m_SumFreeSize += suballoc.size;
        8707  ++m_1stNullItemsMiddleCount;
        8708  ++madeLostCount;
        8709  }
        8710  else
        8711  {
        8712  return false;
        8713  }
        8714  }
        8715  ++index1st;
        8716  }
        8717 
        8718  CleanupAfterFree();
        8719  //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
        8720 
        8721  return true;
        8722 }
        8723 
        8724 uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
        8725 {
        8726  uint32_t lostAllocationCount = 0;
        8727 
        8728  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8729  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        8730  {
        8731  VmaSuballocation& suballoc = suballocations1st[i];
        8732  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        8733  suballoc.hAllocation->CanBecomeLost() &&
        8734  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        8735  {
        8736  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8737  suballoc.hAllocation = VK_NULL_HANDLE;
        8738  ++m_1stNullItemsMiddleCount;
        8739  m_SumFreeSize += suballoc.size;
        8740  ++lostAllocationCount;
        8741  }
        8742  }
        8743 
        8744  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8745  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        8746  {
        8747  VmaSuballocation& suballoc = suballocations2nd[i];
        8748  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
        8749  suballoc.hAllocation->CanBecomeLost() &&
        8750  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
        8751  {
        8752  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8753  suballoc.hAllocation = VK_NULL_HANDLE;
        8754  ++m_2ndNullItemsCount;
        8755  ++lostAllocationCount;
        8756  }
        8757  }
        8758 
        8759  if(lostAllocationCount)
        8760  {
        8761  CleanupAfterFree();
        8762  }
        8763 
        8764  return lostAllocationCount;
        8765 }
        8766 
        8767 VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
        8768 {
        8769  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8770  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
        8771  {
        8772  const VmaSuballocation& suballoc = suballocations1st[i];
        8773  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        8774  {
        8775  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        8776  {
        8777  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        8778  return VK_ERROR_VALIDATION_FAILED_EXT;
        8779  }
        8780  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        8781  {
        8782  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        8783  return VK_ERROR_VALIDATION_FAILED_EXT;
        8784  }
        8785  }
        8786  }
        8787 
        8788  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8789  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
        8790  {
        8791  const VmaSuballocation& suballoc = suballocations2nd[i];
        8792  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
        8793  {
        8794  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
        8795  {
        8796  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
        8797  return VK_ERROR_VALIDATION_FAILED_EXT;
        8798  }
        8799  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
        8800  {
        8801  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
        8802  return VK_ERROR_VALIDATION_FAILED_EXT;
        8803  }
        8804  }
        8805  }
        8806 
        8807  return VK_SUCCESS;
        8808 }
        8809 
        8810 void VmaBlockMetadata_Linear::Alloc(
        8811  const VmaAllocationRequest& request,
        8812  VmaSuballocationType type,
        8813  VkDeviceSize allocSize,
        8814  bool upperAddress,
        8815  VmaAllocation hAllocation)
        8816 {
        8817  const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
        8818 
        8819  if(upperAddress)
        8820  {
        8821  VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
        8822  "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
        8823  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8824  suballocations2nd.push_back(newSuballoc);
        8825  m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
        8826  }
        8827  else
        8828  {
        8829  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8830 
        8831  // First allocation.
        8832  if(suballocations1st.empty())
        8833  {
        8834  suballocations1st.push_back(newSuballoc);
        8835  }
        8836  else
        8837  {
        8838  // New allocation at the end of 1st vector.
        8839  if(request.offset >= suballocations1st.back().offset + suballocations1st.back().size)
        8840  {
        8841  // Check if it fits before the end of the block.
        8842  VMA_ASSERT(request.offset + allocSize <= GetSize());
        8843  suballocations1st.push_back(newSuballoc);
        8844  }
        8845  // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
        8846  else if(request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset)
        8847  {
        8848  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8849 
        8850  switch(m_2ndVectorMode)
        8851  {
        8852  case SECOND_VECTOR_EMPTY:
        8853  // First allocation from second part ring buffer.
        8854  VMA_ASSERT(suballocations2nd.empty());
        8855  m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
        8856  break;
        8857  case SECOND_VECTOR_RING_BUFFER:
        8858  // 2-part ring buffer is already started.
        8859  VMA_ASSERT(!suballocations2nd.empty());
        8860  break;
        8861  case SECOND_VECTOR_DOUBLE_STACK:
        8862  VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
        8863  break;
        8864  default:
        8865  VMA_ASSERT(0);
        8866  }
        8867 
        8868  suballocations2nd.push_back(newSuballoc);
        8869  }
        8870  else
        8871  {
        8872  VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
        8873  }
        8874  }
        8875  }
        8876 
        8877  m_SumFreeSize -= newSuballoc.size;
        8878 }
        8879 
        8880 void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
        8881 {
        8882  FreeAtOffset(allocation->GetOffset());
        8883 }
        8884 
        8885 void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
        8886 {
        8887  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8888  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8889 
        8890  if(!suballocations1st.empty())
        8891  {
        8892  // First allocation: Mark it as next empty at the beginning.
        8893  VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
        8894  if(firstSuballoc.offset == offset)
        8895  {
        8896  firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
        8897  firstSuballoc.hAllocation = VK_NULL_HANDLE;
        8898  m_SumFreeSize += firstSuballoc.size;
        8899  ++m_1stNullItemsBeginCount;
        8900  CleanupAfterFree();
        8901  return;
        8902  }
        8903  }
        8904 
        8905  // Last allocation in 2-part ring buffer or top of upper stack (same logic).
        8906  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
        8907  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
        8908  {
        8909  VmaSuballocation& lastSuballoc = suballocations2nd.back();
        8910  if(lastSuballoc.offset == offset)
        8911  {
        8912  m_SumFreeSize += lastSuballoc.size;
        8913  suballocations2nd.pop_back();
        8914  CleanupAfterFree();
        8915  return;
        8916  }
        8917  }
        8918  // Last allocation in 1st vector.
        8919  else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
        8920  {
        8921  VmaSuballocation& lastSuballoc = suballocations1st.back();
        8922  if(lastSuballoc.offset == offset)
        8923  {
        8924  m_SumFreeSize += lastSuballoc.size;
        8925  suballocations1st.pop_back();
        8926  CleanupAfterFree();
        8927  return;
        8928  }
        8929  }
        8930 
        8931  // Item from the middle of 1st vector.
        8932  {
        8933  VmaSuballocation refSuballoc;
        8934  refSuballoc.offset = offset;
        8935  // Rest of members stays uninitialized intentionally for better performance.
        8936  SuballocationVectorType::iterator it = VmaVectorFindSorted<VmaSuballocationOffsetLess>(
        8937  suballocations1st.begin() + m_1stNullItemsBeginCount,
        8938  suballocations1st.end(),
        8939  refSuballoc);
        8940  if(it != suballocations1st.end())
        8941  {
        8942  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        8943  it->hAllocation = VK_NULL_HANDLE;
        8944  ++m_1stNullItemsMiddleCount;
        8945  m_SumFreeSize += it->size;
        8946  CleanupAfterFree();
        8947  return;
        8948  }
        8949  }
        8950 
        8951  if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
        8952  {
        8953  // Item from the middle of 2nd vector.
        8954  VmaSuballocation refSuballoc;
        8955  refSuballoc.offset = offset;
        8956  // Rest of members stays uninitialized intentionally for better performance.
        8957  SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
        8958  VmaVectorFindSorted<VmaSuballocationOffsetLess>(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc) :
        8959  VmaVectorFindSorted<VmaSuballocationOffsetGreater>(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc);
        8960  if(it != suballocations2nd.end())
        8961  {
        8962  it->type = VMA_SUBALLOCATION_TYPE_FREE;
        8963  it->hAllocation = VK_NULL_HANDLE;
        8964  ++m_2ndNullItemsCount;
        8965  m_SumFreeSize += it->size;
        8966  CleanupAfterFree();
        8967  return;
        8968  }
        8969  }
        8970 
        8971  VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
        8972 }
        8973 
        8974 bool VmaBlockMetadata_Linear::ShouldCompact1st() const
        8975 {
        8976  const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        8977  const size_t suballocCount = AccessSuballocations1st().size();
        8978  return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
        8979 }
        8980 
        8981 void VmaBlockMetadata_Linear::CleanupAfterFree()
        8982 {
        8983  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
        8984  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
        8985 
        8986  if(IsEmpty())
        8987  {
        8988  suballocations1st.clear();
        8989  suballocations2nd.clear();
        8990  m_1stNullItemsBeginCount = 0;
        8991  m_1stNullItemsMiddleCount = 0;
        8992  m_2ndNullItemsCount = 0;
        8993  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        8994  }
        8995  else
        8996  {
        8997  const size_t suballoc1stCount = suballocations1st.size();
        8998  const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
        8999  VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
        9000 
        9001  // Find more null items at the beginning of 1st vector.
        9002  while(m_1stNullItemsBeginCount < suballoc1stCount &&
        9003  suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        9004  {
        9005  ++m_1stNullItemsBeginCount;
        9006  --m_1stNullItemsMiddleCount;
        9007  }
        9008 
        9009  // Find more null items at the end of 1st vector.
        9010  while(m_1stNullItemsMiddleCount > 0 &&
        9011  suballocations1st.back().hAllocation == VK_NULL_HANDLE)
        9012  {
        9013  --m_1stNullItemsMiddleCount;
        9014  suballocations1st.pop_back();
        9015  }
        9016 
        9017  // Find more null items at the end of 2nd vector.
        9018  while(m_2ndNullItemsCount > 0 &&
        9019  suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
        9020  {
        9021  --m_2ndNullItemsCount;
        9022  suballocations2nd.pop_back();
        9023  }
        9024 
        9025  if(ShouldCompact1st())
        9026  {
        9027  const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
        9028  size_t srcIndex = m_1stNullItemsBeginCount;
        9029  for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
        9030  {
        9031  while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
        9032  {
        9033  ++srcIndex;
        9034  }
        9035  if(dstIndex != srcIndex)
        9036  {
        9037  suballocations1st[dstIndex] = suballocations1st[srcIndex];
        9038  }
        9039  ++srcIndex;
        9040  }
        9041  suballocations1st.resize(nonNullItemCount);
        9042  m_1stNullItemsBeginCount = 0;
        9043  m_1stNullItemsMiddleCount = 0;
        9044  }
        9045 
        9046  // 2nd vector became empty.
        9047  if(suballocations2nd.empty())
        9048  {
        9049  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        9050  }
        9051 
        9052  // 1st vector became empty.
        9053  if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
        9054  {
        9055  suballocations1st.clear();
        9056  m_1stNullItemsBeginCount = 0;
        9057 
        9058  if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
        9059  {
        9060  // Swap 1st with 2nd. Now 2nd is empty.
        9061  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
        9062  m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
        9063  while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
        9064  suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
        9065  {
        9066  ++m_1stNullItemsBeginCount;
        9067  --m_1stNullItemsMiddleCount;
        9068  }
        9069  m_2ndNullItemsCount = 0;
        9070  m_1stVectorIndex ^= 1;
        9071  }
        9072  }
        9073  }
        9074 
        9075  VMA_HEAVY_ASSERT(Validate());
        9076 }
        9077 
        9078 
        9080 // class VmaDeviceMemoryBlock
        9081 
        9082 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
        9083  m_pMetadata(VMA_NULL),
        9084  m_MemoryTypeIndex(UINT32_MAX),
        9085  m_Id(0),
        9086  m_hMemory(VK_NULL_HANDLE),
        9087  m_MapCount(0),
        9088  m_pMappedData(VMA_NULL)
        9089 {
        9090 }
        9091 
        9092 void VmaDeviceMemoryBlock::Init(
        9093  VmaAllocator hAllocator,
        9094  uint32_t newMemoryTypeIndex,
        9095  VkDeviceMemory newMemory,
        9096  VkDeviceSize newSize,
        9097  uint32_t id,
        9098  bool linearAlgorithm)
        9099 {
        9100  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
        9101 
        9102  m_MemoryTypeIndex = newMemoryTypeIndex;
        9103  m_Id = id;
        9104  m_hMemory = newMemory;
        9105 
        9106  if(linearAlgorithm)
        9107  {
        9108  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
        9109  }
        9110  else
        9111  {
        9112  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
        9113  }
        9114  m_pMetadata->Init(newSize);
        9115 }
        9116 
        9117 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
        9118 {
        9119  // This is the most important assert in the entire library.
        9120  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
        9121  VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
        9122 
        9123  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
        9124  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
        9125  m_hMemory = VK_NULL_HANDLE;
        9126 
        9127  vma_delete(allocator, m_pMetadata);
        9128  m_pMetadata = VMA_NULL;
        9129 }
        9130 
        9131 bool VmaDeviceMemoryBlock::Validate() const
        9132 {
        9133  if((m_hMemory == VK_NULL_HANDLE) ||
        9134  (m_pMetadata->GetSize() == 0))
        9135  {
        9136  return false;
        9137  }
        9138 
        9139  return m_pMetadata->Validate();
        9140 }
        9141 
        9142 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
        9143 {
        9144  void* pData = nullptr;
        9145  VkResult res = Map(hAllocator, 1, &pData);
        9146  if(res != VK_SUCCESS)
        9147  {
        9148  return res;
        9149  }
        9150 
        9151  res = m_pMetadata->CheckCorruption(pData);
        9152 
        9153  Unmap(hAllocator, 1);
        9154 
        9155  return res;
        9156 }
        9157 
        9158 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
        9159 {
        9160  if(count == 0)
        9161  {
        9162  return VK_SUCCESS;
        9163  }
        9164 
        9165  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9166  if(m_MapCount != 0)
        9167  {
        9168  m_MapCount += count;
        9169  VMA_ASSERT(m_pMappedData != VMA_NULL);
        9170  if(ppData != VMA_NULL)
        9171  {
        9172  *ppData = m_pMappedData;
        9173  }
        9174  return VK_SUCCESS;
        9175  }
        9176  else
        9177  {
        9178  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
        9179  hAllocator->m_hDevice,
        9180  m_hMemory,
        9181  0, // offset
        9182  VK_WHOLE_SIZE,
        9183  0, // flags
        9184  &m_pMappedData);
        9185  if(result == VK_SUCCESS)
        9186  {
        9187  if(ppData != VMA_NULL)
        9188  {
        9189  *ppData = m_pMappedData;
        9190  }
        9191  m_MapCount = count;
        9192  }
        9193  return result;
        9194  }
        9195 }
        9196 
        9197 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
        9198 {
        9199  if(count == 0)
        9200  {
        9201  return;
        9202  }
        9203 
        9204  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9205  if(m_MapCount >= count)
        9206  {
        9207  m_MapCount -= count;
        9208  if(m_MapCount == 0)
        9209  {
        9210  m_pMappedData = VMA_NULL;
        9211  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
        9212  }
        9213  }
        9214  else
        9215  {
        9216  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
        9217  }
        9218 }
        9219 
        9220 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        9221 {
        9222  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        9223  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        9224 
        9225  void* pData;
        9226  VkResult res = Map(hAllocator, 1, &pData);
        9227  if(res != VK_SUCCESS)
        9228  {
        9229  return res;
        9230  }
        9231 
        9232  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
        9233  VmaWriteMagicValue(pData, allocOffset + allocSize);
        9234 
        9235  Unmap(hAllocator, 1);
        9236 
        9237  return VK_SUCCESS;
        9238 }
        9239 
        9240 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
        9241 {
        9242  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
        9243  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
        9244 
        9245  void* pData;
        9246  VkResult res = Map(hAllocator, 1, &pData);
        9247  if(res != VK_SUCCESS)
        9248  {
        9249  return res;
        9250  }
        9251 
        9252  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
        9253  {
        9254  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
        9255  }
        9256  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
        9257  {
        9258  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
        9259  }
        9260 
        9261  Unmap(hAllocator, 1);
        9262 
        9263  return VK_SUCCESS;
        9264 }
        9265 
        9266 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
        9267  const VmaAllocator hAllocator,
        9268  const VmaAllocation hAllocation,
        9269  VkBuffer hBuffer)
        9270 {
        9271  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        9272  hAllocation->GetBlock() == this);
        9273  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        9274  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9275  return hAllocator->GetVulkanFunctions().vkBindBufferMemory(
        9276  hAllocator->m_hDevice,
        9277  hBuffer,
        9278  m_hMemory,
        9279  hAllocation->GetOffset());
        9280 }
        9281 
        9282 VkResult VmaDeviceMemoryBlock::BindImageMemory(
        9283  const VmaAllocator hAllocator,
        9284  const VmaAllocation hAllocation,
        9285  VkImage hImage)
        9286 {
        9287  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
        9288  hAllocation->GetBlock() == this);
        9289  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
        9290  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
        9291  return hAllocator->GetVulkanFunctions().vkBindImageMemory(
        9292  hAllocator->m_hDevice,
        9293  hImage,
        9294  m_hMemory,
        9295  hAllocation->GetOffset());
        9296 }
        9297 
        9298 static void InitStatInfo(VmaStatInfo& outInfo)
        9299 {
        9300  memset(&outInfo, 0, sizeof(outInfo));
        9301  outInfo.allocationSizeMin = UINT64_MAX;
        9302  outInfo.unusedRangeSizeMin = UINT64_MAX;
        9303 }
        9304 
        9305 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
        9306 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
        9307 {
        9308  inoutInfo.blockCount += srcInfo.blockCount;
        9309  inoutInfo.allocationCount += srcInfo.allocationCount;
        9310  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
        9311  inoutInfo.usedBytes += srcInfo.usedBytes;
        9312  inoutInfo.unusedBytes += srcInfo.unusedBytes;
        9313  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
        9314  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
        9315  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
        9316  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
        9317 }
        9318 
        9319 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
        9320 {
        9321  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
        9322  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
        9323  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
        9324  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
        9325 }
        9326 
        9327 VmaPool_T::VmaPool_T(
        9328  VmaAllocator hAllocator,
        9329  const VmaPoolCreateInfo& createInfo,
        9330  VkDeviceSize preferredBlockSize) :
        9331  m_BlockVector(
        9332  hAllocator,
        9333  createInfo.memoryTypeIndex,
        9334  createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
        9335  createInfo.minBlockCount,
        9336  createInfo.maxBlockCount,
        9337  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
        9338  createInfo.frameInUseCount,
        9339  true, // isCustomPool
        9340  createInfo.blockSize != 0, // explicitBlockSize
        9341  (createInfo.flags & VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) != 0), // linearAlgorithm
        9342  m_Id(0)
        9343 {
        9344 }
        9345 
        9346 VmaPool_T::~VmaPool_T()
        9347 {
        9348 }
        9349 
        9350 #if VMA_STATS_STRING_ENABLED
        9351 
        9352 #endif // #if VMA_STATS_STRING_ENABLED
        9353 
        9354 VmaBlockVector::VmaBlockVector(
        9355  VmaAllocator hAllocator,
        9356  uint32_t memoryTypeIndex,
        9357  VkDeviceSize preferredBlockSize,
        9358  size_t minBlockCount,
        9359  size_t maxBlockCount,
        9360  VkDeviceSize bufferImageGranularity,
        9361  uint32_t frameInUseCount,
        9362  bool isCustomPool,
        9363  bool explicitBlockSize,
        9364  bool linearAlgorithm) :
        9365  m_hAllocator(hAllocator),
        9366  m_MemoryTypeIndex(memoryTypeIndex),
        9367  m_PreferredBlockSize(preferredBlockSize),
        9368  m_MinBlockCount(minBlockCount),
        9369  m_MaxBlockCount(maxBlockCount),
        9370  m_BufferImageGranularity(bufferImageGranularity),
        9371  m_FrameInUseCount(frameInUseCount),
        9372  m_IsCustomPool(isCustomPool),
        9373  m_ExplicitBlockSize(explicitBlockSize),
        9374  m_LinearAlgorithm(linearAlgorithm),
        9375  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
        9376  m_HasEmptyBlock(false),
        9377  m_pDefragmentator(VMA_NULL),
        9378  m_NextBlockId(0)
        9379 {
        9380 }
        9381 
        9382 VmaBlockVector::~VmaBlockVector()
        9383 {
        9384  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
        9385 
        9386  for(size_t i = m_Blocks.size(); i--; )
        9387  {
        9388  m_Blocks[i]->Destroy(m_hAllocator);
        9389  vma_delete(m_hAllocator, m_Blocks[i]);
        9390  }
        9391 }
        9392 
        9393 VkResult VmaBlockVector::CreateMinBlocks()
        9394 {
        9395  for(size_t i = 0; i < m_MinBlockCount; ++i)
        9396  {
        9397  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
        9398  if(res != VK_SUCCESS)
        9399  {
        9400  return res;
        9401  }
        9402  }
        9403  return VK_SUCCESS;
        9404 }
        9405 
        9406 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
        9407 {
        9408  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9409 
        9410  const size_t blockCount = m_Blocks.size();
        9411 
        9412  pStats->size = 0;
        9413  pStats->unusedSize = 0;
        9414  pStats->allocationCount = 0;
        9415  pStats->unusedRangeCount = 0;
        9416  pStats->unusedRangeSizeMax = 0;
        9417  pStats->blockCount = blockCount;
        9418 
        9419  for(uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        9420  {
        9421  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        9422  VMA_ASSERT(pBlock);
        9423  VMA_HEAVY_ASSERT(pBlock->Validate());
        9424  pBlock->m_pMetadata->AddPoolStats(*pStats);
        9425  }
        9426 }
        9427 
        9428 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
        9429 {
        9430  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        9431  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
        9432  (VMA_DEBUG_MARGIN > 0) &&
        9433  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
        9434 }
        9435 
        9436 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
        9437 
        9438 VkResult VmaBlockVector::Allocate(
        9439  VmaPool hCurrentPool,
        9440  uint32_t currentFrameIndex,
        9441  VkDeviceSize size,
        9442  VkDeviceSize alignment,
        9443  const VmaAllocationCreateInfo& createInfo,
        9444  VmaSuballocationType suballocType,
        9445  VmaAllocation* pAllocation)
        9446 {
        9447  const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        9448  bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
        9449  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        9450  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        9451  const bool canCreateNewBlock =
        9452  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
        9453  (m_Blocks.size() < m_MaxBlockCount);
        9454 
        9455  // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.
        9456  // Which in turn is available only when maxBlockCount = 1.
        9457  if(m_LinearAlgorithm && m_MaxBlockCount > 1)
        9458  {
        9459  canMakeOtherLost = false;
        9460  }
        9461 
        9462  // Upper address can only be used with linear allocator and within single memory block.
        9463  if(isUpperAddress &&
        9464  (!m_LinearAlgorithm || m_MaxBlockCount > 1))
        9465  {
        9466  return VK_ERROR_FEATURE_NOT_PRESENT;
        9467  }
        9468 
        9469  // Early reject: requested allocation size is larger that maximum block size for this block vector.
        9470  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
        9471  {
        9472  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9473  }
        9474 
        9475  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9476 
        9477  /*
        9478  Under certain condition, this whole section can be skipped for optimization, so
        9479  we move on directly to trying to allocate with canMakeOtherLost. That's the case
        9480  e.g. for custom pools with linear algorithm.
        9481  */
        9482  if(!canMakeOtherLost || canCreateNewBlock)
        9483  {
        9484  // 1. Search existing allocations. Try to allocate without making other allocations lost.
        9485  VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;
        9486  allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
        9487 
        9488  if(m_LinearAlgorithm)
        9489  {
        9490  // Use only last block.
        9491  if(!m_Blocks.empty())
        9492  {
        9493  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
        9494  VMA_ASSERT(pCurrBlock);
        9495  VkResult res = AllocateFromBlock(
        9496  pCurrBlock,
        9497  hCurrentPool,
        9498  currentFrameIndex,
        9499  size,
        9500  alignment,
        9501  allocFlagsCopy,
        9502  createInfo.pUserData,
        9503  suballocType,
        9504  pAllocation);
        9505  if(res == VK_SUCCESS)
        9506  {
        9507  VMA_DEBUG_LOG(" Returned from last block #%u", (uint32_t)(m_Blocks.size() - 1));
        9508  return VK_SUCCESS;
        9509  }
        9510  }
        9511  }
        9512  else
        9513  {
        9514  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        9515  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        9516  {
        9517  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        9518  VMA_ASSERT(pCurrBlock);
        9519  VkResult res = AllocateFromBlock(
        9520  pCurrBlock,
        9521  hCurrentPool,
        9522  currentFrameIndex,
        9523  size,
        9524  alignment,
        9525  allocFlagsCopy,
        9526  createInfo.pUserData,
        9527  suballocType,
        9528  pAllocation);
        9529  if(res == VK_SUCCESS)
        9530  {
        9531  VMA_DEBUG_LOG(" Returned from existing block #%u", (uint32_t)blockIndex);
        9532  return VK_SUCCESS;
        9533  }
        9534  }
        9535  }
        9536 
        9537  // 2. Try to create new block.
        9538  if(canCreateNewBlock)
        9539  {
        9540  // Calculate optimal size for new block.
        9541  VkDeviceSize newBlockSize = m_PreferredBlockSize;
        9542  uint32_t newBlockSizeShift = 0;
        9543  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
        9544 
        9545  if(!m_ExplicitBlockSize)
        9546  {
        9547  // Allocate 1/8, 1/4, 1/2 as first blocks.
        9548  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
        9549  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
        9550  {
        9551  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        9552  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
        9553  {
        9554  newBlockSize = smallerNewBlockSize;
        9555  ++newBlockSizeShift;
        9556  }
        9557  else
        9558  {
        9559  break;
        9560  }
        9561  }
        9562  }
        9563 
        9564  size_t newBlockIndex = 0;
        9565  VkResult res = CreateBlock(newBlockSize, &newBlockIndex);
        9566  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
        9567  if(!m_ExplicitBlockSize)
        9568  {
        9569  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
        9570  {
        9571  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
        9572  if(smallerNewBlockSize >= size)
        9573  {
        9574  newBlockSize = smallerNewBlockSize;
        9575  ++newBlockSizeShift;
        9576  res = CreateBlock(newBlockSize, &newBlockIndex);
        9577  }
        9578  else
        9579  {
        9580  break;
        9581  }
        9582  }
        9583  }
        9584 
        9585  if(res == VK_SUCCESS)
        9586  {
        9587  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
        9588  VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
        9589 
        9590  res = AllocateFromBlock(
        9591  pBlock,
        9592  hCurrentPool,
        9593  currentFrameIndex,
        9594  size,
        9595  alignment,
        9596  allocFlagsCopy,
        9597  createInfo.pUserData,
        9598  suballocType,
        9599  pAllocation);
        9600  if(res == VK_SUCCESS)
        9601  {
        9602  VMA_DEBUG_LOG(" Created new block Size=%llu", newBlockSize);
        9603  return VK_SUCCESS;
        9604  }
        9605  else
        9606  {
        9607  // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
        9608  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9609  }
        9610  }
        9611  }
        9612  }
        9613 
        9614  // 3. Try to allocate from existing blocks with making other allocations lost.
        9615  if(canMakeOtherLost)
        9616  {
        9617  uint32_t tryIndex = 0;
        9618  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
        9619  {
        9620  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
        9621  VmaAllocationRequest bestRequest = {};
        9622  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
        9623 
        9624  // 1. Search existing allocations.
        9625  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
        9626  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
        9627  {
        9628  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
        9629  VMA_ASSERT(pCurrBlock);
        9630  VmaAllocationRequest currRequest = {};
        9631  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
        9632  currentFrameIndex,
        9633  m_FrameInUseCount,
        9634  m_BufferImageGranularity,
        9635  size,
        9636  alignment,
        9637  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
        9638  suballocType,
        9639  canMakeOtherLost,
        9640  &currRequest))
        9641  {
        9642  const VkDeviceSize currRequestCost = currRequest.CalcCost();
        9643  if(pBestRequestBlock == VMA_NULL ||
        9644  currRequestCost < bestRequestCost)
        9645  {
        9646  pBestRequestBlock = pCurrBlock;
        9647  bestRequest = currRequest;
        9648  bestRequestCost = currRequestCost;
        9649 
        9650  if(bestRequestCost == 0)
        9651  {
        9652  break;
        9653  }
        9654  }
        9655  }
        9656  }
        9657 
        9658  if(pBestRequestBlock != VMA_NULL)
        9659  {
        9660  if(mapped)
        9661  {
        9662  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
        9663  if(res != VK_SUCCESS)
        9664  {
        9665  return res;
        9666  }
        9667  }
        9668 
        9669  if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
        9670  currentFrameIndex,
        9671  m_FrameInUseCount,
        9672  &bestRequest))
        9673  {
        9674  // We no longer have an empty Allocation.
        9675  if(pBestRequestBlock->m_pMetadata->IsEmpty())
        9676  {
        9677  m_HasEmptyBlock = false;
        9678  }
        9679  // Allocate from this pBlock.
        9680  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
        9681  pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, isUpperAddress, *pAllocation);
        9682  (*pAllocation)->InitBlockAllocation(
        9683  hCurrentPool,
        9684  pBestRequestBlock,
        9685  bestRequest.offset,
        9686  alignment,
        9687  size,
        9688  suballocType,
        9689  mapped,
        9690  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        9691  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
        9692  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
        9693  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
        9694  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        9695  {
        9696  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        9697  }
        9698  if(IsCorruptionDetectionEnabled())
        9699  {
        9700  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
        9701  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        9702  }
        9703  return VK_SUCCESS;
        9704  }
        9705  // else: Some allocations must have been touched while we are here. Next try.
        9706  }
        9707  else
        9708  {
        9709  // Could not find place in any of the blocks - break outer loop.
        9710  break;
        9711  }
        9712  }
        9713  /* Maximum number of tries exceeded - a very unlike event when many other
        9714  threads are simultaneously touching allocations making it impossible to make
        9715  lost at the same time as we try to allocate. */
        9716  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
        9717  {
        9718  return VK_ERROR_TOO_MANY_OBJECTS;
        9719  }
        9720  }
        9721 
        9722  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9723 }
        9724 
        9725 void VmaBlockVector::Free(
        9726  VmaAllocation hAllocation)
        9727 {
        9728  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
        9729 
        9730  // Scope for lock.
        9731  {
        9732  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9733 
        9734  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        9735 
        9736  if(IsCorruptionDetectionEnabled())
        9737  {
        9738  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
        9739  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
        9740  }
        9741 
        9742  if(hAllocation->IsPersistentMap())
        9743  {
        9744  pBlock->Unmap(m_hAllocator, 1);
        9745  }
        9746 
        9747  pBlock->m_pMetadata->Free(hAllocation);
        9748  VMA_HEAVY_ASSERT(pBlock->Validate());
        9749 
        9750  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
        9751 
        9752  // pBlock became empty after this deallocation.
        9753  if(pBlock->m_pMetadata->IsEmpty())
        9754  {
        9755  // Already has empty Allocation. We don't want to have two, so delete this one.
        9756  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
        9757  {
        9758  pBlockToDelete = pBlock;
        9759  Remove(pBlock);
        9760  }
        9761  // We now have first empty block.
        9762  else
        9763  {
        9764  m_HasEmptyBlock = true;
        9765  }
        9766  }
        9767  // pBlock didn't become empty, but we have another empty block - find and free that one.
        9768  // (This is optional, heuristics.)
        9769  else if(m_HasEmptyBlock)
        9770  {
        9771  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
        9772  if(pLastBlock->m_pMetadata->IsEmpty() && m_Blocks.size() > m_MinBlockCount)
        9773  {
        9774  pBlockToDelete = pLastBlock;
        9775  m_Blocks.pop_back();
        9776  m_HasEmptyBlock = false;
        9777  }
        9778  }
        9779 
        9780  IncrementallySortBlocks();
        9781  }
        9782 
        9783  // Destruction of a free Allocation. Deferred until this point, outside of mutex
        9784  // lock, for performance reason.
        9785  if(pBlockToDelete != VMA_NULL)
        9786  {
        9787  VMA_DEBUG_LOG(" Deleted empty allocation");
        9788  pBlockToDelete->Destroy(m_hAllocator);
        9789  vma_delete(m_hAllocator, pBlockToDelete);
        9790  }
        9791 }
        9792 
        9793 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
        9794 {
        9795  VkDeviceSize result = 0;
        9796  for(size_t i = m_Blocks.size(); i--; )
        9797  {
        9798  result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
        9799  if(result >= m_PreferredBlockSize)
        9800  {
        9801  break;
        9802  }
        9803  }
        9804  return result;
        9805 }
        9806 
        9807 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
        9808 {
        9809  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        9810  {
        9811  if(m_Blocks[blockIndex] == pBlock)
        9812  {
        9813  VmaVectorRemove(m_Blocks, blockIndex);
        9814  return;
        9815  }
        9816  }
        9817  VMA_ASSERT(0);
        9818 }
        9819 
        9820 void VmaBlockVector::IncrementallySortBlocks()
        9821 {
        9822  if(!m_LinearAlgorithm)
        9823  {
        9824  // Bubble sort only until first swap.
        9825  for(size_t i = 1; i < m_Blocks.size(); ++i)
        9826  {
        9827  if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
        9828  {
        9829  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
        9830  return;
        9831  }
        9832  }
        9833  }
        9834 }
        9835 
        9836 VkResult VmaBlockVector::AllocateFromBlock(
        9837  VmaDeviceMemoryBlock* pBlock,
        9838  VmaPool hCurrentPool,
        9839  uint32_t currentFrameIndex,
        9840  VkDeviceSize size,
        9841  VkDeviceSize alignment,
        9842  VmaAllocationCreateFlags allocFlags,
        9843  void* pUserData,
        9844  VmaSuballocationType suballocType,
        9845  VmaAllocation* pAllocation)
        9846 {
        9847  VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);
        9848  const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
        9849  const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        9850  const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
        9851 
        9852  VmaAllocationRequest currRequest = {};
        9853  if(pBlock->m_pMetadata->CreateAllocationRequest(
        9854  currentFrameIndex,
        9855  m_FrameInUseCount,
        9856  m_BufferImageGranularity,
        9857  size,
        9858  alignment,
        9859  isUpperAddress,
        9860  suballocType,
        9861  false, // canMakeOtherLost
        9862  &currRequest))
        9863  {
        9864  // Allocate from pCurrBlock.
        9865  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
        9866 
        9867  if(mapped)
        9868  {
        9869  VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
        9870  if(res != VK_SUCCESS)
        9871  {
        9872  return res;
        9873  }
        9874  }
        9875 
        9876  // We no longer have an empty Allocation.
        9877  if(pBlock->m_pMetadata->IsEmpty())
        9878  {
        9879  m_HasEmptyBlock = false;
        9880  }
        9881 
        9882  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
        9883  pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, isUpperAddress, *pAllocation);
        9884  (*pAllocation)->InitBlockAllocation(
        9885  hCurrentPool,
        9886  pBlock,
        9887  currRequest.offset,
        9888  alignment,
        9889  size,
        9890  suballocType,
        9891  mapped,
        9892  (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
        9893  VMA_HEAVY_ASSERT(pBlock->Validate());
        9894  (*pAllocation)->SetUserData(m_hAllocator, pUserData);
        9895  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        9896  {
        9897  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        9898  }
        9899  if(IsCorruptionDetectionEnabled())
        9900  {
        9901  VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
        9902  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
        9903  }
        9904  return VK_SUCCESS;
        9905  }
        9906  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        9907 }
        9908 
        9909 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
        9910 {
        9911  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        9912  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
        9913  allocInfo.allocationSize = blockSize;
        9914  VkDeviceMemory mem = VK_NULL_HANDLE;
        9915  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
        9916  if(res < 0)
        9917  {
        9918  return res;
        9919  }
        9920 
        9921  // New VkDeviceMemory successfully created.
        9922 
        9923  // Create new Allocation for it.
        9924  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
        9925  pBlock->Init(
        9926  m_hAllocator,
        9927  m_MemoryTypeIndex,
        9928  mem,
        9929  allocInfo.allocationSize,
        9930  m_NextBlockId++,
        9931  m_LinearAlgorithm);
        9932 
        9933  m_Blocks.push_back(pBlock);
        9934  if(pNewBlockIndex != VMA_NULL)
        9935  {
        9936  *pNewBlockIndex = m_Blocks.size() - 1;
        9937  }
        9938 
        9939  return VK_SUCCESS;
        9940 }
        9941 
        9942 #if VMA_STATS_STRING_ENABLED
        9943 
        9944 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
        9945 {
        9946  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        9947 
        9948  json.BeginObject();
        9949 
        9950  if(m_IsCustomPool)
        9951  {
        9952  json.WriteString("MemoryTypeIndex");
        9953  json.WriteNumber(m_MemoryTypeIndex);
        9954 
        9955  json.WriteString("BlockSize");
        9956  json.WriteNumber(m_PreferredBlockSize);
        9957 
        9958  json.WriteString("BlockCount");
        9959  json.BeginObject(true);
        9960  if(m_MinBlockCount > 0)
        9961  {
        9962  json.WriteString("Min");
        9963  json.WriteNumber((uint64_t)m_MinBlockCount);
        9964  }
        9965  if(m_MaxBlockCount < SIZE_MAX)
        9966  {
        9967  json.WriteString("Max");
        9968  json.WriteNumber((uint64_t)m_MaxBlockCount);
        9969  }
        9970  json.WriteString("Cur");
        9971  json.WriteNumber((uint64_t)m_Blocks.size());
        9972  json.EndObject();
        9973 
        9974  if(m_FrameInUseCount > 0)
        9975  {
        9976  json.WriteString("FrameInUseCount");
        9977  json.WriteNumber(m_FrameInUseCount);
        9978  }
        9979 
        9980  if(m_LinearAlgorithm)
        9981  {
        9982  json.WriteString("LinearAlgorithm");
        9983  json.WriteBool(true);
        9984  }
        9985  }
        9986  else
        9987  {
        9988  json.WriteString("PreferredBlockSize");
        9989  json.WriteNumber(m_PreferredBlockSize);
        9990  }
        9991 
        9992  json.WriteString("Blocks");
        9993  json.BeginObject();
        9994  for(size_t i = 0; i < m_Blocks.size(); ++i)
        9995  {
        9996  json.BeginString();
        9997  json.ContinueString(m_Blocks[i]->GetId());
        9998  json.EndString();
        9999 
        10000  m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
        10001  }
        10002  json.EndObject();
        10003 
        10004  json.EndObject();
        10005 }
        10006 
        10007 #endif // #if VMA_STATS_STRING_ENABLED
        10008 
        10009 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
        10010  VmaAllocator hAllocator,
        10011  uint32_t currentFrameIndex)
        10012 {
        10013  if(m_pDefragmentator == VMA_NULL)
        10014  {
        10015  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
        10016  hAllocator,
        10017  this,
        10018  currentFrameIndex);
        10019  }
        10020 
        10021  return m_pDefragmentator;
        10022 }
        10023 
        10024 VkResult VmaBlockVector::Defragment(
        10025  VmaDefragmentationStats* pDefragmentationStats,
        10026  VkDeviceSize& maxBytesToMove,
        10027  uint32_t& maxAllocationsToMove)
        10028 {
        10029  if(m_pDefragmentator == VMA_NULL)
        10030  {
        10031  return VK_SUCCESS;
        10032  }
        10033 
        10034  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10035 
        10036  // Defragment.
        10037  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
        10038 
        10039  // Accumulate statistics.
        10040  if(pDefragmentationStats != VMA_NULL)
        10041  {
        10042  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
        10043  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
        10044  pDefragmentationStats->bytesMoved += bytesMoved;
        10045  pDefragmentationStats->allocationsMoved += allocationsMoved;
        10046  VMA_ASSERT(bytesMoved <= maxBytesToMove);
        10047  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
        10048  maxBytesToMove -= bytesMoved;
        10049  maxAllocationsToMove -= allocationsMoved;
        10050  }
        10051 
        10052  // Free empty blocks.
        10053  m_HasEmptyBlock = false;
        10054  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
        10055  {
        10056  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
        10057  if(pBlock->m_pMetadata->IsEmpty())
        10058  {
        10059  if(m_Blocks.size() > m_MinBlockCount)
        10060  {
        10061  if(pDefragmentationStats != VMA_NULL)
        10062  {
        10063  ++pDefragmentationStats->deviceMemoryBlocksFreed;
        10064  pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
        10065  }
        10066 
        10067  VmaVectorRemove(m_Blocks, blockIndex);
        10068  pBlock->Destroy(m_hAllocator);
        10069  vma_delete(m_hAllocator, pBlock);
        10070  }
        10071  else
        10072  {
        10073  m_HasEmptyBlock = true;
        10074  }
        10075  }
        10076  }
        10077 
        10078  return result;
        10079 }
        10080 
        10081 void VmaBlockVector::DestroyDefragmentator()
        10082 {
        10083  if(m_pDefragmentator != VMA_NULL)
        10084  {
        10085  vma_delete(m_hAllocator, m_pDefragmentator);
        10086  m_pDefragmentator = VMA_NULL;
        10087  }
        10088 }
        10089 
        10090 void VmaBlockVector::MakePoolAllocationsLost(
        10091  uint32_t currentFrameIndex,
        10092  size_t* pLostAllocationCount)
        10093 {
        10094  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10095  size_t lostAllocationCount = 0;
        10096  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        10097  {
        10098  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        10099  VMA_ASSERT(pBlock);
        10100  lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
        10101  }
        10102  if(pLostAllocationCount != VMA_NULL)
        10103  {
        10104  *pLostAllocationCount = lostAllocationCount;
        10105  }
        10106 }
        10107 
        10108 VkResult VmaBlockVector::CheckCorruption()
        10109 {
        10110  if(!IsCorruptionDetectionEnabled())
        10111  {
        10112  return VK_ERROR_FEATURE_NOT_PRESENT;
        10113  }
        10114 
        10115  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10116  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        10117  {
        10118  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        10119  VMA_ASSERT(pBlock);
        10120  VkResult res = pBlock->CheckCorruption(m_hAllocator);
        10121  if(res != VK_SUCCESS)
        10122  {
        10123  return res;
        10124  }
        10125  }
        10126  return VK_SUCCESS;
        10127 }
        10128 
        10129 void VmaBlockVector::AddStats(VmaStats* pStats)
        10130 {
        10131  const uint32_t memTypeIndex = m_MemoryTypeIndex;
        10132  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
        10133 
        10134  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
        10135 
        10136  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
        10137  {
        10138  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
        10139  VMA_ASSERT(pBlock);
        10140  VMA_HEAVY_ASSERT(pBlock->Validate());
        10141  VmaStatInfo allocationStatInfo;
        10142  pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
        10143  VmaAddStatInfo(pStats->total, allocationStatInfo);
        10144  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        10145  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        10146  }
        10147 }
        10148 
        10150 // VmaDefragmentator members definition
        10151 
        10152 VmaDefragmentator::VmaDefragmentator(
        10153  VmaAllocator hAllocator,
        10154  VmaBlockVector* pBlockVector,
        10155  uint32_t currentFrameIndex) :
        10156  m_hAllocator(hAllocator),
        10157  m_pBlockVector(pBlockVector),
        10158  m_CurrentFrameIndex(currentFrameIndex),
        10159  m_BytesMoved(0),
        10160  m_AllocationsMoved(0),
        10161  m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),
        10162  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
        10163 {
        10164  VMA_ASSERT(!pBlockVector->UsesLinearAlgorithm());
        10165 }
        10166 
        10167 VmaDefragmentator::~VmaDefragmentator()
        10168 {
        10169  for(size_t i = m_Blocks.size(); i--; )
        10170  {
        10171  vma_delete(m_hAllocator, m_Blocks[i]);
        10172  }
        10173 }
        10174 
        10175 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
        10176 {
        10177  AllocationInfo allocInfo;
        10178  allocInfo.m_hAllocation = hAlloc;
        10179  allocInfo.m_pChanged = pChanged;
        10180  m_Allocations.push_back(allocInfo);
        10181 }
        10182 
        10183 VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)
        10184 {
        10185  // It has already been mapped for defragmentation.
        10186  if(m_pMappedDataForDefragmentation)
        10187  {
        10188  *ppMappedData = m_pMappedDataForDefragmentation;
        10189  return VK_SUCCESS;
        10190  }
        10191 
        10192  // It is originally mapped.
        10193  if(m_pBlock->GetMappedData())
        10194  {
        10195  *ppMappedData = m_pBlock->GetMappedData();
        10196  return VK_SUCCESS;
        10197  }
        10198 
        10199  // Map on first usage.
        10200  VkResult res = m_pBlock->Map(hAllocator, 1, &m_pMappedDataForDefragmentation);
        10201  *ppMappedData = m_pMappedDataForDefragmentation;
        10202  return res;
        10203 }
        10204 
        10205 void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)
        10206 {
        10207  if(m_pMappedDataForDefragmentation != VMA_NULL)
        10208  {
        10209  m_pBlock->Unmap(hAllocator, 1);
        10210  }
        10211 }
        10212 
        10213 VkResult VmaDefragmentator::DefragmentRound(
        10214  VkDeviceSize maxBytesToMove,
        10215  uint32_t maxAllocationsToMove)
        10216 {
        10217  if(m_Blocks.empty())
        10218  {
        10219  return VK_SUCCESS;
        10220  }
        10221 
        10222  size_t srcBlockIndex = m_Blocks.size() - 1;
        10223  size_t srcAllocIndex = SIZE_MAX;
        10224  for(;;)
        10225  {
        10226  // 1. Find next allocation to move.
        10227  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
        10228  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
        10229  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
        10230  {
        10231  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
        10232  {
        10233  // Finished: no more allocations to process.
        10234  if(srcBlockIndex == 0)
        10235  {
        10236  return VK_SUCCESS;
        10237  }
        10238  else
        10239  {
        10240  --srcBlockIndex;
        10241  srcAllocIndex = SIZE_MAX;
        10242  }
        10243  }
        10244  else
        10245  {
        10246  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
        10247  }
        10248  }
        10249 
        10250  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
        10251  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
        10252 
        10253  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
        10254  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
        10255  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
        10256  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
        10257 
        10258  // 2. Try to find new place for this allocation in preceding or current block.
        10259  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
        10260  {
        10261  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
        10262  VmaAllocationRequest dstAllocRequest;
        10263  if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
        10264  m_CurrentFrameIndex,
        10265  m_pBlockVector->GetFrameInUseCount(),
        10266  m_pBlockVector->GetBufferImageGranularity(),
        10267  size,
        10268  alignment,
        10269  false, // upperAddress
        10270  suballocType,
        10271  false, // canMakeOtherLost
        10272  &dstAllocRequest) &&
        10273  MoveMakesSense(
        10274  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
        10275  {
        10276  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
        10277 
        10278  // Reached limit on number of allocations or bytes to move.
        10279  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
        10280  (m_BytesMoved + size > maxBytesToMove))
        10281  {
        10282  return VK_INCOMPLETE;
        10283  }
        10284 
        10285  void* pDstMappedData = VMA_NULL;
        10286  VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);
        10287  if(res != VK_SUCCESS)
        10288  {
        10289  return res;
        10290  }
        10291 
        10292  void* pSrcMappedData = VMA_NULL;
        10293  res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);
        10294  if(res != VK_SUCCESS)
        10295  {
        10296  return res;
        10297  }
        10298 
        10299  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
        10300  memcpy(
        10301  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
        10302  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
        10303  static_cast<size_t>(size));
        10304 
        10305  if(VMA_DEBUG_MARGIN > 0)
        10306  {
        10307  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset - VMA_DEBUG_MARGIN);
        10308  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset + size);
        10309  }
        10310 
        10311  pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
        10312  dstAllocRequest,
        10313  suballocType,
        10314  size,
        10315  false, // upperAddress
        10316  allocInfo.m_hAllocation);
        10317  pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
        10318 
        10319  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
        10320 
        10321  if(allocInfo.m_pChanged != VMA_NULL)
        10322  {
        10323  *allocInfo.m_pChanged = VK_TRUE;
        10324  }
        10325 
        10326  ++m_AllocationsMoved;
        10327  m_BytesMoved += size;
        10328 
        10329  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
        10330 
        10331  break;
        10332  }
        10333  }
        10334 
        10335  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
        10336 
        10337  if(srcAllocIndex > 0)
        10338  {
        10339  --srcAllocIndex;
        10340  }
        10341  else
        10342  {
        10343  if(srcBlockIndex > 0)
        10344  {
        10345  --srcBlockIndex;
        10346  srcAllocIndex = SIZE_MAX;
        10347  }
        10348  else
        10349  {
        10350  return VK_SUCCESS;
        10351  }
        10352  }
        10353  }
        10354 }
        10355 
        10356 VkResult VmaDefragmentator::Defragment(
        10357  VkDeviceSize maxBytesToMove,
        10358  uint32_t maxAllocationsToMove)
        10359 {
        10360  if(m_Allocations.empty())
        10361  {
        10362  return VK_SUCCESS;
        10363  }
        10364 
        10365  // Create block info for each block.
        10366  const size_t blockCount = m_pBlockVector->m_Blocks.size();
        10367  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        10368  {
        10369  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
        10370  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
        10371  m_Blocks.push_back(pBlockInfo);
        10372  }
        10373 
        10374  // Sort them by m_pBlock pointer value.
        10375  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
        10376 
        10377  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
        10378  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
        10379  {
        10380  AllocationInfo& allocInfo = m_Allocations[blockIndex];
        10381  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
        10382  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        10383  {
        10384  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
        10385  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
        10386  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
        10387  {
        10388  (*it)->m_Allocations.push_back(allocInfo);
        10389  }
        10390  else
        10391  {
        10392  VMA_ASSERT(0);
        10393  }
        10394  }
        10395  }
        10396  m_Allocations.clear();
        10397 
        10398  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        10399  {
        10400  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
        10401  pBlockInfo->CalcHasNonMovableAllocations();
        10402  pBlockInfo->SortAllocationsBySizeDescecnding();
        10403  }
        10404 
        10405  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
        10406  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
        10407 
        10408  // Execute defragmentation rounds (the main part).
        10409  VkResult result = VK_SUCCESS;
        10410  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
        10411  {
        10412  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
        10413  }
        10414 
        10415  // Unmap blocks that were mapped for defragmentation.
        10416  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
        10417  {
        10418  m_Blocks[blockIndex]->Unmap(m_hAllocator);
        10419  }
        10420 
        10421  return result;
        10422 }
        10423 
        10424 bool VmaDefragmentator::MoveMakesSense(
        10425  size_t dstBlockIndex, VkDeviceSize dstOffset,
        10426  size_t srcBlockIndex, VkDeviceSize srcOffset)
        10427 {
        10428  if(dstBlockIndex < srcBlockIndex)
        10429  {
        10430  return true;
        10431  }
        10432  if(dstBlockIndex > srcBlockIndex)
        10433  {
        10434  return false;
        10435  }
        10436  if(dstOffset < srcOffset)
        10437  {
        10438  return true;
        10439  }
        10440  return false;
        10441 }
        10442 
        10444 // VmaRecorder
        10445 
        10446 #if VMA_RECORDING_ENABLED
        10447 
        10448 VmaRecorder::VmaRecorder() :
        10449  m_UseMutex(true),
        10450  m_Flags(0),
        10451  m_File(VMA_NULL),
        10452  m_Freq(INT64_MAX),
        10453  m_StartCounter(INT64_MAX)
        10454 {
        10455 }
        10456 
        10457 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
        10458 {
        10459  m_UseMutex = useMutex;
        10460  m_Flags = settings.flags;
        10461 
        10462  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
        10463  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
        10464 
        10465  // Open file for writing.
        10466  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
        10467  if(err != 0)
        10468  {
        10469  return VK_ERROR_INITIALIZATION_FAILED;
        10470  }
        10471 
        10472  // Write header.
        10473  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
        10474  fprintf(m_File, "%s\n", "1,3");
        10475 
        10476  return VK_SUCCESS;
        10477 }
        10478 
        10479 VmaRecorder::~VmaRecorder()
        10480 {
        10481  if(m_File != VMA_NULL)
        10482  {
        10483  fclose(m_File);
        10484  }
        10485 }
        10486 
        10487 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
        10488 {
        10489  CallParams callParams;
        10490  GetBasicParams(callParams);
        10491 
        10492  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10493  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
        10494  Flush();
        10495 }
        10496 
        10497 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
        10498 {
        10499  CallParams callParams;
        10500  GetBasicParams(callParams);
        10501 
        10502  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10503  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
        10504  Flush();
        10505 }
        10506 
        10507 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
        10508 {
        10509  CallParams callParams;
        10510  GetBasicParams(callParams);
        10511 
        10512  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10513  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
        10514  createInfo.memoryTypeIndex,
        10515  createInfo.flags,
        10516  createInfo.blockSize,
        10517  createInfo.minBlockCount,
        10518  createInfo.maxBlockCount,
        10519  createInfo.frameInUseCount,
        10520  pool);
        10521  Flush();
        10522 }
        10523 
        10524 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
        10525 {
        10526  CallParams callParams;
        10527  GetBasicParams(callParams);
        10528 
        10529  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10530  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
        10531  pool);
        10532  Flush();
        10533 }
        10534 
        10535 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
        10536  const VkMemoryRequirements& vkMemReq,
        10537  const VmaAllocationCreateInfo& createInfo,
        10538  VmaAllocation allocation)
        10539 {
        10540  CallParams callParams;
        10541  GetBasicParams(callParams);
        10542 
        10543  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10544  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        10545  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10546  vkMemReq.size,
        10547  vkMemReq.alignment,
        10548  vkMemReq.memoryTypeBits,
        10549  createInfo.flags,
        10550  createInfo.usage,
        10551  createInfo.requiredFlags,
        10552  createInfo.preferredFlags,
        10553  createInfo.memoryTypeBits,
        10554  createInfo.pool,
        10555  allocation,
        10556  userDataStr.GetString());
        10557  Flush();
        10558 }
        10559 
        10560 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
        10561  const VkMemoryRequirements& vkMemReq,
        10562  bool requiresDedicatedAllocation,
        10563  bool prefersDedicatedAllocation,
        10564  const VmaAllocationCreateInfo& createInfo,
        10565  VmaAllocation allocation)
        10566 {
        10567  CallParams callParams;
        10568  GetBasicParams(callParams);
        10569 
        10570  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10571  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        10572  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForBuffer,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10573  vkMemReq.size,
        10574  vkMemReq.alignment,
        10575  vkMemReq.memoryTypeBits,
        10576  requiresDedicatedAllocation ? 1 : 0,
        10577  prefersDedicatedAllocation ? 1 : 0,
        10578  createInfo.flags,
        10579  createInfo.usage,
        10580  createInfo.requiredFlags,
        10581  createInfo.preferredFlags,
        10582  createInfo.memoryTypeBits,
        10583  createInfo.pool,
        10584  allocation,
        10585  userDataStr.GetString());
        10586  Flush();
        10587 }
        10588 
        10589 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
        10590  const VkMemoryRequirements& vkMemReq,
        10591  bool requiresDedicatedAllocation,
        10592  bool prefersDedicatedAllocation,
        10593  const VmaAllocationCreateInfo& createInfo,
        10594  VmaAllocation allocation)
        10595 {
        10596  CallParams callParams;
        10597  GetBasicParams(callParams);
        10598 
        10599  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10600  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
        10601  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryForImage,%llu,%llu,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10602  vkMemReq.size,
        10603  vkMemReq.alignment,
        10604  vkMemReq.memoryTypeBits,
        10605  requiresDedicatedAllocation ? 1 : 0,
        10606  prefersDedicatedAllocation ? 1 : 0,
        10607  createInfo.flags,
        10608  createInfo.usage,
        10609  createInfo.requiredFlags,
        10610  createInfo.preferredFlags,
        10611  createInfo.memoryTypeBits,
        10612  createInfo.pool,
        10613  allocation,
        10614  userDataStr.GetString());
        10615  Flush();
        10616 }
        10617 
        10618 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
        10619  VmaAllocation allocation)
        10620 {
        10621  CallParams callParams;
        10622  GetBasicParams(callParams);
        10623 
        10624  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10625  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        10626  allocation);
        10627  Flush();
        10628 }
        10629 
        10630 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
        10631  VmaAllocation allocation,
        10632  const void* pUserData)
        10633 {
        10634  CallParams callParams;
        10635  GetBasicParams(callParams);
        10636 
        10637  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10638  UserDataString userDataStr(
        10639  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
        10640  pUserData);
        10641  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10642  allocation,
        10643  userDataStr.GetString());
        10644  Flush();
        10645 }
        10646 
        10647 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
        10648  VmaAllocation allocation)
        10649 {
        10650  CallParams callParams;
        10651  GetBasicParams(callParams);
        10652 
        10653  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10654  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        10655  allocation);
        10656  Flush();
        10657 }
        10658 
        10659 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
        10660  VmaAllocation allocation)
        10661 {
        10662  CallParams callParams;
        10663  GetBasicParams(callParams);
        10664 
        10665  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10666  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        10667  allocation);
        10668  Flush();
        10669 }
        10670 
        10671 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
        10672  VmaAllocation allocation)
        10673 {
        10674  CallParams callParams;
        10675  GetBasicParams(callParams);
        10676 
        10677  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10678  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
        10679  allocation);
        10680  Flush();
        10681 }
        10682 
        10683 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
        10684  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        10685 {
        10686  CallParams callParams;
        10687  GetBasicParams(callParams);
        10688 
        10689  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10690  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        10691  allocation,
        10692  offset,
        10693  size);
        10694  Flush();
        10695 }
        10696 
        10697 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
        10698  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        10699 {
        10700  CallParams callParams;
        10701  GetBasicParams(callParams);
        10702 
        10703  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10704  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
        10705  allocation,
        10706  offset,
        10707  size);
        10708  Flush();
        10709 }
        10710 
        10711 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
        10712  const VkBufferCreateInfo& bufCreateInfo,
        10713  const VmaAllocationCreateInfo& allocCreateInfo,
        10714  VmaAllocation allocation)
        10715 {
        10716  CallParams callParams;
        10717  GetBasicParams(callParams);
        10718 
        10719  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10720  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        10721  fprintf(m_File, "%u,%.3f,%u,vmaCreateBuffer,%u,%llu,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10722  bufCreateInfo.flags,
        10723  bufCreateInfo.size,
        10724  bufCreateInfo.usage,
        10725  bufCreateInfo.sharingMode,
        10726  allocCreateInfo.flags,
        10727  allocCreateInfo.usage,
        10728  allocCreateInfo.requiredFlags,
        10729  allocCreateInfo.preferredFlags,
        10730  allocCreateInfo.memoryTypeBits,
        10731  allocCreateInfo.pool,
        10732  allocation,
        10733  userDataStr.GetString());
        10734  Flush();
        10735 }
        10736 
        10737 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
        10738  const VkImageCreateInfo& imageCreateInfo,
        10739  const VmaAllocationCreateInfo& allocCreateInfo,
        10740  VmaAllocation allocation)
        10741 {
        10742  CallParams callParams;
        10743  GetBasicParams(callParams);
        10744 
        10745  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10746  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
        10747  fprintf(m_File, "%u,%.3f,%u,vmaCreateImage,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
        10748  imageCreateInfo.flags,
        10749  imageCreateInfo.imageType,
        10750  imageCreateInfo.format,
        10751  imageCreateInfo.extent.width,
        10752  imageCreateInfo.extent.height,
        10753  imageCreateInfo.extent.depth,
        10754  imageCreateInfo.mipLevels,
        10755  imageCreateInfo.arrayLayers,
        10756  imageCreateInfo.samples,
        10757  imageCreateInfo.tiling,
        10758  imageCreateInfo.usage,
        10759  imageCreateInfo.sharingMode,
        10760  imageCreateInfo.initialLayout,
        10761  allocCreateInfo.flags,
        10762  allocCreateInfo.usage,
        10763  allocCreateInfo.requiredFlags,
        10764  allocCreateInfo.preferredFlags,
        10765  allocCreateInfo.memoryTypeBits,
        10766  allocCreateInfo.pool,
        10767  allocation,
        10768  userDataStr.GetString());
        10769  Flush();
        10770 }
        10771 
        10772 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
        10773  VmaAllocation allocation)
        10774 {
        10775  CallParams callParams;
        10776  GetBasicParams(callParams);
        10777 
        10778  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10779  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
        10780  allocation);
        10781  Flush();
        10782 }
        10783 
        10784 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
        10785  VmaAllocation allocation)
        10786 {
        10787  CallParams callParams;
        10788  GetBasicParams(callParams);
        10789 
        10790  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10791  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
        10792  allocation);
        10793  Flush();
        10794 }
        10795 
        10796 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
        10797  VmaAllocation allocation)
        10798 {
        10799  CallParams callParams;
        10800  GetBasicParams(callParams);
        10801 
        10802  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10803  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
        10804  allocation);
        10805  Flush();
        10806 }
        10807 
        10808 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
        10809  VmaAllocation allocation)
        10810 {
        10811  CallParams callParams;
        10812  GetBasicParams(callParams);
        10813 
        10814  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10815  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
        10816  allocation);
        10817  Flush();
        10818 }
        10819 
        10820 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
        10821  VmaPool pool)
        10822 {
        10823  CallParams callParams;
        10824  GetBasicParams(callParams);
        10825 
        10826  VmaMutexLock lock(m_FileMutex, m_UseMutex);
        10827  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
        10828  pool);
        10829  Flush();
        10830 }
        10831 
        10832 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
        10833 {
        10834  if(pUserData != VMA_NULL)
        10835  {
        10836  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
        10837  {
        10838  m_Str = (const char*)pUserData;
        10839  }
        10840  else
        10841  {
        10842  sprintf_s(m_PtrStr, "%p", pUserData);
        10843  m_Str = m_PtrStr;
        10844  }
        10845  }
        10846  else
        10847  {
        10848  m_Str = "";
        10849  }
        10850 }
        10851 
        10852 void VmaRecorder::WriteConfiguration(
        10853  const VkPhysicalDeviceProperties& devProps,
        10854  const VkPhysicalDeviceMemoryProperties& memProps,
        10855  bool dedicatedAllocationExtensionEnabled)
        10856 {
        10857  fprintf(m_File, "Config,Begin\n");
        10858 
        10859  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
        10860  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
        10861  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
        10862  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
        10863  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
        10864  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
        10865 
        10866  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
        10867  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
        10868  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
        10869 
        10870  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
        10871  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
        10872  {
        10873  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
        10874  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
        10875  }
        10876  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
        10877  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
        10878  {
        10879  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
        10880  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
        10881  }
        10882 
        10883  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
        10884 
        10885  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
        10886  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
        10887  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
        10888  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
        10889  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
        10890  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
        10891  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
        10892  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
        10893  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        10894 
        10895  fprintf(m_File, "Config,End\n");
        10896 }
        10897 
        10898 void VmaRecorder::GetBasicParams(CallParams& outParams)
        10899 {
        10900  outParams.threadId = GetCurrentThreadId();
        10901 
        10902  LARGE_INTEGER counter;
        10903  QueryPerformanceCounter(&counter);
        10904  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
        10905 }
        10906 
        10907 void VmaRecorder::Flush()
        10908 {
        10909  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
        10910  {
        10911  fflush(m_File);
        10912  }
        10913 }
        10914 
        10915 #endif // #if VMA_RECORDING_ENABLED
        10916 
        10918 // VmaAllocator_T
        10919 
        10920 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
        10921  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
        10922  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
        10923  m_hDevice(pCreateInfo->device),
        10924  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
        10925  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
        10926  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
        10927  m_PreferredLargeHeapBlockSize(0),
        10928  m_PhysicalDevice(pCreateInfo->physicalDevice),
        10929  m_CurrentFrameIndex(0),
        10930  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
        10931  m_NextPoolId(0)
        10932 #if VMA_RECORDING_ENABLED
        10933  ,m_pRecorder(VMA_NULL)
        10934 #endif
        10935 {
        10936  if(VMA_DEBUG_DETECT_CORRUPTION)
        10937  {
        10938  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
        10939  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
        10940  }
        10941 
        10942  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
        10943 
        10944 #if !(VMA_DEDICATED_ALLOCATION)
        10945  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
        10946  {
        10947  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
        10948  }
        10949 #endif
        10950 
        10951  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
        10952  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
        10953  memset(&m_MemProps, 0, sizeof(m_MemProps));
        10954 
        10955  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
        10956  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
        10957 
        10958  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        10959  {
        10960  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
        10961  }
        10962 
        10963  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
        10964  {
        10965  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
        10966  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
        10967  }
        10968 
        10969  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
        10970 
        10971  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
        10972  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
        10973 
        10974  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
        10975  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
        10976 
        10977  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
        10978  {
        10979  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
        10980  {
        10981  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
        10982  if(limit != VK_WHOLE_SIZE)
        10983  {
        10984  m_HeapSizeLimit[heapIndex] = limit;
        10985  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
        10986  {
        10987  m_MemProps.memoryHeaps[heapIndex].size = limit;
        10988  }
        10989  }
        10990  }
        10991  }
        10992 
        10993  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        10994  {
        10995  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
        10996 
        10997  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
        10998  this,
        10999  memTypeIndex,
        11000  preferredBlockSize,
        11001  0,
        11002  SIZE_MAX,
        11003  GetBufferImageGranularity(),
        11004  pCreateInfo->frameInUseCount,
        11005  false, // isCustomPool
        11006  false, // explicitBlockSize
        11007  false); // linearAlgorithm
        11008  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
        11009  // becase minBlockCount is 0.
        11010  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
        11011 
        11012  }
        11013 }
        11014 
        11015 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
        11016 {
        11017  VkResult res = VK_SUCCESS;
        11018 
        11019  if(pCreateInfo->pRecordSettings != VMA_NULL &&
        11020  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
        11021  {
        11022 #if VMA_RECORDING_ENABLED
        11023  m_pRecorder = vma_new(this, VmaRecorder)();
        11024  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
        11025  if(res != VK_SUCCESS)
        11026  {
        11027  return res;
        11028  }
        11029  m_pRecorder->WriteConfiguration(
        11030  m_PhysicalDeviceProperties,
        11031  m_MemProps,
        11032  m_UseKhrDedicatedAllocation);
        11033  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
        11034 #else
        11035  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
        11036  return VK_ERROR_FEATURE_NOT_PRESENT;
        11037 #endif
        11038  }
        11039 
        11040  return res;
        11041 }
        11042 
        11043 VmaAllocator_T::~VmaAllocator_T()
        11044 {
        11045 #if VMA_RECORDING_ENABLED
        11046  if(m_pRecorder != VMA_NULL)
        11047  {
        11048  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
        11049  vma_delete(this, m_pRecorder);
        11050  }
        11051 #endif
        11052 
        11053  VMA_ASSERT(m_Pools.empty());
        11054 
        11055  for(size_t i = GetMemoryTypeCount(); i--; )
        11056  {
        11057  vma_delete(this, m_pDedicatedAllocations[i]);
        11058  vma_delete(this, m_pBlockVectors[i]);
        11059  }
        11060 }
        11061 
        11062 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
        11063 {
        11064 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        11065  m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;
        11066  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;
        11067  m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
        11068  m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;
        11069  m_VulkanFunctions.vkMapMemory = &vkMapMemory;
        11070  m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;
        11071  m_VulkanFunctions.vkFlushMappedMemoryRanges = &vkFlushMappedMemoryRanges;
        11072  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = &vkInvalidateMappedMemoryRanges;
        11073  m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;
        11074  m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;
        11075  m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;
        11076  m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;
        11077  m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;
        11078  m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;
        11079  m_VulkanFunctions.vkCreateImage = &vkCreateImage;
        11080  m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;
        11081 #if VMA_DEDICATED_ALLOCATION
        11082  if(m_UseKhrDedicatedAllocation)
        11083  {
        11084  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
        11085  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
        11086  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
        11087  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
        11088  }
        11089 #endif // #if VMA_DEDICATED_ALLOCATION
        11090 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
        11091 
        11092 #define VMA_COPY_IF_NOT_NULL(funcName) \
        11093  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
        11094 
        11095  if(pVulkanFunctions != VMA_NULL)
        11096  {
        11097  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
        11098  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
        11099  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
        11100  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
        11101  VMA_COPY_IF_NOT_NULL(vkMapMemory);
        11102  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
        11103  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
        11104  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
        11105  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
        11106  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
        11107  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
        11108  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
        11109  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
        11110  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
        11111  VMA_COPY_IF_NOT_NULL(vkCreateImage);
        11112  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
        11113 #if VMA_DEDICATED_ALLOCATION
        11114  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
        11115  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
        11116 #endif
        11117  }
        11118 
        11119 #undef VMA_COPY_IF_NOT_NULL
        11120 
        11121  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
        11122  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
        11123  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
        11124  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
        11125  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
        11126  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
        11127  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
        11128  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
        11129  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
        11130  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
        11131  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
        11132  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
        11133  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
        11134  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
        11135  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
        11136  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
        11137  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
        11138  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
        11139 #if VMA_DEDICATED_ALLOCATION
        11140  if(m_UseKhrDedicatedAllocation)
        11141  {
        11142  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
        11143  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
        11144  }
        11145 #endif
        11146 }
        11147 
        11148 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
        11149 {
        11150  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        11151  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
        11152  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
        11153  return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
        11154 }
        11155 
        11156 VkResult VmaAllocator_T::AllocateMemoryOfType(
        11157  VkDeviceSize size,
        11158  VkDeviceSize alignment,
        11159  bool dedicatedAllocation,
        11160  VkBuffer dedicatedBuffer,
        11161  VkImage dedicatedImage,
        11162  const VmaAllocationCreateInfo& createInfo,
        11163  uint32_t memTypeIndex,
        11164  VmaSuballocationType suballocType,
        11165  VmaAllocation* pAllocation)
        11166 {
        11167  VMA_ASSERT(pAllocation != VMA_NULL);
        11168  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
        11169 
        11170  VmaAllocationCreateInfo finalCreateInfo = createInfo;
        11171 
        11172  // If memory type is not HOST_VISIBLE, disable MAPPED.
        11173  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        11174  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        11175  {
        11176  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
        11177  }
        11178 
        11179  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
        11180  VMA_ASSERT(blockVector);
        11181 
        11182  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
        11183  bool preferDedicatedMemory =
        11184  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
        11185  dedicatedAllocation ||
        11186  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
        11187  size > preferredBlockSize / 2;
        11188 
        11189  if(preferDedicatedMemory &&
        11190  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
        11191  finalCreateInfo.pool == VK_NULL_HANDLE)
        11192  {
        11193  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
        11194  }
        11195 
        11196  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
        11197  {
        11198  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11199  {
        11200  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11201  }
        11202  else
        11203  {
        11204  return AllocateDedicatedMemory(
        11205  size,
        11206  suballocType,
        11207  memTypeIndex,
        11208  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        11209  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        11210  finalCreateInfo.pUserData,
        11211  dedicatedBuffer,
        11212  dedicatedImage,
        11213  pAllocation);
        11214  }
        11215  }
        11216  else
        11217  {
        11218  VkResult res = blockVector->Allocate(
        11219  VK_NULL_HANDLE, // hCurrentPool
        11220  m_CurrentFrameIndex.load(),
        11221  size,
        11222  alignment,
        11223  finalCreateInfo,
        11224  suballocType,
        11225  pAllocation);
        11226  if(res == VK_SUCCESS)
        11227  {
        11228  return res;
        11229  }
        11230 
        11231  // 5. Try dedicated memory.
        11232  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11233  {
        11234  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11235  }
        11236  else
        11237  {
        11238  res = AllocateDedicatedMemory(
        11239  size,
        11240  suballocType,
        11241  memTypeIndex,
        11242  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
        11243  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
        11244  finalCreateInfo.pUserData,
        11245  dedicatedBuffer,
        11246  dedicatedImage,
        11247  pAllocation);
        11248  if(res == VK_SUCCESS)
        11249  {
        11250  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
        11251  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
        11252  return VK_SUCCESS;
        11253  }
        11254  else
        11255  {
        11256  // Everything failed: Return error code.
        11257  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        11258  return res;
        11259  }
        11260  }
        11261  }
        11262 }
        11263 
        11264 VkResult VmaAllocator_T::AllocateDedicatedMemory(
        11265  VkDeviceSize size,
        11266  VmaSuballocationType suballocType,
        11267  uint32_t memTypeIndex,
        11268  bool map,
        11269  bool isUserDataString,
        11270  void* pUserData,
        11271  VkBuffer dedicatedBuffer,
        11272  VkImage dedicatedImage,
        11273  VmaAllocation* pAllocation)
        11274 {
        11275  VMA_ASSERT(pAllocation);
        11276 
        11277  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
        11278  allocInfo.memoryTypeIndex = memTypeIndex;
        11279  allocInfo.allocationSize = size;
        11280 
        11281 #if VMA_DEDICATED_ALLOCATION
        11282  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
        11283  if(m_UseKhrDedicatedAllocation)
        11284  {
        11285  if(dedicatedBuffer != VK_NULL_HANDLE)
        11286  {
        11287  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
        11288  dedicatedAllocInfo.buffer = dedicatedBuffer;
        11289  allocInfo.pNext = &dedicatedAllocInfo;
        11290  }
        11291  else if(dedicatedImage != VK_NULL_HANDLE)
        11292  {
        11293  dedicatedAllocInfo.image = dedicatedImage;
        11294  allocInfo.pNext = &dedicatedAllocInfo;
        11295  }
        11296  }
        11297 #endif // #if VMA_DEDICATED_ALLOCATION
        11298 
        11299  // Allocate VkDeviceMemory.
        11300  VkDeviceMemory hMemory = VK_NULL_HANDLE;
        11301  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
        11302  if(res < 0)
        11303  {
        11304  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
        11305  return res;
        11306  }
        11307 
        11308  void* pMappedData = VMA_NULL;
        11309  if(map)
        11310  {
        11311  res = (*m_VulkanFunctions.vkMapMemory)(
        11312  m_hDevice,
        11313  hMemory,
        11314  0,
        11315  VK_WHOLE_SIZE,
        11316  0,
        11317  &pMappedData);
        11318  if(res < 0)
        11319  {
        11320  VMA_DEBUG_LOG(" vkMapMemory FAILED");
        11321  FreeVulkanMemory(memTypeIndex, size, hMemory);
        11322  return res;
        11323  }
        11324  }
        11325 
        11326  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
        11327  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
        11328  (*pAllocation)->SetUserData(this, pUserData);
        11329  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        11330  {
        11331  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
        11332  }
        11333 
        11334  // Register it in m_pDedicatedAllocations.
        11335  {
        11336  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        11337  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        11338  VMA_ASSERT(pDedicatedAllocations);
        11339  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);
        11340  }
        11341 
        11342  VMA_DEBUG_LOG(" Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
        11343 
        11344  return VK_SUCCESS;
        11345 }
        11346 
        11347 void VmaAllocator_T::GetBufferMemoryRequirements(
        11348  VkBuffer hBuffer,
        11349  VkMemoryRequirements& memReq,
        11350  bool& requiresDedicatedAllocation,
        11351  bool& prefersDedicatedAllocation) const
        11352 {
        11353 #if VMA_DEDICATED_ALLOCATION
        11354  if(m_UseKhrDedicatedAllocation)
        11355  {
        11356  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
        11357  memReqInfo.buffer = hBuffer;
        11358 
        11359  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        11360 
        11361  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        11362  memReq2.pNext = &memDedicatedReq;
        11363 
        11364  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        11365 
        11366  memReq = memReq2.memoryRequirements;
        11367  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        11368  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        11369  }
        11370  else
        11371 #endif // #if VMA_DEDICATED_ALLOCATION
        11372  {
        11373  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
        11374  requiresDedicatedAllocation = false;
        11375  prefersDedicatedAllocation = false;
        11376  }
        11377 }
        11378 
        11379 void VmaAllocator_T::GetImageMemoryRequirements(
        11380  VkImage hImage,
        11381  VkMemoryRequirements& memReq,
        11382  bool& requiresDedicatedAllocation,
        11383  bool& prefersDedicatedAllocation) const
        11384 {
        11385 #if VMA_DEDICATED_ALLOCATION
        11386  if(m_UseKhrDedicatedAllocation)
        11387  {
        11388  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
        11389  memReqInfo.image = hImage;
        11390 
        11391  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
        11392 
        11393  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
        11394  memReq2.pNext = &memDedicatedReq;
        11395 
        11396  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
        11397 
        11398  memReq = memReq2.memoryRequirements;
        11399  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
        11400  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
        11401  }
        11402  else
        11403 #endif // #if VMA_DEDICATED_ALLOCATION
        11404  {
        11405  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
        11406  requiresDedicatedAllocation = false;
        11407  prefersDedicatedAllocation = false;
        11408  }
        11409 }
        11410 
        11411 VkResult VmaAllocator_T::AllocateMemory(
        11412  const VkMemoryRequirements& vkMemReq,
        11413  bool requiresDedicatedAllocation,
        11414  bool prefersDedicatedAllocation,
        11415  VkBuffer dedicatedBuffer,
        11416  VkImage dedicatedImage,
        11417  const VmaAllocationCreateInfo& createInfo,
        11418  VmaSuballocationType suballocType,
        11419  VmaAllocation* pAllocation)
        11420 {
        11421  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
        11422  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11423  {
        11424  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
        11425  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11426  }
        11427  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
        11428  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
        11429  {
        11430  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
        11431  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11432  }
        11433  if(requiresDedicatedAllocation)
        11434  {
        11435  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
        11436  {
        11437  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
        11438  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11439  }
        11440  if(createInfo.pool != VK_NULL_HANDLE)
        11441  {
        11442  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
        11443  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11444  }
        11445  }
        11446  if((createInfo.pool != VK_NULL_HANDLE) &&
        11447  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
        11448  {
        11449  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
        11450  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11451  }
        11452 
        11453  if(createInfo.pool != VK_NULL_HANDLE)
        11454  {
        11455  const VkDeviceSize alignmentForPool = VMA_MAX(
        11456  vkMemReq.alignment,
        11457  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
        11458  return createInfo.pool->m_BlockVector.Allocate(
        11459  createInfo.pool,
        11460  m_CurrentFrameIndex.load(),
        11461  vkMemReq.size,
        11462  alignmentForPool,
        11463  createInfo,
        11464  suballocType,
        11465  pAllocation);
        11466  }
        11467  else
        11468  {
        11469  // Bit mask of memory Vulkan types acceptable for this allocation.
        11470  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
        11471  uint32_t memTypeIndex = UINT32_MAX;
        11472  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        11473  if(res == VK_SUCCESS)
        11474  {
        11475  VkDeviceSize alignmentForMemType = VMA_MAX(
        11476  vkMemReq.alignment,
        11477  GetMemoryTypeMinAlignment(memTypeIndex));
        11478 
        11479  res = AllocateMemoryOfType(
        11480  vkMemReq.size,
        11481  alignmentForMemType,
        11482  requiresDedicatedAllocation || prefersDedicatedAllocation,
        11483  dedicatedBuffer,
        11484  dedicatedImage,
        11485  createInfo,
        11486  memTypeIndex,
        11487  suballocType,
        11488  pAllocation);
        11489  // Succeeded on first try.
        11490  if(res == VK_SUCCESS)
        11491  {
        11492  return res;
        11493  }
        11494  // Allocation from this memory type failed. Try other compatible memory types.
        11495  else
        11496  {
        11497  for(;;)
        11498  {
        11499  // Remove old memTypeIndex from list of possibilities.
        11500  memoryTypeBits &= ~(1u << memTypeIndex);
        11501  // Find alternative memTypeIndex.
        11502  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
        11503  if(res == VK_SUCCESS)
        11504  {
        11505  alignmentForMemType = VMA_MAX(
        11506  vkMemReq.alignment,
        11507  GetMemoryTypeMinAlignment(memTypeIndex));
        11508 
        11509  res = AllocateMemoryOfType(
        11510  vkMemReq.size,
        11511  alignmentForMemType,
        11512  requiresDedicatedAllocation || prefersDedicatedAllocation,
        11513  dedicatedBuffer,
        11514  dedicatedImage,
        11515  createInfo,
        11516  memTypeIndex,
        11517  suballocType,
        11518  pAllocation);
        11519  // Allocation from this alternative memory type succeeded.
        11520  if(res == VK_SUCCESS)
        11521  {
        11522  return res;
        11523  }
        11524  // else: Allocation from this memory type failed. Try next one - next loop iteration.
        11525  }
        11526  // No other matching memory type index could be found.
        11527  else
        11528  {
        11529  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
        11530  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
        11531  }
        11532  }
        11533  }
        11534  }
        11535  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
        11536  else
        11537  return res;
        11538  }
        11539 }
        11540 
        11541 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
        11542 {
        11543  VMA_ASSERT(allocation);
        11544 
        11545  if(allocation->CanBecomeLost() == false ||
        11546  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
        11547  {
        11548  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
        11549  {
        11550  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
        11551  }
        11552 
        11553  switch(allocation->GetType())
        11554  {
        11555  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        11556  {
        11557  VmaBlockVector* pBlockVector = VMA_NULL;
        11558  VmaPool hPool = allocation->GetPool();
        11559  if(hPool != VK_NULL_HANDLE)
        11560  {
        11561  pBlockVector = &hPool->m_BlockVector;
        11562  }
        11563  else
        11564  {
        11565  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        11566  pBlockVector = m_pBlockVectors[memTypeIndex];
        11567  }
        11568  pBlockVector->Free(allocation);
        11569  }
        11570  break;
        11571  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        11572  FreeDedicatedMemory(allocation);
        11573  break;
        11574  default:
        11575  VMA_ASSERT(0);
        11576  }
        11577  }
        11578 
        11579  allocation->SetUserData(this, VMA_NULL);
        11580  vma_delete(this, allocation);
        11581 }
        11582 
        11583 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
        11584 {
        11585  // Initialize.
        11586  InitStatInfo(pStats->total);
        11587  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
        11588  InitStatInfo(pStats->memoryType[i]);
        11589  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
        11590  InitStatInfo(pStats->memoryHeap[i]);
        11591 
        11592  // Process default pools.
        11593  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        11594  {
        11595  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        11596  VMA_ASSERT(pBlockVector);
        11597  pBlockVector->AddStats(pStats);
        11598  }
        11599 
        11600  // Process custom pools.
        11601  {
        11602  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11603  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        11604  {
        11605  m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
        11606  }
        11607  }
        11608 
        11609  // Process dedicated allocations.
        11610  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        11611  {
        11612  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
        11613  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        11614  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        11615  VMA_ASSERT(pDedicatedAllocVector);
        11616  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
        11617  {
        11618  VmaStatInfo allocationStatInfo;
        11619  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
        11620  VmaAddStatInfo(pStats->total, allocationStatInfo);
        11621  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
        11622  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
        11623  }
        11624  }
        11625 
        11626  // Postprocess.
        11627  VmaPostprocessCalcStatInfo(pStats->total);
        11628  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
        11629  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
        11630  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
        11631  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
        11632 }
        11633 
        11634 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
        11635 
        11636 VkResult VmaAllocator_T::Defragment(
        11637  VmaAllocation* pAllocations,
        11638  size_t allocationCount,
        11639  VkBool32* pAllocationsChanged,
        11640  const VmaDefragmentationInfo* pDefragmentationInfo,
        11641  VmaDefragmentationStats* pDefragmentationStats)
        11642 {
        11643  if(pAllocationsChanged != VMA_NULL)
        11644  {
        11645  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
        11646  }
        11647  if(pDefragmentationStats != VMA_NULL)
        11648  {
        11649  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
        11650  }
        11651 
        11652  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
        11653 
        11654  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
        11655 
        11656  const size_t poolCount = m_Pools.size();
        11657 
        11658  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
        11659  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
        11660  {
        11661  VmaAllocation hAlloc = pAllocations[allocIndex];
        11662  VMA_ASSERT(hAlloc);
        11663  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
        11664  // DedicatedAlloc cannot be defragmented.
        11665  const VkMemoryPropertyFlags requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        11666  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
        11667  // Only HOST_VISIBLE and HOST_COHERENT memory types can be defragmented.
        11668  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags) &&
        11669  // Lost allocation cannot be defragmented.
        11670  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
        11671  {
        11672  VmaBlockVector* pAllocBlockVector = VMA_NULL;
        11673 
        11674  const VmaPool hAllocPool = hAlloc->GetPool();
        11675  // This allocation belongs to custom pool.
        11676  if(hAllocPool != VK_NULL_HANDLE)
        11677  {
        11678  // Pools with linear algorithm are not defragmented.
        11679  if(!hAllocPool->m_BlockVector.UsesLinearAlgorithm())
        11680  {
        11681  pAllocBlockVector = &hAllocPool->m_BlockVector;
        11682  }
        11683  }
        11684  // This allocation belongs to general pool.
        11685  else
        11686  {
        11687  pAllocBlockVector = m_pBlockVectors[memTypeIndex];
        11688  }
        11689 
        11690  if(pAllocBlockVector != VMA_NULL)
        11691  {
        11692  VmaDefragmentator* const pDefragmentator =
        11693  pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);
        11694  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
        11695  &pAllocationsChanged[allocIndex] : VMA_NULL;
        11696  pDefragmentator->AddAllocation(hAlloc, pChanged);
        11697  }
        11698  }
        11699  }
        11700 
        11701  VkResult result = VK_SUCCESS;
        11702 
        11703  // ======== Main processing.
        11704 
        11705  VkDeviceSize maxBytesToMove = SIZE_MAX;
        11706  uint32_t maxAllocationsToMove = UINT32_MAX;
        11707  if(pDefragmentationInfo != VMA_NULL)
        11708  {
        11709  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
        11710  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
        11711  }
        11712 
        11713  // Process standard memory.
        11714  for(uint32_t memTypeIndex = 0;
        11715  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
        11716  ++memTypeIndex)
        11717  {
        11718  // Only HOST_VISIBLE memory types can be defragmented.
        11719  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        11720  {
        11721  result = m_pBlockVectors[memTypeIndex]->Defragment(
        11722  pDefragmentationStats,
        11723  maxBytesToMove,
        11724  maxAllocationsToMove);
        11725  }
        11726  }
        11727 
        11728  // Process custom pools.
        11729  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
        11730  {
        11731  result = m_Pools[poolIndex]->m_BlockVector.Defragment(
        11732  pDefragmentationStats,
        11733  maxBytesToMove,
        11734  maxAllocationsToMove);
        11735  }
        11736 
        11737  // ======== Destroy defragmentators.
        11738 
        11739  // Process custom pools.
        11740  for(size_t poolIndex = poolCount; poolIndex--; )
        11741  {
        11742  m_Pools[poolIndex]->m_BlockVector.DestroyDefragmentator();
        11743  }
        11744 
        11745  // Process standard memory.
        11746  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
        11747  {
        11748  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        11749  {
        11750  m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();
        11751  }
        11752  }
        11753 
        11754  return result;
        11755 }
        11756 
        11757 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
        11758 {
        11759  if(hAllocation->CanBecomeLost())
        11760  {
        11761  /*
        11762  Warning: This is a carefully designed algorithm.
        11763  Do not modify unless you really know what you're doing :)
        11764  */
        11765  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11766  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11767  for(;;)
        11768  {
        11769  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        11770  {
        11771  pAllocationInfo->memoryType = UINT32_MAX;
        11772  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
        11773  pAllocationInfo->offset = 0;
        11774  pAllocationInfo->size = hAllocation->GetSize();
        11775  pAllocationInfo->pMappedData = VMA_NULL;
        11776  pAllocationInfo->pUserData = hAllocation->GetUserData();
        11777  return;
        11778  }
        11779  else if(localLastUseFrameIndex == localCurrFrameIndex)
        11780  {
        11781  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        11782  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        11783  pAllocationInfo->offset = hAllocation->GetOffset();
        11784  pAllocationInfo->size = hAllocation->GetSize();
        11785  pAllocationInfo->pMappedData = VMA_NULL;
        11786  pAllocationInfo->pUserData = hAllocation->GetUserData();
        11787  return;
        11788  }
        11789  else // Last use time earlier than current time.
        11790  {
        11791  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11792  {
        11793  localLastUseFrameIndex = localCurrFrameIndex;
        11794  }
        11795  }
        11796  }
        11797  }
        11798  else
        11799  {
        11800 #if VMA_STATS_STRING_ENABLED
        11801  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11802  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11803  for(;;)
        11804  {
        11805  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        11806  if(localLastUseFrameIndex == localCurrFrameIndex)
        11807  {
        11808  break;
        11809  }
        11810  else // Last use time earlier than current time.
        11811  {
        11812  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11813  {
        11814  localLastUseFrameIndex = localCurrFrameIndex;
        11815  }
        11816  }
        11817  }
        11818 #endif
        11819 
        11820  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
        11821  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
        11822  pAllocationInfo->offset = hAllocation->GetOffset();
        11823  pAllocationInfo->size = hAllocation->GetSize();
        11824  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
        11825  pAllocationInfo->pUserData = hAllocation->GetUserData();
        11826  }
        11827 }
        11828 
        11829 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
        11830 {
        11831  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
        11832  if(hAllocation->CanBecomeLost())
        11833  {
        11834  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11835  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11836  for(;;)
        11837  {
        11838  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
        11839  {
        11840  return false;
        11841  }
        11842  else if(localLastUseFrameIndex == localCurrFrameIndex)
        11843  {
        11844  return true;
        11845  }
        11846  else // Last use time earlier than current time.
        11847  {
        11848  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11849  {
        11850  localLastUseFrameIndex = localCurrFrameIndex;
        11851  }
        11852  }
        11853  }
        11854  }
        11855  else
        11856  {
        11857 #if VMA_STATS_STRING_ENABLED
        11858  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
        11859  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
        11860  for(;;)
        11861  {
        11862  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
        11863  if(localLastUseFrameIndex == localCurrFrameIndex)
        11864  {
        11865  break;
        11866  }
        11867  else // Last use time earlier than current time.
        11868  {
        11869  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
        11870  {
        11871  localLastUseFrameIndex = localCurrFrameIndex;
        11872  }
        11873  }
        11874  }
        11875 #endif
        11876 
        11877  return true;
        11878  }
        11879 }
        11880 
        11881 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
        11882 {
        11883  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
        11884 
        11885  const bool isLinearAlgorithm = (pCreateInfo->flags & VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) != 0;
        11886 
        11887  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
        11888 
        11889  if(newCreateInfo.maxBlockCount == 0)
        11890  {
        11891  newCreateInfo.maxBlockCount = SIZE_MAX;
        11892  }
        11893  if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
        11894  {
        11895  return VK_ERROR_INITIALIZATION_FAILED;
        11896  }
        11897 
        11898  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
        11899 
        11900  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
        11901 
        11902  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
        11903  if(res != VK_SUCCESS)
        11904  {
        11905  vma_delete(this, *pPool);
        11906  *pPool = VMA_NULL;
        11907  return res;
        11908  }
        11909 
        11910  // Add to m_Pools.
        11911  {
        11912  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11913  (*pPool)->SetId(m_NextPoolId++);
        11914  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
        11915  }
        11916 
        11917  return VK_SUCCESS;
        11918 }
        11919 
        11920 void VmaAllocator_T::DestroyPool(VmaPool pool)
        11921 {
        11922  // Remove from m_Pools.
        11923  {
        11924  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11925  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
        11926  VMA_ASSERT(success && "Pool not found in Allocator.");
        11927  }
        11928 
        11929  vma_delete(this, pool);
        11930 }
        11931 
        11932 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
        11933 {
        11934  pool->m_BlockVector.GetPoolStats(pPoolStats);
        11935 }
        11936 
        11937 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
        11938 {
        11939  m_CurrentFrameIndex.store(frameIndex);
        11940 }
        11941 
        11942 void VmaAllocator_T::MakePoolAllocationsLost(
        11943  VmaPool hPool,
        11944  size_t* pLostAllocationCount)
        11945 {
        11946  hPool->m_BlockVector.MakePoolAllocationsLost(
        11947  m_CurrentFrameIndex.load(),
        11948  pLostAllocationCount);
        11949 }
        11950 
        11951 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
        11952 {
        11953  return hPool->m_BlockVector.CheckCorruption();
        11954 }
        11955 
        11956 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
        11957 {
        11958  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
        11959 
        11960  // Process default pools.
        11961  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        11962  {
        11963  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
        11964  {
        11965  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
        11966  VMA_ASSERT(pBlockVector);
        11967  VkResult localRes = pBlockVector->CheckCorruption();
        11968  switch(localRes)
        11969  {
        11970  case VK_ERROR_FEATURE_NOT_PRESENT:
        11971  break;
        11972  case VK_SUCCESS:
        11973  finalRes = VK_SUCCESS;
        11974  break;
        11975  default:
        11976  return localRes;
        11977  }
        11978  }
        11979  }
        11980 
        11981  // Process custom pools.
        11982  {
        11983  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        11984  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
        11985  {
        11986  if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
        11987  {
        11988  VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
        11989  switch(localRes)
        11990  {
        11991  case VK_ERROR_FEATURE_NOT_PRESENT:
        11992  break;
        11993  case VK_SUCCESS:
        11994  finalRes = VK_SUCCESS;
        11995  break;
        11996  default:
        11997  return localRes;
        11998  }
        11999  }
        12000  }
        12001  }
        12002 
        12003  return finalRes;
        12004 }
        12005 
        12006 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
        12007 {
        12008  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);
        12009  (*pAllocation)->InitLost();
        12010 }
        12011 
        12012 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
        12013 {
        12014  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
        12015 
        12016  VkResult res;
        12017  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        12018  {
        12019  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
        12020  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
        12021  {
        12022  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        12023  if(res == VK_SUCCESS)
        12024  {
        12025  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
        12026  }
        12027  }
        12028  else
        12029  {
        12030  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
        12031  }
        12032  }
        12033  else
        12034  {
        12035  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
        12036  }
        12037 
        12038  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
        12039  {
        12040  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
        12041  }
        12042 
        12043  return res;
        12044 }
        12045 
        12046 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
        12047 {
        12048  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
        12049  {
        12050  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
        12051  }
        12052 
        12053  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
        12054 
        12055  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
        12056  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
        12057  {
        12058  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
        12059  m_HeapSizeLimit[heapIndex] += size;
        12060  }
        12061 }
        12062 
        12063 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
        12064 {
        12065  if(hAllocation->CanBecomeLost())
        12066  {
        12067  return VK_ERROR_MEMORY_MAP_FAILED;
        12068  }
        12069 
        12070  switch(hAllocation->GetType())
        12071  {
        12072  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12073  {
        12074  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        12075  char *pBytes = VMA_NULL;
        12076  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
        12077  if(res == VK_SUCCESS)
        12078  {
        12079  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
        12080  hAllocation->BlockAllocMap();
        12081  }
        12082  return res;
        12083  }
        12084  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12085  return hAllocation->DedicatedAllocMap(this, ppData);
        12086  default:
        12087  VMA_ASSERT(0);
        12088  return VK_ERROR_MEMORY_MAP_FAILED;
        12089  }
        12090 }
        12091 
        12092 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
        12093 {
        12094  switch(hAllocation->GetType())
        12095  {
        12096  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12097  {
        12098  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
        12099  hAllocation->BlockAllocUnmap();
        12100  pBlock->Unmap(this, 1);
        12101  }
        12102  break;
        12103  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12104  hAllocation->DedicatedAllocUnmap(this);
        12105  break;
        12106  default:
        12107  VMA_ASSERT(0);
        12108  }
        12109 }
        12110 
        12111 VkResult VmaAllocator_T::BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer)
        12112 {
        12113  VkResult res = VK_SUCCESS;
        12114  switch(hAllocation->GetType())
        12115  {
        12116  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12117  res = GetVulkanFunctions().vkBindBufferMemory(
        12118  m_hDevice,
        12119  hBuffer,
        12120  hAllocation->GetMemory(),
        12121  0); //memoryOffset
        12122  break;
        12123  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12124  {
        12125  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        12126  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
        12127  res = pBlock->BindBufferMemory(this, hAllocation, hBuffer);
        12128  break;
        12129  }
        12130  default:
        12131  VMA_ASSERT(0);
        12132  }
        12133  return res;
        12134 }
        12135 
        12136 VkResult VmaAllocator_T::BindImageMemory(VmaAllocation hAllocation, VkImage hImage)
        12137 {
        12138  VkResult res = VK_SUCCESS;
        12139  switch(hAllocation->GetType())
        12140  {
        12141  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12142  res = GetVulkanFunctions().vkBindImageMemory(
        12143  m_hDevice,
        12144  hImage,
        12145  hAllocation->GetMemory(),
        12146  0); //memoryOffset
        12147  break;
        12148  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12149  {
        12150  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
        12151  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
        12152  res = pBlock->BindImageMemory(this, hAllocation, hImage);
        12153  break;
        12154  }
        12155  default:
        12156  VMA_ASSERT(0);
        12157  }
        12158  return res;
        12159 }
        12160 
        12161 void VmaAllocator_T::FlushOrInvalidateAllocation(
        12162  VmaAllocation hAllocation,
        12163  VkDeviceSize offset, VkDeviceSize size,
        12164  VMA_CACHE_OPERATION op)
        12165 {
        12166  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
        12167  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
        12168  {
        12169  const VkDeviceSize allocationSize = hAllocation->GetSize();
        12170  VMA_ASSERT(offset <= allocationSize);
        12171 
        12172  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
        12173 
        12174  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
        12175  memRange.memory = hAllocation->GetMemory();
        12176 
        12177  switch(hAllocation->GetType())
        12178  {
        12179  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
        12180  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        12181  if(size == VK_WHOLE_SIZE)
        12182  {
        12183  memRange.size = allocationSize - memRange.offset;
        12184  }
        12185  else
        12186  {
        12187  VMA_ASSERT(offset + size <= allocationSize);
        12188  memRange.size = VMA_MIN(
        12189  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
        12190  allocationSize - memRange.offset);
        12191  }
        12192  break;
        12193 
        12194  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
        12195  {
        12196  // 1. Still within this allocation.
        12197  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
        12198  if(size == VK_WHOLE_SIZE)
        12199  {
        12200  size = allocationSize - offset;
        12201  }
        12202  else
        12203  {
        12204  VMA_ASSERT(offset + size <= allocationSize);
        12205  }
        12206  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
        12207 
        12208  // 2. Adjust to whole block.
        12209  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
        12210  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
        12211  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
        12212  memRange.offset += allocationOffset;
        12213  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
        12214 
        12215  break;
        12216  }
        12217 
        12218  default:
        12219  VMA_ASSERT(0);
        12220  }
        12221 
        12222  switch(op)
        12223  {
        12224  case VMA_CACHE_FLUSH:
        12225  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
        12226  break;
        12227  case VMA_CACHE_INVALIDATE:
        12228  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
        12229  break;
        12230  default:
        12231  VMA_ASSERT(0);
        12232  }
        12233  }
        12234  // else: Just ignore this call.
        12235 }
        12236 
        12237 void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
        12238 {
        12239  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
        12240 
        12241  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
        12242  {
        12243  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        12244  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
        12245  VMA_ASSERT(pDedicatedAllocations);
        12246  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
        12247  VMA_ASSERT(success);
        12248  }
        12249 
        12250  VkDeviceMemory hMemory = allocation->GetMemory();
        12251 
        12252  if(allocation->GetMappedData() != VMA_NULL)
        12253  {
        12254  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
        12255  }
        12256 
        12257  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
        12258 
        12259  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
        12260 }
        12261 
        12262 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
        12263 {
        12264  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
        12265  !hAllocation->CanBecomeLost() &&
        12266  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        12267  {
        12268  void* pData = VMA_NULL;
        12269  VkResult res = Map(hAllocation, &pData);
        12270  if(res == VK_SUCCESS)
        12271  {
        12272  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
        12273  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
        12274  Unmap(hAllocation);
        12275  }
        12276  else
        12277  {
        12278  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
        12279  }
        12280  }
        12281 }
        12282 
        12283 #if VMA_STATS_STRING_ENABLED
        12284 
        12285 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
        12286 {
        12287  bool dedicatedAllocationsStarted = false;
        12288  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        12289  {
        12290  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
        12291  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
        12292  VMA_ASSERT(pDedicatedAllocVector);
        12293  if(pDedicatedAllocVector->empty() == false)
        12294  {
        12295  if(dedicatedAllocationsStarted == false)
        12296  {
        12297  dedicatedAllocationsStarted = true;
        12298  json.WriteString("DedicatedAllocations");
        12299  json.BeginObject();
        12300  }
        12301 
        12302  json.BeginString("Type ");
        12303  json.ContinueString(memTypeIndex);
        12304  json.EndString();
        12305 
        12306  json.BeginArray();
        12307 
        12308  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
        12309  {
        12310  json.BeginObject(true);
        12311  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
        12312  hAlloc->PrintParameters(json);
        12313  json.EndObject();
        12314  }
        12315 
        12316  json.EndArray();
        12317  }
        12318  }
        12319  if(dedicatedAllocationsStarted)
        12320  {
        12321  json.EndObject();
        12322  }
        12323 
        12324  {
        12325  bool allocationsStarted = false;
        12326  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
        12327  {
        12328  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
        12329  {
        12330  if(allocationsStarted == false)
        12331  {
        12332  allocationsStarted = true;
        12333  json.WriteString("DefaultPools");
        12334  json.BeginObject();
        12335  }
        12336 
        12337  json.BeginString("Type ");
        12338  json.ContinueString(memTypeIndex);
        12339  json.EndString();
        12340 
        12341  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
        12342  }
        12343  }
        12344  if(allocationsStarted)
        12345  {
        12346  json.EndObject();
        12347  }
        12348  }
        12349 
        12350  // Custom pools
        12351  {
        12352  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
        12353  const size_t poolCount = m_Pools.size();
        12354  if(poolCount > 0)
        12355  {
        12356  json.WriteString("Pools");
        12357  json.BeginObject();
        12358  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
        12359  {
        12360  json.BeginString();
        12361  json.ContinueString(m_Pools[poolIndex]->GetId());
        12362  json.EndString();
        12363 
        12364  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
        12365  }
        12366  json.EndObject();
        12367  }
        12368  }
        12369 }
        12370 
        12371 #endif // #if VMA_STATS_STRING_ENABLED
        12372 
        12374 // Public interface
        12375 
        12376 VkResult vmaCreateAllocator(
        12377  const VmaAllocatorCreateInfo* pCreateInfo,
        12378  VmaAllocator* pAllocator)
        12379 {
        12380  VMA_ASSERT(pCreateInfo && pAllocator);
        12381  VMA_DEBUG_LOG("vmaCreateAllocator");
        12382  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
        12383  return (*pAllocator)->Init(pCreateInfo);
        12384 }
        12385 
        12386 void vmaDestroyAllocator(
        12387  VmaAllocator allocator)
        12388 {
        12389  if(allocator != VK_NULL_HANDLE)
        12390  {
        12391  VMA_DEBUG_LOG("vmaDestroyAllocator");
        12392  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
        12393  vma_delete(&allocationCallbacks, allocator);
        12394  }
        12395 }
        12396 
        12397 void vmaGetPhysicalDeviceProperties(
        12398  VmaAllocator allocator,
        12399  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        12400 {
        12401  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
        12402  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
        12403 }
        12404 
        12405 void vmaGetMemoryProperties(
        12406  VmaAllocator allocator,
        12407  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
        12408 {
        12409  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
        12410  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
        12411 }
        12412 
        12413 void vmaGetMemoryTypeProperties(
        12414  VmaAllocator allocator,
        12415  uint32_t memoryTypeIndex,
        12416  VkMemoryPropertyFlags* pFlags)
        12417 {
        12418  VMA_ASSERT(allocator && pFlags);
        12419  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
        12420  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
        12421 }
        12422 
        12423 void vmaSetCurrentFrameIndex(
        12424  VmaAllocator allocator,
        12425  uint32_t frameIndex)
        12426 {
        12427  VMA_ASSERT(allocator);
        12428  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
        12429 
        12430  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12431 
        12432  allocator->SetCurrentFrameIndex(frameIndex);
        12433 }
        12434 
        12435 void vmaCalculateStats(
        12436  VmaAllocator allocator,
        12437  VmaStats* pStats)
        12438 {
        12439  VMA_ASSERT(allocator && pStats);
        12440  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12441  allocator->CalculateStats(pStats);
        12442 }
        12443 
        12444 #if VMA_STATS_STRING_ENABLED
        12445 
        12446 void vmaBuildStatsString(
        12447  VmaAllocator allocator,
        12448  char** ppStatsString,
        12449  VkBool32 detailedMap)
        12450 {
        12451  VMA_ASSERT(allocator && ppStatsString);
        12452  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12453 
        12454  VmaStringBuilder sb(allocator);
        12455  {
        12456  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
        12457  json.BeginObject();
        12458 
        12459  VmaStats stats;
        12460  allocator->CalculateStats(&stats);
        12461 
        12462  json.WriteString("Total");
        12463  VmaPrintStatInfo(json, stats.total);
        12464 
        12465  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
        12466  {
        12467  json.BeginString("Heap ");
        12468  json.ContinueString(heapIndex);
        12469  json.EndString();
        12470  json.BeginObject();
        12471 
        12472  json.WriteString("Size");
        12473  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
        12474 
        12475  json.WriteString("Flags");
        12476  json.BeginArray(true);
        12477  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
        12478  {
        12479  json.WriteString("DEVICE_LOCAL");
        12480  }
        12481  json.EndArray();
        12482 
        12483  if(stats.memoryHeap[heapIndex].blockCount > 0)
        12484  {
        12485  json.WriteString("Stats");
        12486  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
        12487  }
        12488 
        12489  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
        12490  {
        12491  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
        12492  {
        12493  json.BeginString("Type ");
        12494  json.ContinueString(typeIndex);
        12495  json.EndString();
        12496 
        12497  json.BeginObject();
        12498 
        12499  json.WriteString("Flags");
        12500  json.BeginArray(true);
        12501  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
        12502  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
        12503  {
        12504  json.WriteString("DEVICE_LOCAL");
        12505  }
        12506  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        12507  {
        12508  json.WriteString("HOST_VISIBLE");
        12509  }
        12510  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
        12511  {
        12512  json.WriteString("HOST_COHERENT");
        12513  }
        12514  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
        12515  {
        12516  json.WriteString("HOST_CACHED");
        12517  }
        12518  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        12519  {
        12520  json.WriteString("LAZILY_ALLOCATED");
        12521  }
        12522  json.EndArray();
        12523 
        12524  if(stats.memoryType[typeIndex].blockCount > 0)
        12525  {
        12526  json.WriteString("Stats");
        12527  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
        12528  }
        12529 
        12530  json.EndObject();
        12531  }
        12532  }
        12533 
        12534  json.EndObject();
        12535  }
        12536  if(detailedMap == VK_TRUE)
        12537  {
        12538  allocator->PrintDetailedMap(json);
        12539  }
        12540 
        12541  json.EndObject();
        12542  }
        12543 
        12544  const size_t len = sb.GetLength();
        12545  char* const pChars = vma_new_array(allocator, char, len + 1);
        12546  if(len > 0)
        12547  {
        12548  memcpy(pChars, sb.GetData(), len);
        12549  }
        12550  pChars[len] = '\0';
        12551  *ppStatsString = pChars;
        12552 }
        12553 
        12554 void vmaFreeStatsString(
        12555  VmaAllocator allocator,
        12556  char* pStatsString)
        12557 {
        12558  if(pStatsString != VMA_NULL)
        12559  {
        12560  VMA_ASSERT(allocator);
        12561  size_t len = strlen(pStatsString);
        12562  vma_delete_array(allocator, pStatsString, len + 1);
        12563  }
        12564 }
        12565 
        12566 #endif // #if VMA_STATS_STRING_ENABLED
        12567 
        12568 /*
        12569 This function is not protected by any mutex because it just reads immutable data.
        12570 */
        12571 VkResult vmaFindMemoryTypeIndex(
        12572  VmaAllocator allocator,
        12573  uint32_t memoryTypeBits,
        12574  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        12575  uint32_t* pMemoryTypeIndex)
        12576 {
        12577  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        12578  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        12579  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        12580 
        12581  if(pAllocationCreateInfo->memoryTypeBits != 0)
        12582  {
        12583  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
        12584  }
        12585 
        12586  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
        12587  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
        12588 
        12589  const bool mapped = (pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
        12590  if(mapped)
        12591  {
        12592  preferredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        12593  }
        12594 
        12595  // Convert usage to requiredFlags and preferredFlags.
        12596  switch(pAllocationCreateInfo->usage)
        12597  {
        12598  case VMA_MEMORY_USAGE_UNKNOWN:
        12599  break;
        12600  case VMA_MEMORY_USAGE_GPU_ONLY:
        12601  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        12602  {
        12603  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        12604  }
        12605  break;
        12606  case VMA_MEMORY_USAGE_CPU_ONLY:
        12607  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        12608  break;
        12609  case VMA_MEMORY_USAGE_CPU_TO_GPU:
        12610  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        12611  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
        12612  {
        12613  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
        12614  }
        12615  break;
        12616  case VMA_MEMORY_USAGE_GPU_TO_CPU:
        12617  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
        12618  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        12619  break;
        12620  default:
        12621  break;
        12622  }
        12623 
        12624  *pMemoryTypeIndex = UINT32_MAX;
        12625  uint32_t minCost = UINT32_MAX;
        12626  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
        12627  memTypeIndex < allocator->GetMemoryTypeCount();
        12628  ++memTypeIndex, memTypeBit <<= 1)
        12629  {
        12630  // This memory type is acceptable according to memoryTypeBits bitmask.
        12631  if((memTypeBit & memoryTypeBits) != 0)
        12632  {
        12633  const VkMemoryPropertyFlags currFlags =
        12634  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
        12635  // This memory type contains requiredFlags.
        12636  if((requiredFlags & ~currFlags) == 0)
        12637  {
        12638  // Calculate cost as number of bits from preferredFlags not present in this memory type.
        12639  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
        12640  // Remember memory type with lowest cost.
        12641  if(currCost < minCost)
        12642  {
        12643  *pMemoryTypeIndex = memTypeIndex;
        12644  if(currCost == 0)
        12645  {
        12646  return VK_SUCCESS;
        12647  }
        12648  minCost = currCost;
        12649  }
        12650  }
        12651  }
        12652  }
        12653  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
        12654 }
        12655 
        12656 VkResult vmaFindMemoryTypeIndexForBufferInfo(
        12657  VmaAllocator allocator,
        12658  const VkBufferCreateInfo* pBufferCreateInfo,
        12659  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        12660  uint32_t* pMemoryTypeIndex)
        12661 {
        12662  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        12663  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
        12664  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        12665  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        12666 
        12667  const VkDevice hDev = allocator->m_hDevice;
        12668  VkBuffer hBuffer = VK_NULL_HANDLE;
        12669  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
        12670  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
        12671  if(res == VK_SUCCESS)
        12672  {
        12673  VkMemoryRequirements memReq = {};
        12674  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
        12675  hDev, hBuffer, &memReq);
        12676 
        12677  res = vmaFindMemoryTypeIndex(
        12678  allocator,
        12679  memReq.memoryTypeBits,
        12680  pAllocationCreateInfo,
        12681  pMemoryTypeIndex);
        12682 
        12683  allocator->GetVulkanFunctions().vkDestroyBuffer(
        12684  hDev, hBuffer, allocator->GetAllocationCallbacks());
        12685  }
        12686  return res;
        12687 }
        12688 
        12689 VkResult vmaFindMemoryTypeIndexForImageInfo(
        12690  VmaAllocator allocator,
        12691  const VkImageCreateInfo* pImageCreateInfo,
        12692  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        12693  uint32_t* pMemoryTypeIndex)
        12694 {
        12695  VMA_ASSERT(allocator != VK_NULL_HANDLE);
        12696  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
        12697  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
        12698  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
        12699 
        12700  const VkDevice hDev = allocator->m_hDevice;
        12701  VkImage hImage = VK_NULL_HANDLE;
        12702  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
        12703  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
        12704  if(res == VK_SUCCESS)
        12705  {
        12706  VkMemoryRequirements memReq = {};
        12707  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
        12708  hDev, hImage, &memReq);
        12709 
        12710  res = vmaFindMemoryTypeIndex(
        12711  allocator,
        12712  memReq.memoryTypeBits,
        12713  pAllocationCreateInfo,
        12714  pMemoryTypeIndex);
        12715 
        12716  allocator->GetVulkanFunctions().vkDestroyImage(
        12717  hDev, hImage, allocator->GetAllocationCallbacks());
        12718  }
        12719  return res;
        12720 }
        12721 
        12722 VkResult vmaCreatePool(
        12723  VmaAllocator allocator,
        12724  const VmaPoolCreateInfo* pCreateInfo,
        12725  VmaPool* pPool)
        12726 {
        12727  VMA_ASSERT(allocator && pCreateInfo && pPool);
        12728 
        12729  VMA_DEBUG_LOG("vmaCreatePool");
        12730 
        12731  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12732 
        12733  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
        12734 
        12735 #if VMA_RECORDING_ENABLED
        12736  if(allocator->GetRecorder() != VMA_NULL)
        12737  {
        12738  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
        12739  }
        12740 #endif
        12741 
        12742  return res;
        12743 }
        12744 
        12745 void vmaDestroyPool(
        12746  VmaAllocator allocator,
        12747  VmaPool pool)
        12748 {
        12749  VMA_ASSERT(allocator);
        12750 
        12751  if(pool == VK_NULL_HANDLE)
        12752  {
        12753  return;
        12754  }
        12755 
        12756  VMA_DEBUG_LOG("vmaDestroyPool");
        12757 
        12758  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12759 
        12760 #if VMA_RECORDING_ENABLED
        12761  if(allocator->GetRecorder() != VMA_NULL)
        12762  {
        12763  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
        12764  }
        12765 #endif
        12766 
        12767  allocator->DestroyPool(pool);
        12768 }
        12769 
        12770 void vmaGetPoolStats(
        12771  VmaAllocator allocator,
        12772  VmaPool pool,
        12773  VmaPoolStats* pPoolStats)
        12774 {
        12775  VMA_ASSERT(allocator && pool && pPoolStats);
        12776 
        12777  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12778 
        12779  allocator->GetPoolStats(pool, pPoolStats);
        12780 }
        12781 
        12782 void vmaMakePoolAllocationsLost(
        12783  VmaAllocator allocator,
        12784  VmaPool pool,
        12785  size_t* pLostAllocationCount)
        12786 {
        12787  VMA_ASSERT(allocator && pool);
        12788 
        12789  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12790 
        12791 #if VMA_RECORDING_ENABLED
        12792  if(allocator->GetRecorder() != VMA_NULL)
        12793  {
        12794  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
        12795  }
        12796 #endif
        12797 
        12798  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
        12799 }
        12800 
        12801 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
        12802 {
        12803  VMA_ASSERT(allocator && pool);
        12804 
        12805  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12806 
        12807  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
        12808 
        12809  return allocator->CheckPoolCorruption(pool);
        12810 }
        12811 
        12812 VkResult vmaAllocateMemory(
        12813  VmaAllocator allocator,
        12814  const VkMemoryRequirements* pVkMemoryRequirements,
        12815  const VmaAllocationCreateInfo* pCreateInfo,
        12816  VmaAllocation* pAllocation,
        12817  VmaAllocationInfo* pAllocationInfo)
        12818 {
        12819  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
        12820 
        12821  VMA_DEBUG_LOG("vmaAllocateMemory");
        12822 
        12823  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12824 
        12825  VkResult result = allocator->AllocateMemory(
        12826  *pVkMemoryRequirements,
        12827  false, // requiresDedicatedAllocation
        12828  false, // prefersDedicatedAllocation
        12829  VK_NULL_HANDLE, // dedicatedBuffer
        12830  VK_NULL_HANDLE, // dedicatedImage
        12831  *pCreateInfo,
        12832  VMA_SUBALLOCATION_TYPE_UNKNOWN,
        12833  pAllocation);
        12834 
        12835 #if VMA_RECORDING_ENABLED
        12836  if(allocator->GetRecorder() != VMA_NULL)
        12837  {
        12838  allocator->GetRecorder()->RecordAllocateMemory(
        12839  allocator->GetCurrentFrameIndex(),
        12840  *pVkMemoryRequirements,
        12841  *pCreateInfo,
        12842  *pAllocation);
        12843  }
        12844 #endif
        12845 
        12846  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
        12847  {
        12848  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        12849  }
        12850 
        12851  return result;
        12852 }
        12853 
        12854 VkResult vmaAllocateMemoryForBuffer(
        12855  VmaAllocator allocator,
        12856  VkBuffer buffer,
        12857  const VmaAllocationCreateInfo* pCreateInfo,
        12858  VmaAllocation* pAllocation,
        12859  VmaAllocationInfo* pAllocationInfo)
        12860 {
        12861  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        12862 
        12863  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
        12864 
        12865  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12866 
        12867  VkMemoryRequirements vkMemReq = {};
        12868  bool requiresDedicatedAllocation = false;
        12869  bool prefersDedicatedAllocation = false;
        12870  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
        12871  requiresDedicatedAllocation,
        12872  prefersDedicatedAllocation);
        12873 
        12874  VkResult result = allocator->AllocateMemory(
        12875  vkMemReq,
        12876  requiresDedicatedAllocation,
        12877  prefersDedicatedAllocation,
        12878  buffer, // dedicatedBuffer
        12879  VK_NULL_HANDLE, // dedicatedImage
        12880  *pCreateInfo,
        12881  VMA_SUBALLOCATION_TYPE_BUFFER,
        12882  pAllocation);
        12883 
        12884 #if VMA_RECORDING_ENABLED
        12885  if(allocator->GetRecorder() != VMA_NULL)
        12886  {
        12887  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
        12888  allocator->GetCurrentFrameIndex(),
        12889  vkMemReq,
        12890  requiresDedicatedAllocation,
        12891  prefersDedicatedAllocation,
        12892  *pCreateInfo,
        12893  *pAllocation);
        12894  }
        12895 #endif
        12896 
        12897  if(pAllocationInfo && result == VK_SUCCESS)
        12898  {
        12899  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        12900  }
        12901 
        12902  return result;
        12903 }
        12904 
        12905 VkResult vmaAllocateMemoryForImage(
        12906  VmaAllocator allocator,
        12907  VkImage image,
        12908  const VmaAllocationCreateInfo* pCreateInfo,
        12909  VmaAllocation* pAllocation,
        12910  VmaAllocationInfo* pAllocationInfo)
        12911 {
        12912  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
        12913 
        12914  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
        12915 
        12916  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12917 
        12918  VkMemoryRequirements vkMemReq = {};
        12919  bool requiresDedicatedAllocation = false;
        12920  bool prefersDedicatedAllocation = false;
        12921  allocator->GetImageMemoryRequirements(image, vkMemReq,
        12922  requiresDedicatedAllocation, prefersDedicatedAllocation);
        12923 
        12924  VkResult result = allocator->AllocateMemory(
        12925  vkMemReq,
        12926  requiresDedicatedAllocation,
        12927  prefersDedicatedAllocation,
        12928  VK_NULL_HANDLE, // dedicatedBuffer
        12929  image, // dedicatedImage
        12930  *pCreateInfo,
        12931  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
        12932  pAllocation);
        12933 
        12934 #if VMA_RECORDING_ENABLED
        12935  if(allocator->GetRecorder() != VMA_NULL)
        12936  {
        12937  allocator->GetRecorder()->RecordAllocateMemoryForImage(
        12938  allocator->GetCurrentFrameIndex(),
        12939  vkMemReq,
        12940  requiresDedicatedAllocation,
        12941  prefersDedicatedAllocation,
        12942  *pCreateInfo,
        12943  *pAllocation);
        12944  }
        12945 #endif
        12946 
        12947  if(pAllocationInfo && result == VK_SUCCESS)
        12948  {
        12949  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        12950  }
        12951 
        12952  return result;
        12953 }
        12954 
        12955 void vmaFreeMemory(
        12956  VmaAllocator allocator,
        12957  VmaAllocation allocation)
        12958 {
        12959  VMA_ASSERT(allocator);
        12960 
        12961  if(allocation == VK_NULL_HANDLE)
        12962  {
        12963  return;
        12964  }
        12965 
        12966  VMA_DEBUG_LOG("vmaFreeMemory");
        12967 
        12968  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12969 
        12970 #if VMA_RECORDING_ENABLED
        12971  if(allocator->GetRecorder() != VMA_NULL)
        12972  {
        12973  allocator->GetRecorder()->RecordFreeMemory(
        12974  allocator->GetCurrentFrameIndex(),
        12975  allocation);
        12976  }
        12977 #endif
        12978 
        12979  allocator->FreeMemory(allocation);
        12980 }
        12981 
        12982 void vmaGetAllocationInfo(
        12983  VmaAllocator allocator,
        12984  VmaAllocation allocation,
        12985  VmaAllocationInfo* pAllocationInfo)
        12986 {
        12987  VMA_ASSERT(allocator && allocation && pAllocationInfo);
        12988 
        12989  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        12990 
        12991 #if VMA_RECORDING_ENABLED
        12992  if(allocator->GetRecorder() != VMA_NULL)
        12993  {
        12994  allocator->GetRecorder()->RecordGetAllocationInfo(
        12995  allocator->GetCurrentFrameIndex(),
        12996  allocation);
        12997  }
        12998 #endif
        12999 
        13000  allocator->GetAllocationInfo(allocation, pAllocationInfo);
        13001 }
        13002 
        13003 VkBool32 vmaTouchAllocation(
        13004  VmaAllocator allocator,
        13005  VmaAllocation allocation)
        13006 {
        13007  VMA_ASSERT(allocator && allocation);
        13008 
        13009  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13010 
        13011 #if VMA_RECORDING_ENABLED
        13012  if(allocator->GetRecorder() != VMA_NULL)
        13013  {
        13014  allocator->GetRecorder()->RecordTouchAllocation(
        13015  allocator->GetCurrentFrameIndex(),
        13016  allocation);
        13017  }
        13018 #endif
        13019 
        13020  return allocator->TouchAllocation(allocation);
        13021 }
        13022 
        13023 void vmaSetAllocationUserData(
        13024  VmaAllocator allocator,
        13025  VmaAllocation allocation,
        13026  void* pUserData)
        13027 {
        13028  VMA_ASSERT(allocator && allocation);
        13029 
        13030  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13031 
        13032  allocation->SetUserData(allocator, pUserData);
        13033 
        13034 #if VMA_RECORDING_ENABLED
        13035  if(allocator->GetRecorder() != VMA_NULL)
        13036  {
        13037  allocator->GetRecorder()->RecordSetAllocationUserData(
        13038  allocator->GetCurrentFrameIndex(),
        13039  allocation,
        13040  pUserData);
        13041  }
        13042 #endif
        13043 }
        13044 
        13045 void vmaCreateLostAllocation(
        13046  VmaAllocator allocator,
        13047  VmaAllocation* pAllocation)
        13048 {
        13049  VMA_ASSERT(allocator && pAllocation);
        13050 
        13051  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
        13052 
        13053  allocator->CreateLostAllocation(pAllocation);
        13054 
        13055 #if VMA_RECORDING_ENABLED
        13056  if(allocator->GetRecorder() != VMA_NULL)
        13057  {
        13058  allocator->GetRecorder()->RecordCreateLostAllocation(
        13059  allocator->GetCurrentFrameIndex(),
        13060  *pAllocation);
        13061  }
        13062 #endif
        13063 }
        13064 
        13065 VkResult vmaMapMemory(
        13066  VmaAllocator allocator,
        13067  VmaAllocation allocation,
        13068  void** ppData)
        13069 {
        13070  VMA_ASSERT(allocator && allocation && ppData);
        13071 
        13072  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13073 
        13074  VkResult res = allocator->Map(allocation, ppData);
        13075 
        13076 #if VMA_RECORDING_ENABLED
        13077  if(allocator->GetRecorder() != VMA_NULL)
        13078  {
        13079  allocator->GetRecorder()->RecordMapMemory(
        13080  allocator->GetCurrentFrameIndex(),
        13081  allocation);
        13082  }
        13083 #endif
        13084 
        13085  return res;
        13086 }
        13087 
        13088 void vmaUnmapMemory(
        13089  VmaAllocator allocator,
        13090  VmaAllocation allocation)
        13091 {
        13092  VMA_ASSERT(allocator && allocation);
        13093 
        13094  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13095 
        13096 #if VMA_RECORDING_ENABLED
        13097  if(allocator->GetRecorder() != VMA_NULL)
        13098  {
        13099  allocator->GetRecorder()->RecordUnmapMemory(
        13100  allocator->GetCurrentFrameIndex(),
        13101  allocation);
        13102  }
        13103 #endif
        13104 
        13105  allocator->Unmap(allocation);
        13106 }
        13107 
        13108 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        13109 {
        13110  VMA_ASSERT(allocator && allocation);
        13111 
        13112  VMA_DEBUG_LOG("vmaFlushAllocation");
        13113 
        13114  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13115 
        13116  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
        13117 
        13118 #if VMA_RECORDING_ENABLED
        13119  if(allocator->GetRecorder() != VMA_NULL)
        13120  {
        13121  allocator->GetRecorder()->RecordFlushAllocation(
        13122  allocator->GetCurrentFrameIndex(),
        13123  allocation, offset, size);
        13124  }
        13125 #endif
        13126 }
        13127 
        13128 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        13129 {
        13130  VMA_ASSERT(allocator && allocation);
        13131 
        13132  VMA_DEBUG_LOG("vmaInvalidateAllocation");
        13133 
        13134  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13135 
        13136  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
        13137 
        13138 #if VMA_RECORDING_ENABLED
        13139  if(allocator->GetRecorder() != VMA_NULL)
        13140  {
        13141  allocator->GetRecorder()->RecordInvalidateAllocation(
        13142  allocator->GetCurrentFrameIndex(),
        13143  allocation, offset, size);
        13144  }
        13145 #endif
        13146 }
        13147 
        13148 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
        13149 {
        13150  VMA_ASSERT(allocator);
        13151 
        13152  VMA_DEBUG_LOG("vmaCheckCorruption");
        13153 
        13154  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13155 
        13156  return allocator->CheckCorruption(memoryTypeBits);
        13157 }
        13158 
        13159 VkResult vmaDefragment(
        13160  VmaAllocator allocator,
        13161  VmaAllocation* pAllocations,
        13162  size_t allocationCount,
        13163  VkBool32* pAllocationsChanged,
        13164  const VmaDefragmentationInfo *pDefragmentationInfo,
        13165  VmaDefragmentationStats* pDefragmentationStats)
        13166 {
        13167  VMA_ASSERT(allocator && pAllocations);
        13168 
        13169  VMA_DEBUG_LOG("vmaDefragment");
        13170 
        13171  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13172 
        13173  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
        13174 }
        13175 
        13176 VkResult vmaBindBufferMemory(
        13177  VmaAllocator allocator,
        13178  VmaAllocation allocation,
        13179  VkBuffer buffer)
        13180 {
        13181  VMA_ASSERT(allocator && allocation && buffer);
        13182 
        13183  VMA_DEBUG_LOG("vmaBindBufferMemory");
        13184 
        13185  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13186 
        13187  return allocator->BindBufferMemory(allocation, buffer);
        13188 }
        13189 
        13190 VkResult vmaBindImageMemory(
        13191  VmaAllocator allocator,
        13192  VmaAllocation allocation,
        13193  VkImage image)
        13194 {
        13195  VMA_ASSERT(allocator && allocation && image);
        13196 
        13197  VMA_DEBUG_LOG("vmaBindImageMemory");
        13198 
        13199  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13200 
        13201  return allocator->BindImageMemory(allocation, image);
        13202 }
        13203 
        13204 VkResult vmaCreateBuffer(
        13205  VmaAllocator allocator,
        13206  const VkBufferCreateInfo* pBufferCreateInfo,
        13207  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        13208  VkBuffer* pBuffer,
        13209  VmaAllocation* pAllocation,
        13210  VmaAllocationInfo* pAllocationInfo)
        13211 {
        13212  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
        13213 
        13214  VMA_DEBUG_LOG("vmaCreateBuffer");
        13215 
        13216  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13217 
        13218  *pBuffer = VK_NULL_HANDLE;
        13219  *pAllocation = VK_NULL_HANDLE;
        13220 
        13221  // 1. Create VkBuffer.
        13222  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
        13223  allocator->m_hDevice,
        13224  pBufferCreateInfo,
        13225  allocator->GetAllocationCallbacks(),
        13226  pBuffer);
        13227  if(res >= 0)
        13228  {
        13229  // 2. vkGetBufferMemoryRequirements.
        13230  VkMemoryRequirements vkMemReq = {};
        13231  bool requiresDedicatedAllocation = false;
        13232  bool prefersDedicatedAllocation = false;
        13233  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
        13234  requiresDedicatedAllocation, prefersDedicatedAllocation);
        13235 
        13236  // Make sure alignment requirements for specific buffer usages reported
        13237  // in Physical Device Properties are included in alignment reported by memory requirements.
        13238  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
        13239  {
        13240  VMA_ASSERT(vkMemReq.alignment %
        13241  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
        13242  }
        13243  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
        13244  {
        13245  VMA_ASSERT(vkMemReq.alignment %
        13246  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
        13247  }
        13248  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
        13249  {
        13250  VMA_ASSERT(vkMemReq.alignment %
        13251  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
        13252  }
        13253 
        13254  // 3. Allocate memory using allocator.
        13255  res = allocator->AllocateMemory(
        13256  vkMemReq,
        13257  requiresDedicatedAllocation,
        13258  prefersDedicatedAllocation,
        13259  *pBuffer, // dedicatedBuffer
        13260  VK_NULL_HANDLE, // dedicatedImage
        13261  *pAllocationCreateInfo,
        13262  VMA_SUBALLOCATION_TYPE_BUFFER,
        13263  pAllocation);
        13264 
        13265 #if VMA_RECORDING_ENABLED
        13266  if(allocator->GetRecorder() != VMA_NULL)
        13267  {
        13268  allocator->GetRecorder()->RecordCreateBuffer(
        13269  allocator->GetCurrentFrameIndex(),
        13270  *pBufferCreateInfo,
        13271  *pAllocationCreateInfo,
        13272  *pAllocation);
        13273  }
        13274 #endif
        13275 
        13276  if(res >= 0)
        13277  {
        13278  // 3. Bind buffer with memory.
        13279  res = allocator->BindBufferMemory(*pAllocation, *pBuffer);
        13280  if(res >= 0)
        13281  {
        13282  // All steps succeeded.
        13283  #if VMA_STATS_STRING_ENABLED
        13284  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
        13285  #endif
        13286  if(pAllocationInfo != VMA_NULL)
        13287  {
        13288  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        13289  }
        13290 
        13291  return VK_SUCCESS;
        13292  }
        13293  allocator->FreeMemory(*pAllocation);
        13294  *pAllocation = VK_NULL_HANDLE;
        13295  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        13296  *pBuffer = VK_NULL_HANDLE;
        13297  return res;
        13298  }
        13299  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
        13300  *pBuffer = VK_NULL_HANDLE;
        13301  return res;
        13302  }
        13303  return res;
        13304 }
        13305 
        13306 void vmaDestroyBuffer(
        13307  VmaAllocator allocator,
        13308  VkBuffer buffer,
        13309  VmaAllocation allocation)
        13310 {
        13311  VMA_ASSERT(allocator);
        13312 
        13313  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        13314  {
        13315  return;
        13316  }
        13317 
        13318  VMA_DEBUG_LOG("vmaDestroyBuffer");
        13319 
        13320  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13321 
        13322 #if VMA_RECORDING_ENABLED
        13323  if(allocator->GetRecorder() != VMA_NULL)
        13324  {
        13325  allocator->GetRecorder()->RecordDestroyBuffer(
        13326  allocator->GetCurrentFrameIndex(),
        13327  allocation);
        13328  }
        13329 #endif
        13330 
        13331  if(buffer != VK_NULL_HANDLE)
        13332  {
        13333  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
        13334  }
        13335 
        13336  if(allocation != VK_NULL_HANDLE)
        13337  {
        13338  allocator->FreeMemory(allocation);
        13339  }
        13340 }
        13341 
        13342 VkResult vmaCreateImage(
        13343  VmaAllocator allocator,
        13344  const VkImageCreateInfo* pImageCreateInfo,
        13345  const VmaAllocationCreateInfo* pAllocationCreateInfo,
        13346  VkImage* pImage,
        13347  VmaAllocation* pAllocation,
        13348  VmaAllocationInfo* pAllocationInfo)
        13349 {
        13350  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
        13351 
        13352  VMA_DEBUG_LOG("vmaCreateImage");
        13353 
        13354  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13355 
        13356  *pImage = VK_NULL_HANDLE;
        13357  *pAllocation = VK_NULL_HANDLE;
        13358 
        13359  // 1. Create VkImage.
        13360  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
        13361  allocator->m_hDevice,
        13362  pImageCreateInfo,
        13363  allocator->GetAllocationCallbacks(),
        13364  pImage);
        13365  if(res >= 0)
        13366  {
        13367  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
        13368  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
        13369  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
        13370 
        13371  // 2. Allocate memory using allocator.
        13372  VkMemoryRequirements vkMemReq = {};
        13373  bool requiresDedicatedAllocation = false;
        13374  bool prefersDedicatedAllocation = false;
        13375  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
        13376  requiresDedicatedAllocation, prefersDedicatedAllocation);
        13377 
        13378  res = allocator->AllocateMemory(
        13379  vkMemReq,
        13380  requiresDedicatedAllocation,
        13381  prefersDedicatedAllocation,
        13382  VK_NULL_HANDLE, // dedicatedBuffer
        13383  *pImage, // dedicatedImage
        13384  *pAllocationCreateInfo,
        13385  suballocType,
        13386  pAllocation);
        13387 
        13388 #if VMA_RECORDING_ENABLED
        13389  if(allocator->GetRecorder() != VMA_NULL)
        13390  {
        13391  allocator->GetRecorder()->RecordCreateImage(
        13392  allocator->GetCurrentFrameIndex(),
        13393  *pImageCreateInfo,
        13394  *pAllocationCreateInfo,
        13395  *pAllocation);
        13396  }
        13397 #endif
        13398 
        13399  if(res >= 0)
        13400  {
        13401  // 3. Bind image with memory.
        13402  res = allocator->BindImageMemory(*pAllocation, *pImage);
        13403  if(res >= 0)
        13404  {
        13405  // All steps succeeded.
        13406  #if VMA_STATS_STRING_ENABLED
        13407  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
        13408  #endif
        13409  if(pAllocationInfo != VMA_NULL)
        13410  {
        13411  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
        13412  }
        13413 
        13414  return VK_SUCCESS;
        13415  }
        13416  allocator->FreeMemory(*pAllocation);
        13417  *pAllocation = VK_NULL_HANDLE;
        13418  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        13419  *pImage = VK_NULL_HANDLE;
        13420  return res;
        13421  }
        13422  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
        13423  *pImage = VK_NULL_HANDLE;
        13424  return res;
        13425  }
        13426  return res;
        13427 }
        13428 
        13429 void vmaDestroyImage(
        13430  VmaAllocator allocator,
        13431  VkImage image,
        13432  VmaAllocation allocation)
        13433 {
        13434  VMA_ASSERT(allocator);
        13435 
        13436  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
        13437  {
        13438  return;
        13439  }
        13440 
        13441  VMA_DEBUG_LOG("vmaDestroyImage");
        13442 
        13443  VMA_DEBUG_GLOBAL_MUTEX_LOCK
        13444 
        13445 #if VMA_RECORDING_ENABLED
        13446  if(allocator->GetRecorder() != VMA_NULL)
        13447  {
        13448  allocator->GetRecorder()->RecordDestroyImage(
        13449  allocator->GetCurrentFrameIndex(),
        13450  allocation);
        13451  }
        13452 #endif
        13453 
        13454  if(image != VK_NULL_HANDLE)
        13455  {
        13456  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
        13457  }
        13458  if(allocation != VK_NULL_HANDLE)
        13459  {
        13460  allocator->FreeMemory(allocation);
        13461  }
        13462 }
        13463 
        13464 #endif // #ifdef VMA_IMPLEMENTATION
        VmaVulkanFunctions::vkGetPhysicalDeviceProperties
        PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
        Definition: vk_mem_alloc.h:1446
        +
        VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
        Set this flag if the allocation should have its own memory block.
        Definition: vk_mem_alloc.h:1759
        vmaUnmapMemory
        void vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
        Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
        -
        VmaAllocatorCreateInfo::physicalDevice
        VkPhysicalDevice physicalDevice
        Vulkan physical device.
        Definition: vk_mem_alloc.h:1499
        +
        VmaAllocatorCreateInfo::physicalDevice
        VkPhysicalDevice physicalDevice
        Vulkan physical device.
        Definition: vk_mem_alloc.h:1515
        vmaDefragment
        VkResult vmaDefragment(VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
        Compacts memory by moving allocations.
        vmaInvalidateAllocation
        void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        Invalidates memory of given allocation.
        VmaAllocation
        Represents single memory allocation.
        -
        VMA_RECORD_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1461
        -
        VmaVulkanFunctions::vkCreateBuffer
        PFN_vkCreateBuffer vkCreateBuffer
        Definition: vk_mem_alloc.h:1442
        +
        VMA_RECORD_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1477
        +
        VmaPoolStats::blockCount
        size_t blockCount
        Number of VkDeviceMemory blocks allocated for this pool.
        Definition: vk_mem_alloc.h:2032
        +
        VmaVulkanFunctions::vkCreateBuffer
        PFN_vkCreateBuffer vkCreateBuffer
        Definition: vk_mem_alloc.h:1458
        vmaFreeStatsString
        void vmaFreeStatsString(VmaAllocator allocator, char *pStatsString)
        VmaStats
        struct VmaStats VmaStats
        General statistics from current state of Allocator.
        -
        VMA_MEMORY_USAGE_GPU_ONLY
        Definition: vk_mem_alloc.h:1700
        -
        VmaVulkanFunctions::vkMapMemory
        PFN_vkMapMemory vkMapMemory
        Definition: vk_mem_alloc.h:1434
        -
        VmaAllocationInfo::deviceMemory
        VkDeviceMemory deviceMemory
        Handle to Vulkan memory object.
        Definition: vk_mem_alloc.h:2110
        -
        VmaAllocatorCreateInfo::flags
        VmaAllocatorCreateFlags flags
        Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
        Definition: vk_mem_alloc.h:1496
        -
        VmaDefragmentationInfo::maxAllocationsToMove
        uint32_t maxAllocationsToMove
        Maximum number of allocations that can be moved to different place.
        Definition: vk_mem_alloc.h:2355
        -
        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:1924
        -
        VMA_RECORDING_ENABLED
        #define VMA_RECORDING_ENABLED
        Definition: vk_mem_alloc.h:1473
        +
        VMA_MEMORY_USAGE_GPU_ONLY
        Definition: vk_mem_alloc.h:1716
        +
        VmaVulkanFunctions::vkMapMemory
        PFN_vkMapMemory vkMapMemory
        Definition: vk_mem_alloc.h:1450
        +
        VmaAllocationInfo::deviceMemory
        VkDeviceMemory deviceMemory
        Handle to Vulkan memory object.
        Definition: vk_mem_alloc.h:2132
        +
        VmaAllocatorCreateInfo::flags
        VmaAllocatorCreateFlags flags
        Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
        Definition: vk_mem_alloc.h:1512
        +
        VmaDefragmentationInfo::maxAllocationsToMove
        uint32_t maxAllocationsToMove
        Maximum number of allocations that can be moved to different place.
        Definition: vk_mem_alloc.h:2377
        +
        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:1940
        +
        VMA_RECORDING_ENABLED
        #define VMA_RECORDING_ENABLED
        Definition: vk_mem_alloc.h:1489
        vmaMakePoolAllocationsLost
        void vmaMakePoolAllocationsLost(VmaAllocator allocator, VmaPool pool, size_t *pLostAllocationCount)
        Marks all allocations in given pool as lost if they are not used in current frame or VmaPoolCreateInf...
        -
        VmaPoolStats::size
        VkDeviceSize size
        Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
        Definition: vk_mem_alloc.h:1994
        -
        VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
        Definition: vk_mem_alloc.h:1780
        -
        VmaAllocatorCreateFlags
        VkFlags VmaAllocatorCreateFlags
        Definition: vk_mem_alloc.h:1423
        -
        VmaAllocationCreateInfo::preferredFlags
        VkMemoryPropertyFlags preferredFlags
        Flags that preferably should be set in a memory type chosen for an allocation.
        Definition: vk_mem_alloc.h:1823
        -
        VMA_MEMORY_USAGE_MAX_ENUM
        Definition: vk_mem_alloc.h:1727
        -
        VmaAllocatorCreateInfo::pAllocationCallbacks
        const VkAllocationCallbacks * pAllocationCallbacks
        Custom CPU memory allocation callbacks. Optional.
        Definition: vk_mem_alloc.h:1508
        +
        VmaPoolStats::size
        VkDeviceSize size
        Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
        Definition: vk_mem_alloc.h:2013
        +
        VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
        Definition: vk_mem_alloc.h:1796
        +
        VmaAllocatorCreateFlags
        VkFlags VmaAllocatorCreateFlags
        Definition: vk_mem_alloc.h:1439
        +
        VmaAllocationCreateInfo::preferredFlags
        VkMemoryPropertyFlags preferredFlags
        Flags that preferably should be set in a memory type chosen for an allocation.
        Definition: vk_mem_alloc.h:1839
        +
        VMA_MEMORY_USAGE_MAX_ENUM
        Definition: vk_mem_alloc.h:1743
        +
        VmaAllocatorCreateInfo::pAllocationCallbacks
        const VkAllocationCallbacks * pAllocationCallbacks
        Custom CPU memory allocation callbacks. Optional.
        Definition: vk_mem_alloc.h:1524
        vmaCalculateStats
        void vmaCalculateStats(VmaAllocator allocator, VmaStats *pStats)
        Retrieves statistics from current state of the Allocator.
        -
        VmaAllocatorCreateInfo::pVulkanFunctions
        const VmaVulkanFunctions * pVulkanFunctions
        Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1...
        Definition: vk_mem_alloc.h:1561
        -
        VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        Definition: vk_mem_alloc.h:1493
        +
        VmaAllocatorCreateInfo::pVulkanFunctions
        const VmaVulkanFunctions * pVulkanFunctions
        Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1...
        Definition: vk_mem_alloc.h:1577
        +
        VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        Definition: vk_mem_alloc.h:1509
        vmaDestroyAllocator
        void vmaDestroyAllocator(VmaAllocator allocator)
        Destroys allocator object.
        -
        VmaAllocationCreateFlagBits
        VmaAllocationCreateFlagBits
        Flags to be passed as VmaAllocationCreateInfo::flags.
        Definition: vk_mem_alloc.h:1731
        +
        VmaAllocationCreateFlagBits
        VmaAllocationCreateFlagBits
        Flags to be passed as VmaAllocationCreateInfo::flags.
        Definition: vk_mem_alloc.h:1747
        vmaGetAllocationInfo
        void vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
        Returns current information about specified allocation and atomically marks it as used in current fra...
        -
        VmaStatInfo::allocationSizeMax
        VkDeviceSize allocationSizeMax
        Definition: vk_mem_alloc.h:1633
        -
        VmaVulkanFunctions::vkBindImageMemory
        PFN_vkBindImageMemory vkBindImageMemory
        Definition: vk_mem_alloc.h:1439
        -
        VmaStatInfo::unusedBytes
        VkDeviceSize unusedBytes
        Total number of bytes occupied by unused ranges.
        Definition: vk_mem_alloc.h:1632
        -
        VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        Definition: vk_mem_alloc.h:2359
        +
        VmaStatInfo::allocationSizeMax
        VkDeviceSize allocationSizeMax
        Definition: vk_mem_alloc.h:1649
        +
        VmaVulkanFunctions::vkBindImageMemory
        PFN_vkBindImageMemory vkBindImageMemory
        Definition: vk_mem_alloc.h:1455
        +
        VmaStatInfo::unusedBytes
        VkDeviceSize unusedBytes
        Total number of bytes occupied by unused ranges.
        Definition: vk_mem_alloc.h:1648
        +
        VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        Definition: vk_mem_alloc.h:2381
        vmaFreeMemory
        void vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
        Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().
        -
        VmaAllocatorCreateInfo::frameInUseCount
        uint32_t frameInUseCount
        Maximum number of additional frames that are in use at the same time as current frame.
        Definition: vk_mem_alloc.h:1525
        -
        VmaStats::total
        VmaStatInfo total
        Definition: vk_mem_alloc.h:1642
        -
        VmaDefragmentationStats::deviceMemoryBlocksFreed
        uint32_t deviceMemoryBlocksFreed
        Number of empty VkDeviceMemory objects that have been released to the system.
        Definition: vk_mem_alloc.h:2367
        -
        VmaAllocationCreateInfo::flags
        VmaAllocationCreateFlags flags
        Use VmaAllocationCreateFlagBits enum.
        Definition: vk_mem_alloc.h:1807
        -
        VmaDefragmentationInfo::maxBytesToMove
        VkDeviceSize maxBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:2350
        -
        VmaVulkanFunctions::vkGetBufferMemoryRequirements
        PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
        Definition: vk_mem_alloc.h:1440
        -
        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:1365
        +
        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:1541
        +
        VmaStats::total
        VmaStatInfo total
        Definition: vk_mem_alloc.h:1658
        +
        VmaDefragmentationStats::deviceMemoryBlocksFreed
        uint32_t deviceMemoryBlocksFreed
        Number of empty VkDeviceMemory objects that have been released to the system.
        Definition: vk_mem_alloc.h:2389
        +
        VmaAllocationCreateInfo::flags
        VmaAllocationCreateFlags flags
        Use VmaAllocationCreateFlagBits enum.
        Definition: vk_mem_alloc.h:1823
        +
        VmaDefragmentationInfo::maxBytesToMove
        VkDeviceSize maxBytesToMove
        Maximum total numbers of bytes that can be copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:2372
        +
        VmaVulkanFunctions::vkGetBufferMemoryRequirements
        PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
        Definition: vk_mem_alloc.h:1456
        +
        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:1381
        VmaAllocator
        Represents main object of this library initialized.
        -
        VmaAllocatorCreateInfo::device
        VkDevice device
        Vulkan device.
        Definition: vk_mem_alloc.h:1502
        +
        VmaAllocatorCreateInfo::device
        VkDevice device
        Vulkan device.
        Definition: vk_mem_alloc.h:1518
        vmaBindBufferMemory
        VkResult vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)
        Binds buffer to allocation.
        -
        VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        Definition: vk_mem_alloc.h:1947
        -
        VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1941
        -
        VmaAllocatorCreateInfo::pRecordSettings
        const VmaRecordSettings * pRecordSettings
        Parameters for recording of VMA calls. Can be null.
        Definition: vk_mem_alloc.h:1568
        -
        VmaAllocationInfo::size
        VkDeviceSize size
        Size of this allocation, in bytes.
        Definition: vk_mem_alloc.h:2120
        +
        VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        Definition: vk_mem_alloc.h:1963
        +
        VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1957
        +
        VmaAllocatorCreateInfo::pRecordSettings
        const VmaRecordSettings * pRecordSettings
        Parameters for recording of VMA calls. Can be null.
        Definition: vk_mem_alloc.h:1584
        +
        VmaAllocationInfo::size
        VkDeviceSize size
        Size of this allocation, in bytes.
        Definition: vk_mem_alloc.h:2142
        vmaGetMemoryTypeProperties
        void vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
        Given Memory Type Index, returns Property Flags of this memory type.
        -
        VmaVulkanFunctions::vkUnmapMemory
        PFN_vkUnmapMemory vkUnmapMemory
        Definition: vk_mem_alloc.h:1435
        -
        VMA_RECORD_FLUSH_AFTER_CALL_BIT
        Enables flush after recording every function call.
        Definition: vk_mem_alloc.h:1459
        -
        VmaAllocationCreateInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
        Definition: vk_mem_alloc.h:1844
        -
        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:1963
        -
        VmaPoolStats::allocationCount
        size_t allocationCount
        Number of VmaAllocation objects created from this pool that were not destroyed or lost...
        Definition: vk_mem_alloc.h:2000
        +
        VmaVulkanFunctions::vkUnmapMemory
        PFN_vkUnmapMemory vkUnmapMemory
        Definition: vk_mem_alloc.h:1451
        +
        VMA_RECORD_FLUSH_AFTER_CALL_BIT
        Enables flush after recording every function call.
        Definition: vk_mem_alloc.h:1475
        +
        VmaAllocationCreateInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
        Definition: vk_mem_alloc.h:1860
        +
        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:1983
        +
        VmaPoolStats::allocationCount
        size_t allocationCount
        Number of VmaAllocation objects created from this pool that were not destroyed or lost...
        Definition: vk_mem_alloc.h:2019
        VmaVulkanFunctions
        struct VmaVulkanFunctions VmaVulkanFunctions
        Pointers to some Vulkan functions - a subset used by the library.
        -
        VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1421
        -
        VmaPoolCreateInfo::memoryTypeIndex
        uint32_t memoryTypeIndex
        Vulkan memory type index to allocate this pool from.
        Definition: vk_mem_alloc.h:1950
        +
        VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1437
        +
        VmaPoolCreateInfo::memoryTypeIndex
        uint32_t memoryTypeIndex
        Vulkan memory type index to allocate this pool from.
        Definition: vk_mem_alloc.h:1966
        vmaFindMemoryTypeIndex
        VkResult vmaFindMemoryTypeIndex(VmaAllocator allocator, uint32_t memoryTypeBits, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo.
        -
        VmaMemoryUsage
        VmaMemoryUsage
        Definition: vk_mem_alloc.h:1678
        +
        VmaMemoryUsage
        VmaMemoryUsage
        Definition: vk_mem_alloc.h:1694
        VmaAllocationInfo
        struct VmaAllocationInfo VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        vmaFlushAllocation
        void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
        Flushes memory of given allocation.
        -
        VmaDefragmentationInfo
        Optional configuration parameters to be passed to function vmaDefragment().
        Definition: vk_mem_alloc.h:2345
        +
        VmaDefragmentationInfo
        Optional configuration parameters to be passed to function vmaDefragment().
        Definition: vk_mem_alloc.h:2367
        VmaPoolCreateInfo
        struct VmaPoolCreateInfo VmaPoolCreateInfo
        Describes parameter of created VmaPool.
        vmaDestroyPool
        void vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
        Destroys VmaPool object and frees Vulkan device memory.
        -
        VmaDefragmentationStats::bytesFreed
        VkDeviceSize bytesFreed
        Total number of bytes that have been released to the system by freeing empty VkDeviceMemory objects...
        Definition: vk_mem_alloc.h:2363
        -
        VMA_MEMORY_USAGE_CPU_TO_GPU
        Definition: vk_mem_alloc.h:1717
        -
        VmaAllocationCreateInfo::memoryTypeBits
        uint32_t memoryTypeBits
        Bitmask containing one bit set for every memory type acceptable for this allocation.
        Definition: vk_mem_alloc.h:1831
        -
        VmaVulkanFunctions::vkBindBufferMemory
        PFN_vkBindBufferMemory vkBindBufferMemory
        Definition: vk_mem_alloc.h:1438
        +
        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:2385
        +
        VMA_MEMORY_USAGE_CPU_TO_GPU
        Definition: vk_mem_alloc.h:1733
        +
        VmaAllocationCreateInfo::memoryTypeBits
        uint32_t memoryTypeBits
        Bitmask containing one bit set for every memory type acceptable for this allocation.
        Definition: vk_mem_alloc.h:1847
        +
        VmaVulkanFunctions::vkBindBufferMemory
        PFN_vkBindBufferMemory vkBindBufferMemory
        Definition: vk_mem_alloc.h:1454
        VmaPool
        Represents custom memory pool.
        vmaGetPoolStats
        void vmaGetPoolStats(VmaAllocator allocator, VmaPool pool, VmaPoolStats *pPoolStats)
        Retrieves statistics of existing VmaPool object.
        VmaDefragmentationInfo
        struct VmaDefragmentationInfo VmaDefragmentationInfo
        Optional configuration parameters to be passed to function vmaDefragment().
        -
        VmaStats
        General statistics from current state of Allocator.
        Definition: vk_mem_alloc.h:1638
        -
        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:1371
        +
        VmaStats
        General statistics from current state of Allocator.
        Definition: vk_mem_alloc.h:1654
        +
        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:1387
        vmaSetAllocationUserData
        void vmaSetAllocationUserData(VmaAllocator allocator, VmaAllocation allocation, void *pUserData)
        Sets pUserData in given allocation to new value.
        vmaCreatePool
        VkResult vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
        Allocates Vulkan device memory and creates VmaPool object.
        -
        VmaAllocatorCreateFlagBits
        VmaAllocatorCreateFlagBits
        Flags for created VmaAllocator.
        Definition: vk_mem_alloc.h:1392
        +
        VmaAllocatorCreateFlagBits
        VmaAllocatorCreateFlagBits
        Flags for created VmaAllocator.
        Definition: vk_mem_alloc.h:1408
        vmaBindImageMemory
        VkResult vmaBindImageMemory(VmaAllocator allocator, VmaAllocation allocation, VkImage image)
        Binds image to allocation.
        VmaStatInfo
        struct VmaStatInfo VmaStatInfo
        Calculated statistics of memory usage in entire allocator.
        -
        VmaRecordFlags
        VkFlags VmaRecordFlags
        Definition: vk_mem_alloc.h:1463
        -
        VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
        Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
        Definition: vk_mem_alloc.h:1397
        -
        VmaDefragmentationStats::allocationsMoved
        uint32_t allocationsMoved
        Number of allocations that have been moved to different places.
        Definition: vk_mem_alloc.h:2365
        +
        VmaRecordFlags
        VkFlags VmaRecordFlags
        Definition: vk_mem_alloc.h:1479
        +
        VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT
        Allocator and all objects created from it will not be synchronized internally, so you must guarantee ...
        Definition: vk_mem_alloc.h:1413
        +
        VmaDefragmentationStats::allocationsMoved
        uint32_t allocationsMoved
        Number of allocations that have been moved to different places.
        Definition: vk_mem_alloc.h:2387
        vmaCreateLostAllocation
        void vmaCreateLostAllocation(VmaAllocator allocator, VmaAllocation *pAllocation)
        Creates new allocation that is in lost state from the beginning.
        -
        VmaAllocationCreateInfo::requiredFlags
        VkMemoryPropertyFlags requiredFlags
        Flags that must be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:1818
        -
        VmaPoolStats::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Size of the largest continuous free memory region.
        Definition: vk_mem_alloc.h:2010
        +
        VmaAllocationCreateInfo::requiredFlags
        VkMemoryPropertyFlags requiredFlags
        Flags that must be set in a Memory Type chosen for an allocation.
        Definition: vk_mem_alloc.h:1834
        +
        VmaPoolStats::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Size of the largest continuous free memory region available for new allocation.
        Definition: vk_mem_alloc.h:2029
        vmaBuildStatsString
        void vmaBuildStatsString(VmaAllocator allocator, char **ppStatsString, VkBool32 detailedMap)
        Builds and returns statistics as string in JSON format.
        -
        VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
        PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
        Definition: vk_mem_alloc.h:1431
        -
        VmaStatInfo
        Calculated statistics of memory usage in entire allocator.
        Definition: vk_mem_alloc.h:1621
        -
        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:1958
        -
        VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        Definition: vk_mem_alloc.h:1384
        +
        VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
        PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
        Definition: vk_mem_alloc.h:1447
        +
        VmaStatInfo
        Calculated statistics of memory usage in entire allocator.
        Definition: vk_mem_alloc.h:1637
        +
        VmaPoolCreateInfo::blockSize
        VkDeviceSize blockSize
        Size of a single VkDeviceMemory block to be allocated as part of this pool, in bytes. Optional.
        Definition: vk_mem_alloc.h:1978
        +
        VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        Definition: vk_mem_alloc.h:1400
        vmaCreateBuffer
        VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        -
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
        Definition: vk_mem_alloc.h:1787
        -
        VmaStatInfo::unusedRangeSizeMin
        VkDeviceSize unusedRangeSizeMin
        Definition: vk_mem_alloc.h:1634
        -
        VmaDeviceMemoryCallbacks::pfnFree
        PFN_vmaFreeDeviceMemoryFunction pfnFree
        Optional, can be null.
        Definition: vk_mem_alloc.h:1388
        -
        VmaPoolCreateInfo::flags
        VmaPoolCreateFlags flags
        Use combination of VmaPoolCreateFlagBits.
        Definition: vk_mem_alloc.h:1953
        -
        VMA_MEMORY_USAGE_GPU_TO_CPU
        Definition: vk_mem_alloc.h:1726
        -
        VmaVulkanFunctions::vkInvalidateMappedMemoryRanges
        PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
        Definition: vk_mem_alloc.h:1437
        +
        VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
        Definition: vk_mem_alloc.h:1803
        +
        VmaStatInfo::unusedRangeSizeMin
        VkDeviceSize unusedRangeSizeMin
        Definition: vk_mem_alloc.h:1650
        +
        VmaDeviceMemoryCallbacks::pfnFree
        PFN_vmaFreeDeviceMemoryFunction pfnFree
        Optional, can be null.
        Definition: vk_mem_alloc.h:1404
        +
        VmaPoolCreateInfo::flags
        VmaPoolCreateFlags flags
        Use combination of VmaPoolCreateFlagBits.
        Definition: vk_mem_alloc.h:1969
        +
        VMA_MEMORY_USAGE_GPU_TO_CPU
        Definition: vk_mem_alloc.h:1742
        +
        VmaVulkanFunctions::vkInvalidateMappedMemoryRanges
        PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
        Definition: vk_mem_alloc.h:1453
        VmaPoolStats
        struct VmaPoolStats VmaPoolStats
        Describes parameter of existing VmaPool.
        vmaCreateImage
        VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        Function similar to vmaCreateBuffer().
        -
        VmaAllocationCreateInfo::usage
        VmaMemoryUsage usage
        Intended usage of memory.
        Definition: vk_mem_alloc.h:1813
        -
        VmaAllocationCreateInfo
        Definition: vk_mem_alloc.h:1804
        +
        VmaAllocationCreateInfo::usage
        VmaMemoryUsage usage
        Intended usage of memory.
        Definition: vk_mem_alloc.h:1829
        +
        VmaAllocationCreateInfo
        Definition: vk_mem_alloc.h:1820
        vmaFindMemoryTypeIndexForImageInfo
        VkResult vmaFindMemoryTypeIndexForImageInfo(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo.
        -
        VmaStatInfo::blockCount
        uint32_t blockCount
        Number of VkDeviceMemory Vulkan memory blocks allocated.
        Definition: vk_mem_alloc.h:1624
        -
        VmaVulkanFunctions::vkFreeMemory
        PFN_vkFreeMemory vkFreeMemory
        Definition: vk_mem_alloc.h:1433
        -
        VmaPoolCreateInfo::maxBlockCount
        size_t maxBlockCount
        Maximum number of blocks that can be allocated in this pool. Optional.
        Definition: vk_mem_alloc.h:1972
        -
        VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
        const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
        Informative callbacks for vkAllocateMemory, vkFreeMemory. Optional.
        Definition: vk_mem_alloc.h:1511
        -
        VmaPoolStats::unusedRangeCount
        size_t unusedRangeCount
        Number of continuous memory ranges in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2003
        -
        VmaAllocationCreateFlags
        VkFlags VmaAllocationCreateFlags
        Definition: vk_mem_alloc.h:1802
        -
        VmaAllocationCreateInfo::pool
        VmaPool pool
        Pool that this allocation should be created in.
        Definition: vk_mem_alloc.h:1837
        +
        VmaStatInfo::blockCount
        uint32_t blockCount
        Number of VkDeviceMemory Vulkan memory blocks allocated.
        Definition: vk_mem_alloc.h:1640
        +
        VmaVulkanFunctions::vkFreeMemory
        PFN_vkFreeMemory vkFreeMemory
        Definition: vk_mem_alloc.h:1449
        +
        VmaPoolCreateInfo::maxBlockCount
        size_t maxBlockCount
        Maximum number of blocks that can be allocated in this pool. Optional.
        Definition: vk_mem_alloc.h:1991
        +
        VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
        const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
        Informative callbacks for vkAllocateMemory, vkFreeMemory. Optional.
        Definition: vk_mem_alloc.h:1527
        +
        VmaPoolStats::unusedRangeCount
        size_t unusedRangeCount
        Number of continuous memory ranges in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2022
        +
        VmaAllocationCreateFlags
        VkFlags VmaAllocationCreateFlags
        Definition: vk_mem_alloc.h:1818
        +
        VmaAllocationCreateInfo::pool
        VmaPool pool
        Pool that this allocation should be created in.
        Definition: vk_mem_alloc.h:1853
        vmaGetMemoryProperties
        void vmaGetMemoryProperties(VmaAllocator allocator, const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
        -
        VmaAllocatorCreateInfo::pHeapSizeLimit
        const VkDeviceSize * pHeapSizeLimit
        Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out o...
        Definition: vk_mem_alloc.h:1549
        -
        VmaStats::memoryType
        VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
        Definition: vk_mem_alloc.h:1640
        -
        VMA_ALLOCATION_CREATE_MAPPED_BIT
        Set this flag to use a memory that will be persistently mapped and retrieve pointer to it...
        Definition: vk_mem_alloc.h:1767
        -
        VmaStatInfo::allocationSizeMin
        VkDeviceSize allocationSizeMin
        Definition: vk_mem_alloc.h:1633
        +
        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:1565
        +
        VmaStats::memoryType
        VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
        Definition: vk_mem_alloc.h:1656
        +
        VMA_ALLOCATION_CREATE_MAPPED_BIT
        Set this flag to use a memory that will be persistently mapped and retrieve pointer to it...
        Definition: vk_mem_alloc.h:1783
        +
        VmaStatInfo::allocationSizeMin
        VkDeviceSize allocationSizeMin
        Definition: vk_mem_alloc.h:1649
        vmaFindMemoryTypeIndexForBufferInfo
        VkResult vmaFindMemoryTypeIndexForBufferInfo(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
        Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
        -
        VmaVulkanFunctions::vkCreateImage
        PFN_vkCreateImage vkCreateImage
        Definition: vk_mem_alloc.h:1444
        -
        VmaRecordSettings::flags
        VmaRecordFlags flags
        Flags for recording. Use VmaRecordFlagBits enum.
        Definition: vk_mem_alloc.h:1481
        -
        VmaDeviceMemoryCallbacks::pfnAllocate
        PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
        Optional, can be null.
        Definition: vk_mem_alloc.h:1386
        -
        VmaVulkanFunctions::vkDestroyBuffer
        PFN_vkDestroyBuffer vkDestroyBuffer
        Definition: vk_mem_alloc.h:1443
        +
        VmaVulkanFunctions::vkCreateImage
        PFN_vkCreateImage vkCreateImage
        Definition: vk_mem_alloc.h:1460
        +
        VmaRecordSettings::flags
        VmaRecordFlags flags
        Flags for recording. Use VmaRecordFlagBits enum.
        Definition: vk_mem_alloc.h:1497
        +
        VmaDeviceMemoryCallbacks::pfnAllocate
        PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
        Optional, can be null.
        Definition: vk_mem_alloc.h:1402
        +
        VmaVulkanFunctions::vkDestroyBuffer
        PFN_vkDestroyBuffer vkDestroyBuffer
        Definition: vk_mem_alloc.h:1459
        vmaMapMemory
        VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
        Maps memory represented by given allocation and returns pointer to it.
        -
        VmaPoolCreateInfo::frameInUseCount
        uint32_t frameInUseCount
        Maximum number of additional frames that are in use at the same time as current frame.
        Definition: vk_mem_alloc.h:1986
        -
        VmaVulkanFunctions::vkFlushMappedMemoryRanges
        PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
        Definition: vk_mem_alloc.h:1436
        -
        VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
        Definition: vk_mem_alloc.h:1798
        +
        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:2005
        +
        VmaVulkanFunctions::vkFlushMappedMemoryRanges
        PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
        Definition: vk_mem_alloc.h:1452
        +
        VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
        Definition: vk_mem_alloc.h:1814
        vmaAllocateMemoryForImage
        VkResult vmaAllocateMemoryForImage(VmaAllocator allocator, VkImage image, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        Function similar to vmaAllocateMemoryForBuffer().
        VmaAllocatorCreateInfo
        struct VmaAllocatorCreateInfo VmaAllocatorCreateInfo
        Description of a Allocator to be created.
        -
        VmaRecordSettings::pFilePath
        const char * pFilePath
        Path to the file that should be written by the recording.
        Definition: vk_mem_alloc.h:1489
        -
        VmaAllocationInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
        Definition: vk_mem_alloc.h:2134
        -
        VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
        VkDeviceSize preferredLargeHeapBlockSize
        Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB...
        Definition: vk_mem_alloc.h:1505
        -
        VmaStatInfo::allocationSizeAvg
        VkDeviceSize allocationSizeAvg
        Definition: vk_mem_alloc.h:1633
        -
        VmaStatInfo::usedBytes
        VkDeviceSize usedBytes
        Total number of bytes occupied by all allocations.
        Definition: vk_mem_alloc.h:1630
        +
        VmaRecordSettings::pFilePath
        const char * pFilePath
        Path to the file that should be written by the recording.
        Definition: vk_mem_alloc.h:1505
        +
        VmaAllocationInfo::pUserData
        void * pUserData
        Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
        Definition: vk_mem_alloc.h:2156
        +
        VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
        VkDeviceSize preferredLargeHeapBlockSize
        Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB...
        Definition: vk_mem_alloc.h:1521
        +
        VmaStatInfo::allocationSizeAvg
        VkDeviceSize allocationSizeAvg
        Definition: vk_mem_alloc.h:1649
        +
        VmaStatInfo::usedBytes
        VkDeviceSize usedBytes
        Total number of bytes occupied by all allocations.
        Definition: vk_mem_alloc.h:1646
        VmaDeviceMemoryCallbacks
        struct VmaDeviceMemoryCallbacks VmaDeviceMemoryCallbacks
        Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
        vmaCheckCorruption
        VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
        Checks magic number in margins around all allocations in given memory types (in both default and cust...
        -
        VmaPoolStats
        Describes parameter of existing VmaPool.
        Definition: vk_mem_alloc.h:1991
        +
        VmaPoolStats
        Describes parameter of existing VmaPool.
        Definition: vk_mem_alloc.h:2010
        vmaCheckPoolCorruption
        VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
        Checks magic number in margins around all allocations in given memory pool in search for corruptions...
        -
        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:2115
        -
        VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1800
        -
        VmaDefragmentationStats::bytesMoved
        VkDeviceSize bytesMoved
        Total number of bytes that have been copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:2361
        -
        VmaVulkanFunctions
        Pointers to some Vulkan functions - a subset used by the library.
        Definition: vk_mem_alloc.h:1429
        +
        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:2137
        +
        VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
        Definition: vk_mem_alloc.h:1816
        +
        VmaDefragmentationStats::bytesMoved
        VkDeviceSize bytesMoved
        Total number of bytes that have been copied while moving allocations to different places...
        Definition: vk_mem_alloc.h:2383
        +
        VmaVulkanFunctions
        Pointers to some Vulkan functions - a subset used by the library.
        Definition: vk_mem_alloc.h:1445
        vmaCreateAllocator
        VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
        Creates Allocator object.
        -
        VmaStatInfo::unusedRangeCount
        uint32_t unusedRangeCount
        Number of free ranges of memory between allocations.
        Definition: vk_mem_alloc.h:1628
        -
        VMA_MEMORY_USAGE_UNKNOWN
        Definition: vk_mem_alloc.h:1683
        -
        VmaPoolCreateFlags
        VkFlags VmaPoolCreateFlags
        Definition: vk_mem_alloc.h:1943
        +
        VmaStatInfo::unusedRangeCount
        uint32_t unusedRangeCount
        Number of free ranges of memory between allocations.
        Definition: vk_mem_alloc.h:1644
        +
        VMA_MEMORY_USAGE_UNKNOWN
        Definition: vk_mem_alloc.h:1699
        +
        VmaPoolCreateFlags
        VkFlags VmaPoolCreateFlags
        Definition: vk_mem_alloc.h:1959
        vmaGetPhysicalDeviceProperties
        void vmaGetPhysicalDeviceProperties(VmaAllocator allocator, const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
        -
        VmaRecordSettings
        Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
        Definition: vk_mem_alloc.h:1478
        -
        VmaStatInfo::allocationCount
        uint32_t allocationCount
        Number of VmaAllocation allocation objects allocated.
        Definition: vk_mem_alloc.h:1626
        -
        VmaVulkanFunctions::vkGetImageMemoryRequirements
        PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
        Definition: vk_mem_alloc.h:1441
        -
        VmaVulkanFunctions::vkDestroyImage
        PFN_vkDestroyImage vkDestroyImage
        Definition: vk_mem_alloc.h:1445
        -
        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:1754
        -
        VMA_MEMORY_USAGE_CPU_ONLY
        Definition: vk_mem_alloc.h:1710
        -
        VmaAllocationInfo::pMappedData
        void * pMappedData
        Pointer to the beginning of this allocation as mapped data.
        Definition: vk_mem_alloc.h:2129
        +
        VmaRecordSettings
        Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
        Definition: vk_mem_alloc.h:1494
        +
        VmaStatInfo::allocationCount
        uint32_t allocationCount
        Number of VmaAllocation allocation objects allocated.
        Definition: vk_mem_alloc.h:1642
        +
        VmaVulkanFunctions::vkGetImageMemoryRequirements
        PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
        Definition: vk_mem_alloc.h:1457
        +
        VmaVulkanFunctions::vkDestroyImage
        PFN_vkDestroyImage vkDestroyImage
        Definition: vk_mem_alloc.h:1461
        +
        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:1770
        +
        VMA_MEMORY_USAGE_CPU_ONLY
        Definition: vk_mem_alloc.h:1726
        +
        VmaAllocationInfo::pMappedData
        void * pMappedData
        Pointer to the beginning of this allocation as mapped data.
        Definition: vk_mem_alloc.h:2151
        vmaDestroyImage
        void vmaDestroyImage(VmaAllocator allocator, VkImage image, VmaAllocation allocation)
        Destroys Vulkan image and frees allocated memory.
        -
        VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
        Enables usage of VK_KHR_dedicated_allocation extension.
        Definition: vk_mem_alloc.h:1419
        +
        VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
        Enables usage of VK_KHR_dedicated_allocation extension.
        Definition: vk_mem_alloc.h:1435
        VmaDefragmentationStats
        struct VmaDefragmentationStats VmaDefragmentationStats
        Statistics returned by function vmaDefragment().
        -
        VmaVulkanFunctions::vkAllocateMemory
        PFN_vkAllocateMemory vkAllocateMemory
        Definition: vk_mem_alloc.h:1432
        -
        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
        Enables alternative, linear allocation algorithm in this pool.
        Definition: vk_mem_alloc.h:1939
        -
        VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        Definition: vk_mem_alloc.h:2096
        +
        VmaVulkanFunctions::vkAllocateMemory
        PFN_vkAllocateMemory vkAllocateMemory
        Definition: vk_mem_alloc.h:1448
        +
        VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
        Enables alternative, linear allocation algorithm in this pool.
        Definition: vk_mem_alloc.h:1955
        +
        VmaAllocationInfo
        Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
        Definition: vk_mem_alloc.h:2118
        vmaAllocateMemory
        VkResult vmaAllocateMemory(VmaAllocator allocator, const VkMemoryRequirements *pVkMemoryRequirements, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        General purpose memory allocation.
        vmaSetCurrentFrameIndex
        void vmaSetCurrentFrameIndex(VmaAllocator allocator, uint32_t frameIndex)
        Sets index of the current frame.
        VmaAllocationCreateInfo
        struct VmaAllocationCreateInfo VmaAllocationCreateInfo
        vmaAllocateMemoryForBuffer
        VkResult vmaAllocateMemoryForBuffer(VmaAllocator allocator, VkBuffer buffer, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
        -
        VmaPoolCreateFlagBits
        VmaPoolCreateFlagBits
        Flags to be passed as VmaPoolCreateInfo::flags.
        Definition: vk_mem_alloc.h:1906
        -
        VmaStatInfo::unusedRangeSizeAvg
        VkDeviceSize unusedRangeSizeAvg
        Definition: vk_mem_alloc.h:1634
        +
        VmaPoolCreateFlagBits
        VmaPoolCreateFlagBits
        Flags to be passed as VmaPoolCreateInfo::flags.
        Definition: vk_mem_alloc.h:1922
        +
        VmaStatInfo::unusedRangeSizeAvg
        VkDeviceSize unusedRangeSizeAvg
        Definition: vk_mem_alloc.h:1650
        vmaTouchAllocation
        VkBool32 vmaTouchAllocation(VmaAllocator allocator, VmaAllocation allocation)
        Returns VK_TRUE if allocation is not lost and atomically marks it as used in current frame...
        -
        VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
        Definition: vk_mem_alloc.h:1793
        -
        VmaRecordFlagBits
        VmaRecordFlagBits
        Flags to be used in VmaRecordSettings::flags.
        Definition: vk_mem_alloc.h:1453
        -
        VmaStats::memoryHeap
        VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
        Definition: vk_mem_alloc.h:1641
        +
        VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
        Definition: vk_mem_alloc.h:1809
        +
        VmaRecordFlagBits
        VmaRecordFlagBits
        Flags to be used in VmaRecordSettings::flags.
        Definition: vk_mem_alloc.h:1469
        +
        VmaStats::memoryHeap
        VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
        Definition: vk_mem_alloc.h:1657
        vmaDestroyBuffer
        void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
        Destroys Vulkan buffer and frees allocated memory.
        -
        VmaPoolStats::unusedSize
        VkDeviceSize unusedSize
        Total number of bytes in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:1997
        -
        VmaStatInfo::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Definition: vk_mem_alloc.h:1634
        +
        VmaPoolStats::unusedSize
        VkDeviceSize unusedSize
        Total number of bytes in the pool not used by any VmaAllocation.
        Definition: vk_mem_alloc.h:2016
        +
        VmaStatInfo::unusedRangeSizeMax
        VkDeviceSize unusedRangeSizeMax
        Definition: vk_mem_alloc.h:1650
        VmaRecordSettings
        struct VmaRecordSettings VmaRecordSettings
        Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
        -
        VmaAllocationInfo::memoryType
        uint32_t memoryType
        Memory type index that this allocation was allocated from.
        Definition: vk_mem_alloc.h:2101
        +
        VmaAllocationInfo::memoryType
        uint32_t memoryType
        Memory type index that this allocation was allocated from.
        Definition: vk_mem_alloc.h:2123