diff --git a/README.md b/README.md index 10be08b..6815d7a 100644 --- a/README.md +++ b/README.md @@ -51,6 +51,7 @@ Additional features: - JSON dump: Obtain a string in JSON format with detailed map of internal state, including list of allocations and gaps between them. - Convert this JSON dump into a picture to visualize your memory. See [tools/VmaDumpVis](tools/VmaDumpVis/README.md). - Debugging incorrect memory usage: Enable initialization of all allocated memory with a bit pattern to detect usage of uninitialized or freed memory. Enable validation of a magic number before and after every allocation to detect out-of-bounds memory corruption. +- Record and replay sequence of calls to library functions to a file to check correctness, measure performance, and gather statistics. # Prequisites diff --git a/bin/VmaReplay_Release_vs2015.exe b/bin/VmaReplay_Release_vs2015.exe new file mode 100644 index 0000000..1e08a58 Binary files /dev/null and b/bin/VmaReplay_Release_vs2015.exe differ diff --git a/bin/VulkanSample_Release_vs2015.exe b/bin/VulkanSample_Release_vs2015.exe index 05ae82b..3958098 100644 Binary files a/bin/VulkanSample_Release_vs2015.exe and b/bin/VulkanSample_Release_vs2015.exe differ diff --git a/docs/Recording file format.md b/docs/Recording file format.md new file mode 100644 index 0000000..b01eaf4 --- /dev/null +++ b/docs/Recording file format.md @@ -0,0 +1,287 @@ +This is an official documentation for file format used by Vulkan Memory Allocator library +to record and replay sequence of calls to its functions. +This feature can be enabled by using `VmaAllocatorCreateInfo::pRecordSettings` structure members. +For details, see main documentation of the library. +Playback can be launched using **VmaReplay** console application. + +Recording is a text file. +Line endings: Unix `'\n'`. +Character encoding: single-byte (can be ASCII or UTF-8, whaterver you use in custom strings). +Suggested file extension: **csv**. File can be processed sequentially - no random access is needed. +Each line forms a separate entry. +Each line consists of a set of values (also called columns), separated by comma `','` (hence "CSV" format - Comma Separated Values). +Number of columns is different in different lines. + +# Header + +First line identifies file format. It must always be: + + Vulkan Memory Allocator,Calls recording + +Second line identifies format version, where first column is major version and second column is minor version. +Formats with only minor version incremented are backward compatible. +VmaReplay application supports all older versions. +Current version is: + + 1,3 + +# Configuration + +Header is followed by mandatory configuration section (min format version 1.3). It starts with line: + + Config,Begin + +And ends with line: + + Config,End + +Between them there can be zero or more lines with configuration options. They store values of various variables from the current environment from the time of recording, like properties and limits of Vulkan physical device, available memory heaps and types, enabled Vulkan extensions, as well macros that configure VMA internals. Supported configuration options are: + + PhysicalDevice,apiVersion, + PhysicalDevice,driverVersion, + PhysicalDevice,vendorID, + PhysicalDevice,deviceID, + PhysicalDevice,deviceType, + PhysicalDevice,deviceName, + + PhysicalDeviceLimits,maxMemoryAllocationCount, + PhysicalDeviceLimits,bufferImageGranularity, + PhysicalDeviceLimits,nonCoherentAtomSize, + + PhysicalDeviceMemory,HeapCount, + PhysicalDeviceMemory,Heap,,size, + PhysicalDeviceMemory,Heap,,flags, + PhysicalDeviceMemory,TypeCount, + PhysicalDeviceMemory,Type,,heapIndex, + PhysicalDeviceMemory,Type,,propertyFlags, + + Extension,VK_KHR_dedicated_allocation, + + Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY, + Macro,VMA_DEBUG_ALIGNMENT, + Macro,VMA_DEBUG_MARGIN, + Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS, + Macro,VMA_DEBUG_DETECT_CORRUPTION, + Macro,VMA_DEBUG_GLOBAL_MUTEX, + Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY, + Macro,VMA_SMALL_HEAP_MAX_SIZE, + Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE, + +# Function calls + +Remaining lines contain recorded calls to VMA functions. First columns are always: + +- Thread ID : uint32 +- Time since first call : float, in seconds +- VMA frame index : uint32 +- Function name : string + +Remaining columns are function parameters and output, depending on function name, which can be: + +**vmaCreateAllocator, vmaDestroyAllocator** + +No parameters. + +**vmaCreatePool** + +- memoryTypeIndex : uint32 +- flags : uint32 +- blockSize : uint64 +- minBlockCount : uint64 +- maxBlockCount : uint64 +- frameInUseCount : uint32 +- pool (output) : pointer + +**vmaDestroyPool** + +- pool : pointer + +**vmaSetAllocationUserData** + +- allocation : pointer +- pUserData : string (may contain additional commas) + +**vmaCreateBuffer** + +- bufferCreateInfo.flags : uint32 +- bufferCreateInfo.size : uint64 +- bufferCreateInfo.usage : uint32 +- bufferCreateInfo.sharingMode : uint32 +- allocationCreateInfo.flags : uint32 +- allocationCreateInfo.usage : uint32 +- allocationCreateInfo.requiredFlags : uint32 +- allocationCreateInfo.preferredFlags : uint32 +- allocationCreateInfo.memoryTypeBits : uint32 +- allocationCreateInfo.pool : pointer +- allocation (output) : pointer +- allocationCreateInfo.pUserData : string (may contain additional commas) + +**vmaDestroyBuffer** + +- allocation : pointer + +**vmaCreateImage** + +- imageCreateInfo.flags : uint32 +- imageCreateInfo.imageType : uint32 +- imageCreateInfo.format : uint32 +- imageCreateInfo.extent.width : uint32 +- imageCreateInfo.extent.height : uint32 +- imageCreateInfo.extent.depth : uint32 +- imageCreateInfo.mipLevels : uint32 +- imageCreateInfo.arrayLayers : uint32 +- imageCreateInfo.samples : uint32 +- imageCreateInfo.tiling : uint32 +- imageCreateInfo.usage : uint32 +- imageCreateInfo.sharingMode : uint32 +- imageCreateInfo.initialLayout : uint32 +- allocationCreateInfo.flags : uint32 +- allocationCreateInfo.usage : uint32 +- allocationCreateInfo.requiredFlags : uint32 +- allocationCreateInfo.preferredFlags : uint32 +- allocationCreateInfo.memoryTypeBits : uint32 +- allocationCreateInfo.pool : pointer +- allocation (output) : pointer +- allocationCreateInfo.pUserData : string (may contain additional commas) + +**vmaDestroyImage** + +- allocation : pointer + +**vmaFreeMemory** (min format version 1.1) + +- allocation : pointer + +**vmaCreateLostAllocation** (min format version 1.2) + +- allocation (output) : pointer + +**vmaAllocateMemory** (min format version 1.2) + +- vkMemoryRequirements.size : uint64 +- vkMemoryRequirements.alignment : uint64 +- vkMemoryRequirements.memoryTypeBits : uint32 +- allocationCreateInfo.flags : uint32 +- allocationCreateInfo.usage : uint32 +- allocationCreateInfo.requiredFlags : uint32 +- allocationCreateInfo.preferredFlags : uint32 +- allocationCreateInfo.memoryTypeBits : uint32 +- allocationCreateInfo.pool : pointer +- allocation (output) : pointer +- allocationCreateInfo.pUserData : string (may contain additional commas) + +**vmaAllocateMemoryForBuffer, vmaAllocateMemoryForImage** (min format version 1.2) + +- vkMemoryRequirements.size : uint64 +- vkMemoryRequirements.alignment : uint64 +- vkMemoryRequirements.memoryTypeBits : uint32 +- requiresDedicatedAllocation : bool +- prefersDedicatedAllocation : bool +- allocationCreateInfo.flags : uint32 +- allocationCreateInfo.usage : uint32 +- allocationCreateInfo.requiredFlags : uint32 +- allocationCreateInfo.preferredFlags : uint32 +- allocationCreateInfo.memoryTypeBits : uint32 +- allocationCreateInfo.pool : pointer +- allocation (output) : pointer +- allocationCreateInfo.pUserData : string (may contain additional commas) + +**vmaMapMemory, vmaUnmapMemory** (min format version 1.2) + +- allocation : pointer + +**vmaFlushAllocation, vmaInvalidateAllocation** (min format version 1.2) + +- allocation : pointer +- offset : uint64 +- size : uint64 + +**vmaTouchAllocation, vmaGetAllocationInfo** (min format version 1.2) + +- allocation : pointer + +**vmaMakePoolAllocationsLost** (min format version: 1.2) + +- pool : pointer + +# Data types + +**bool** + +Encoded as `0` for false or `1` for true. + +**uint32, uint64** + +Encoded in decimal format. + +**pointer** + +Encoded in hexadecimal format. + +**pUserData** + +If `pUserData` was a pointer, it is encoded as hexadecimal string. +If `VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT` was used with the allocation, the string is written as-is. +It may contain additional commas. +It should not contain end-of-line characters - results are then undefined. + +# Example file + + Vulkan Memory Allocator,Calls recording + 1,3 + Config,Begin + PhysicalDevice,apiVersion,4198477 + PhysicalDevice,driverVersion,8388653 + PhysicalDevice,vendorID,4098 + PhysicalDevice,deviceID,26751 + PhysicalDevice,deviceType,2 + PhysicalDevice,deviceName,Radeon RX Vega + PhysicalDeviceLimits,maxMemoryAllocationCount,4096 + PhysicalDeviceLimits,bufferImageGranularity,1 + PhysicalDeviceLimits,nonCoherentAtomSize,128 + PhysicalDeviceMemory,HeapCount,3 + PhysicalDeviceMemory,Heap,0,size,8304721920 + PhysicalDeviceMemory,Heap,0,flags,3 + PhysicalDeviceMemory,Heap,1,size,8286175232 + PhysicalDeviceMemory,Heap,1,flags,0 + PhysicalDeviceMemory,Heap,2,size,268435456 + PhysicalDeviceMemory,Heap,2,flags,3 + PhysicalDeviceMemory,TypeCount,4 + PhysicalDeviceMemory,Type,0,heapIndex,0 + PhysicalDeviceMemory,Type,0,propertyFlags,1 + PhysicalDeviceMemory,Type,1,heapIndex,1 + PhysicalDeviceMemory,Type,1,propertyFlags,6 + PhysicalDeviceMemory,Type,2,heapIndex,2 + PhysicalDeviceMemory,Type,2,propertyFlags,7 + PhysicalDeviceMemory,Type,3,heapIndex,1 + PhysicalDeviceMemory,Type,3,propertyFlags,14 + Extension,VK_KHR_dedicated_allocation,1 + Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,0 + Macro,VMA_DEBUG_ALIGNMENT,1 + Macro,VMA_DEBUG_MARGIN,0 + Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,0 + Macro,VMA_DEBUG_DETECT_CORRUPTION,0 + Macro,VMA_DEBUG_GLOBAL_MUTEX,0 + Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,1 + Macro,VMA_SMALL_HEAP_MAX_SIZE,1073741824 + Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,268435456 + Config,End + 12552,0.000,0,vmaCreateAllocator + 12552,0.010,0,vmaCreateImage,0,1,37,128,128,1,1,1,1,1,1,0,8,36,2,0,0,0,0000000000000000,000001D85B8B1A80, + 12552,0.010,0,vmaSetAllocationUserData,000001D85B8B1A80,Ala ma kota + 12552,0.015,0,vmaCreateImage,0,1,37,128,128,1,1,1,1,0,6,0,0,0,1,0,0,0,0000000000000000,000001D85B8B1620, + 12552,0.017,0,vmaDestroyImage,000001D85B8B1A80 + 12552,0.017,0,vmaCreateBuffer,0,768,1,0,4,2,0,0,0,0000000000000000,000001D85B8B19E0, + 12552,0.017,0,vmaCreateBuffer,0,768,130,0,0,1,0,0,0,0000000000000000,000001D85B8B1A80, + 12552,0.017,0,vmaCreateBuffer,0,60,1,0,4,2,0,0,0,0000000000000000,000001D85B8B1DA0, + 12552,0.017,0,vmaCreateBuffer,0,60,66,0,0,1,0,0,0,0000000000000000,000001D85B8B16C0, + 12552,0.017,0,vmaDestroyBuffer,000001D85B8B1DA0 + 12552,0.017,0,vmaDestroyBuffer,000001D85B8B19E0 + 12552,0.022,0,vmaCreateImage,0,1,126,1424,704,1,1,1,1,0,32,0,0,0,1,0,0,0,0000000000000000,000001D85B8B1EE0, + 12552,0.048,0,vmaDestroyImage,000001D85B8B1EE0 + 12552,0.053,0,vmaCreateImage,0,1,126,1424,704,1,1,1,1,0,32,0,0,0,1,0,0,0,0000000000000000,000001D85B8B1EE0, + 12552,0.662,0,vmaDestroyImage,000001D85B8B1EE0 + 12552,0.695,0,vmaDestroyImage,000001D85B8B1620 + 12552,0.695,0,vmaDestroyBuffer,000001D85B8B16C0 + 12552,0.695,0,vmaDestroyBuffer,000001D85B8B1A80 + 12552,0.695,0,vmaDestroyAllocator \ No newline at end of file diff --git a/docs/html/annotated.html b/docs/html/annotated.html index 18ddbd5..37ef74d 100644 --- a/docs/html/annotated.html +++ b/docs/html/annotated.html @@ -75,9 +75,10 @@ $(function() {  CVmaPoolRepresents custom memory pool  CVmaPoolCreateInfoDescribes parameter of created VmaPool  CVmaPoolStatsDescribes parameter of existing VmaPool - CVmaStatInfoCalculated statistics of memory usage in entire allocator - CVmaStatsGeneral statistics from current state of Allocator - CVmaVulkanFunctionsPointers to some Vulkan functions - a subset used by the library + CVmaRecordSettingsParameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings + CVmaStatInfoCalculated statistics of memory usage in entire allocator + CVmaStatsGeneral statistics from current state of Allocator + CVmaVulkanFunctionsPointers to some Vulkan functions - a subset used by the library diff --git a/docs/html/classes.html b/docs/html/classes.html index b900f2a..099f7e3 100644 --- a/docs/html/classes.html +++ b/docs/html/classes.html @@ -65,10 +65,10 @@ $(function() {
v
- - - + + + +
  v  
-		VmaAllocationInfo   VmaDefragmentationStats   VmaPoolStats   
VmaAllocator   VmaDeviceMemoryCallbacks   VmaStatInfo   
VmaAllocation   VmaAllocatorCreateInfo   VmaPool   VmaStats   
VmaAllocationCreateInfo   VmaDefragmentationInfo   VmaPoolCreateInfo   VmaVulkanFunctions   
VmaAllocationInfo   VmaDefragmentationStats   VmaPoolStats   VmaVulkanFunctions   
VmaAllocator   VmaDeviceMemoryCallbacks   VmaRecordSettings   
VmaAllocation   VmaAllocatorCreateInfo   VmaPool   VmaStatInfo   
VmaAllocationCreateInfo   VmaDefragmentationInfo   VmaPoolCreateInfo   VmaStats   
v
diff --git a/docs/html/functions.html b/docs/html/functions.html index 0751d69..c8ce62d 100644 --- a/docs/html/functions.html +++ b/docs/html/functions.html @@ -114,6 +114,7 @@ $(function() { : VmaAllocationCreateInfo , VmaAllocatorCreateInfo , VmaPoolCreateInfo +, VmaRecordSettings
  • frameInUseCount : VmaAllocatorCreateInfo @@ -165,6 +166,9 @@ $(function() {
  • pDeviceMemoryCallbacks : VmaAllocatorCreateInfo
    • +
  • pFilePath +: VmaRecordSettings +
  • pfnAllocate : VmaDeviceMemoryCallbacks
    • @@ -183,6 +187,9 @@ $(function() {
  • pool : VmaAllocationCreateInfo
    • +
  • pRecordSettings +: VmaAllocatorCreateInfo +
  • preferredFlags : VmaAllocationCreateInfo
    • diff --git a/docs/html/functions_vars.html b/docs/html/functions_vars.html index 6ee6243..de9e9a0 100644 --- a/docs/html/functions_vars.html +++ b/docs/html/functions_vars.html @@ -114,6 +114,7 @@ $(function() { : VmaAllocationCreateInfo , VmaAllocatorCreateInfo , VmaPoolCreateInfo +, VmaRecordSettings
  • frameInUseCount : VmaAllocatorCreateInfo @@ -165,6 +166,9 @@ $(function() {
  • pDeviceMemoryCallbacks : VmaAllocatorCreateInfo
    • +
  • pFilePath +: VmaRecordSettings +
  • pfnAllocate : VmaDeviceMemoryCallbacks
    • @@ -183,6 +187,9 @@ $(function() {
  • pool : VmaAllocationCreateInfo
    • +
  • pRecordSettings +: VmaAllocatorCreateInfo +
  • preferredFlags : VmaAllocationCreateInfo
    • diff --git a/docs/html/general_considerations.html b/docs/html/general_considerations.html index 5d4362d..f631ac8 100644 --- a/docs/html/general_considerations.html +++ b/docs/html/general_considerations.html @@ -74,6 +74,23 @@ Thread safety
  • When the allocator is created with VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT flag, calls to functions that take such VmaAllocator object must be synchronized externally.
  • Access to a VmaAllocation object must be externally synchronized. For example, you must not call vmaGetAllocationInfo() and vmaMapMemory() from different threads at the same time if you pass the same VmaAllocation object to these functions.
    • +

    +Validation layer warnings

    +

    When using this library, you can meet following types of warnings issued by Vulkan validation layer. They don't necessarily indicate a bug, so you may need to just ignore them.

    +
      +
    • vkBindBufferMemory(): Binding memory to buffer 0xeb8e4 but vkGetBufferMemoryRequirements() has not been called on that buffer.
        +
      • It happens when VK_KHR_dedicated_allocation extension is enabled. vkGetBufferMemoryRequirements2KHR function is used instead, while validation layer seems to be unaware of it.
        • +
      +
      • +
    • Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.
        +
      • It happens when you map a buffer or image, because the library maps entire VkDeviceMemory block, where different types of images and buffers may end up together, especially on GPUs with unified memory like Intel.
        • +
      +
      • +
    • Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug.
        +
      • It happens when you use lost allocations, and a new image or buffer is created in place of an existing object that bacame lost.
        • +
      +
      • +

    Allocation algorithm

    The library uses following algorithm for allocation, in order:

    @@ -90,7 +107,7 @@ Allocation algorithm Features not supported

    Features deliberately excluded from the scope of this library:

      -
    • Data transfer - issuing commands that transfer data between buffers or images, any usage of VkCommandList or VkCommandQueue and related synchronization is responsibility of the user.
      • +
    • Data transfer - issuing commands that transfer data between buffers or images, any usage of VkCommandList or VkQueue and related synchronization is responsibility of the user.
    • Allocations for imported/exported external memory. They tend to require explicit memory type index and dedicated allocation anyway, so they don't interact with main features of this library. Such special purpose allocations should be made manually, using vkCreateBuffer() and vkAllocateMemory().
    • Support for any programming languages other than C/C++. Bindings to other languages are welcomed as external projects.
    diff --git a/docs/html/globals.html b/docs/html/globals.html index 08a3076..2f1f2fb 100644 --- a/docs/html/globals.html +++ b/docs/html/globals.html @@ -128,6 +128,15 @@ $(function() {
  • VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT : vk_mem_alloc.h
    • +
  • VMA_RECORD_FLAG_BITS_MAX_ENUM +: vk_mem_alloc.h +
    • +
  • VMA_RECORD_FLUSH_AFTER_CALL_BIT +: vk_mem_alloc.h +
    • +
  • VMA_RECORDING_ENABLED +: vk_mem_alloc.h +
  • VMA_STATS_STRING_ENABLED : vk_mem_alloc.h
    • @@ -275,6 +284,15 @@ $(function() {
  • VmaPoolStats : vk_mem_alloc.h
    • +
  • VmaRecordFlagBits +: vk_mem_alloc.h +
    • +
  • VmaRecordFlags +: vk_mem_alloc.h +
    • +
  • VmaRecordSettings +: vk_mem_alloc.h +
  • vmaSetAllocationUserData() : vk_mem_alloc.h
    • diff --git a/docs/html/globals_defs.html b/docs/html/globals_defs.html index aa8115b..ca5de3f 100644 --- a/docs/html/globals_defs.html +++ b/docs/html/globals_defs.html @@ -62,6 +62,9 @@ $(function() {
  • VMA_DEDICATED_ALLOCATION : vk_mem_alloc.h
    • +
  • VMA_RECORDING_ENABLED +: vk_mem_alloc.h +
  • VMA_STATS_STRING_ENABLED : vk_mem_alloc.h
    • diff --git a/docs/html/globals_enum.html b/docs/html/globals_enum.html index 1df06f1..d295ccd 100644 --- a/docs/html/globals_enum.html +++ b/docs/html/globals_enum.html @@ -71,6 +71,9 @@ $(function() {
  • VmaPoolCreateFlagBits : vk_mem_alloc.h
    • +
  • VmaRecordFlagBits +: vk_mem_alloc.h +
    • diff --git a/docs/html/globals_eval.html b/docs/html/globals_eval.html index 2035414..091f76b 100644 --- a/docs/html/globals_eval.html +++ b/docs/html/globals_eval.html @@ -113,6 +113,12 @@ $(function() {
  • VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT : vk_mem_alloc.h
    • +
  • VMA_RECORD_FLAG_BITS_MAX_ENUM +: vk_mem_alloc.h +
    • +
  • VMA_RECORD_FLUSH_AFTER_CALL_BIT +: vk_mem_alloc.h +
    • diff --git a/docs/html/globals_type.html b/docs/html/globals_type.html index 0b3156b..68106a1 100644 --- a/docs/html/globals_type.html +++ b/docs/html/globals_type.html @@ -110,6 +110,15 @@ $(function() {
  • VmaPoolStats : vk_mem_alloc.h
    • +
  • VmaRecordFlagBits +: vk_mem_alloc.h +
    • +
  • VmaRecordFlags +: vk_mem_alloc.h +
    • +
  • VmaRecordSettings +: vk_mem_alloc.h +
  • VmaStatInfo : vk_mem_alloc.h
    • diff --git a/docs/html/index.html b/docs/html/index.html index e4dc71d..dc62c22 100644 --- a/docs/html/index.html +++ b/docs/html/index.html @@ -112,6 +112,7 @@ Table of contents
  • Corruption detection
    • +
  • Record and replay
  • Recommended usage patterns
      diff --git a/docs/html/memory_mapping.html b/docs/html/memory_mapping.html index fa97ad7..7e2c263 100644 --- a/docs/html/memory_mapping.html +++ b/docs/html/memory_mapping.html @@ -69,8 +69,11 @@ $(function() {

      To "map memory" in Vulkan means to obtain a CPU pointer to VkDeviceMemory, to be able to read from it or write to it in CPU code. Mapping is possible only of memory allocated from a memory type that has VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT flag. Functions vkMapMemory(), vkUnmapMemory() are designed for this purpose. You can use them directly with memory allocated by this library, but it is not recommended because of following issue: Mapping the same VkDeviceMemory block multiple times is illegal - only one mapping at a time is allowed. This includes mapping disjoint regions. Mapping is not reference-counted internally by Vulkan. Because of this, Vulkan Memory Allocator provides following facilities:

      Mapping functions

      -

      The library provides following functions for mapping of a specific VmaAllocation: vmaMapMemory(), vmaUnmapMemory(). They are safer and more convenient to use than standard Vulkan functions. You can map an allocation multiple times simultaneously - mapping is reference-counted internally. You can also map different allocations simultaneously regardless of whether they use the same VkDeviceMemory block. They way it's implemented is that the library always maps entire memory block, not just region of the allocation. For further details, see description of vmaMapMemory() function. Example:

      -
      // Having these objects initialized:
      struct ConstantBuffer
      {
      ...
      };
      ConstantBuffer constantBufferData;
      VmaAllocator allocator;
      VmaBuffer constantBuffer;
      VmaAllocation constantBufferAllocation;
      // You can map and fill your buffer using following code:
      void* mappedData;
      vmaMapMemory(allocator, constantBufferAllocation, &mappedData);
      memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
      vmaUnmapMemory(allocator, constantBufferAllocation);

      +

      The library provides following functions for mapping of a specific VmaAllocation: vmaMapMemory(), vmaUnmapMemory(). They are safer and more convenient to use than standard Vulkan functions. You can map an allocation multiple times simultaneously - mapping is reference-counted internally. You can also map different allocations simultaneously regardless of whether they use the same VkDeviceMemory block. The way it's implemented is that the library always maps entire memory block, not just region of the allocation. For further details, see description of vmaMapMemory() function. Example:

      +
      // Having these objects initialized:
      struct ConstantBuffer
      {
      ...
      };
      ConstantBuffer constantBufferData;
      VmaAllocator allocator;
      VkBuffer constantBuffer;
      VmaAllocation constantBufferAllocation;
      // You can map and fill your buffer using following code:
      void* mappedData;
      vmaMapMemory(allocator, constantBufferAllocation, &mappedData);
      memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
      vmaUnmapMemory(allocator, constantBufferAllocation);

      When mapping, you may see a warning from Vulkan validation layer similar to this one:

      +

      Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.

      +

      It happens because the library maps entire VkDeviceMemory block, where different types of images and buffers may end up together, especially on GPUs with unified memory like Intel. You can safely ignore it if you are sure you access only memory of the intended object that you wanted to map.

      +

      Persistently mapped memory

      Kepping your memory persistently mapped is generally OK in Vulkan. You don't need to unmap it before using its data on the GPU. The library provides a special feature designed for that: Allocations made with VMA_ALLOCATION_CREATE_MAPPED_BIT flag set in VmaAllocationCreateInfo::flags stay mapped all the time, so you can just access CPU pointer to it any time without a need to call any "map" or "unmap" function. Example:

      VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
      bufCreateInfo.size = sizeof(ConstantBuffer);
      bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
      VmaAllocationCreateInfo allocCreateInfo = {};
      allocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
      allocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
      VkBuffer buf;
      VmaAllocation alloc;
      VmaAllocationInfo allocInfo;
      vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
      // Buffer is already mapped. You can access its memory.
      memcpy(allocInfo.pMappedData, &constantBufferData, sizeof(constantBufferData));

      There are some exceptions though, when you should consider mapping memory only for a short period of time:

      diff --git a/docs/html/record_and_replay.html b/docs/html/record_and_replay.html new file mode 100644 index 0000000..d4484be --- /dev/null +++ b/docs/html/record_and_replay.html @@ -0,0 +1,97 @@ + + + + + + + +Vulkan Memory Allocator: Record and replay + + + + + + + + + +
      +
      + + + + + + +
      +
      Vulkan Memory Allocator +
      +
      +
      + + + + + + + + +
      +
      + + +
      + +
      + + +
      +
      +
      +
      Record and replay
      +
      +
      +

      +Introduction

      +

      While using the library, sequence of calls to its functions together with their parameters can be recorded to a file and later replayed using standalone player application. It can be useful to:

      +
        +
      • Test correctness - check if same sequence of calls will not cause crash or failures on a target platform.
        • +
      • Gather statistics - see number of allocations, peak memory usage, number of calls etc.
        • +
      • Benchmark performance - see how much time it takes to replay the whole sequence.
        • +
      +

      +Usage

      +

      To record sequence of calls to a file: Fill in VmaAllocatorCreateInfo::pRecordSettings member while creating VmaAllocator object. File is opened and written during whole lifetime of the allocator.

      +

      To replay file: Use VmaReplay - standalone command-line program. Precompiled binary can be found in "bin" directory. Its source can be found in "src/VmaReplay" directory. Its project is generated by Premake. Command line syntax is printed when the program is launched without parameters. Basic usage: 

      VmaReplay.exe MyRecording.csv
+

      Documentation of file format can be found in file: "docs/Recording file format.md". It's a human-readable, text file in CSV format (Comma Separated Values).

      +

      +Additional considerations

      +
        +
      • Replaying file that was recorded on a different GPU (with different parameters like bufferImageGranularity, nonCoherentAtomSize, and especially different set of memory heaps and types) may give different performance and memory usage results, as well as issue some warnings and errors.
        • +
      • Current implementation of recording in VMA, as well as VmaReplay application, is coded and tested only on Windows. Inclusion of recording code is driven by VMA_RECORDING_ENABLED macro. Support for other platforms should be easy to add. Contributions are welcomed.
        • +
      • Currently calls to vmaDefragment() function are not recorded.
        • +
      +
      + +
      +Generated by   +doxygen + 1.8.13 +
      + + diff --git a/docs/html/search/all_4.js b/docs/html/search/all_4.js index 7bacfcc..347c9f3 100644 --- a/docs/html/search/all_4.js +++ b/docs/html/search/all_4.js @@ -1,5 +1,5 @@ var searchData= [ - ['flags',['flags',['../struct_vma_allocator_create_info.html#a392ea2ecbaff93f91a7c49f735ad4346',1,'VmaAllocatorCreateInfo::flags()'],['../struct_vma_allocation_create_info.html#add09658ac14fe290ace25470ddd6d41b',1,'VmaAllocationCreateInfo::flags()'],['../struct_vma_pool_create_info.html#a8405139f63d078340ae74513a59f5446',1,'VmaPoolCreateInfo::flags()']]], + ['flags',['flags',['../struct_vma_record_settings.html#ad8fdcc92119ae7a8c08c1a564c01d63a',1,'VmaRecordSettings::flags()'],['../struct_vma_allocator_create_info.html#a392ea2ecbaff93f91a7c49f735ad4346',1,'VmaAllocatorCreateInfo::flags()'],['../struct_vma_allocation_create_info.html#add09658ac14fe290ace25470ddd6d41b',1,'VmaAllocationCreateInfo::flags()'],['../struct_vma_pool_create_info.html#a8405139f63d078340ae74513a59f5446',1,'VmaPoolCreateInfo::flags()']]], ['frameinusecount',['frameInUseCount',['../struct_vma_allocator_create_info.html#a21ea188dd212b8171cb9ecbed4a2a3a7',1,'VmaAllocatorCreateInfo::frameInUseCount()'],['../struct_vma_pool_create_info.html#a9437e43ffbb644dbbf7fc4e50cfad6aa',1,'VmaPoolCreateInfo::frameInUseCount()']]] ]; diff --git a/docs/html/search/all_9.js b/docs/html/search/all_9.js index 590465a..33e01da 100644 --- a/docs/html/search/all_9.js +++ b/docs/html/search/all_9.js @@ -2,6 +2,7 @@ var searchData= [ ['pallocationcallbacks',['pAllocationCallbacks',['../struct_vma_allocator_create_info.html#a6e409087e3be55400d0e4ccbe43c608d',1,'VmaAllocatorCreateInfo']]], ['pdevicememorycallbacks',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], + ['pfilepath',['pFilePath',['../struct_vma_record_settings.html#a6cb1fdbf6bcb610b68f2010dd629e89d',1,'VmaRecordSettings']]], ['pfn_5fvmaallocatedevicememoryfunction',['PFN_vmaAllocateDeviceMemoryFunction',['../vk__mem__alloc_8h.html#ab6a6477cda1ce775b30bde96d766203b',1,'vk_mem_alloc.h']]], ['pfn_5fvmafreedevicememoryfunction',['PFN_vmaFreeDeviceMemoryFunction',['../vk__mem__alloc_8h.html#aef2545dc2e9dd4f29ab9ba6ac6fe2f49',1,'vk_mem_alloc.h']]], ['pfnallocate',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], @@ -10,6 +11,7 @@ var searchData= ['physicaldevice',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], ['pmappeddata',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], ['pool',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], + ['precordsettings',['pRecordSettings',['../struct_vma_allocator_create_info.html#ace2aa4877b16a42b0b7673d4e26000ee',1,'VmaAllocatorCreateInfo']]], ['preferredflags',['preferredFlags',['../struct_vma_allocation_create_info.html#a7fe8d81a1ad10b2a2faacacee5b15d6d',1,'VmaAllocationCreateInfo']]], ['preferredlargeheapblocksize',['preferredLargeHeapBlockSize',['../struct_vma_allocator_create_info.html#a8e4714298e3121cdd8b214a1ae7a637a',1,'VmaAllocatorCreateInfo']]], ['puserdata',['pUserData',['../struct_vma_allocation_create_info.html#a8259e85c272683434f4abb4ddddffe19',1,'VmaAllocationCreateInfo::pUserData()'],['../struct_vma_allocation_info.html#adc507656149c04de7ed95d0042ba2a13',1,'VmaAllocationInfo::pUserData()']]], diff --git a/docs/html/search/all_b.js b/docs/html/search/all_b.js index f3376c8..f0c993f 100644 --- a/docs/html/search/all_b.js +++ b/docs/html/search/all_b.js @@ -1,5 +1,6 @@ var searchData= [ + ['record_20and_20replay',['Record and replay',['../record_and_replay.html',1,'index']]], ['requiredflags',['requiredFlags',['../struct_vma_allocation_create_info.html#a9166390303ff42d783305bc31c2b6b90',1,'VmaAllocationCreateInfo']]], ['recommended_20usage_20patterns',['Recommended usage patterns',['../usage_patterns.html',1,'index']]] ]; diff --git a/docs/html/search/all_f.js b/docs/html/search/all_f.js index a80478e..60dbc10 100644 --- a/docs/html/search/all_f.js +++ b/docs/html/search/all_f.js @@ -38,6 +38,9 @@ var searchData= ['vma_5fmemory_5fusage_5funknown',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum',['VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a1c7312bea9ea246846b9054fd6bd6aec',1,'vk_mem_alloc.h']]], ['vma_5fpool_5fcreate_5fignore_5fbuffer_5fimage_5fgranularity_5fbit',['VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a9f1a499508a8edb4e8ba40aa0290a3d2',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflag_5fbits_5fmax_5fenum',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflush_5fafter_5fcall_5fbit',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]], + ['vma_5frecording_5fenabled',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], ['vma_5fstats_5fstring_5fenabled',['VMA_STATS_STRING_ENABLED',['../vk__mem__alloc_8h.html#ae25f0d55fd91cb166f002b63244800e1',1,'vk_mem_alloc.h']]], ['vmaallocatememory',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], ['vmaallocatememoryforbuffer',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], @@ -90,6 +93,9 @@ var searchData= ['vmapoolcreateflags',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], ['vmapoolcreateinfo',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'VmaPoolCreateInfo'],['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'VmaPoolCreateInfo(): vk_mem_alloc.h']]], ['vmapoolstats',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'VmaPoolStats'],['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'VmaPoolStats(): vk_mem_alloc.h']]], + ['vmarecordflagbits',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'VmaRecordFlagBits(): vk_mem_alloc.h'],['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'VmaRecordFlagBits(): vk_mem_alloc.h']]], + ['vmarecordflags',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], + ['vmarecordsettings',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'VmaRecordSettings'],['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'VmaRecordSettings(): vk_mem_alloc.h']]], ['vmasetallocationuserdata',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], ['vmasetcurrentframeindex',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], ['vmastatinfo',['VmaStatInfo',['../struct_vma_stat_info.html',1,'VmaStatInfo'],['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'VmaStatInfo(): vk_mem_alloc.h']]], diff --git a/docs/html/search/classes_0.js b/docs/html/search/classes_0.js index 152fb2b..7fe2da1 100644 --- a/docs/html/search/classes_0.js +++ b/docs/html/search/classes_0.js @@ -11,6 +11,7 @@ var searchData= ['vmapool',['VmaPool',['../struct_vma_pool.html',1,'']]], ['vmapoolcreateinfo',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'']]], ['vmapoolstats',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'']]], + ['vmarecordsettings',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'']]], ['vmastatinfo',['VmaStatInfo',['../struct_vma_stat_info.html',1,'']]], ['vmastats',['VmaStats',['../struct_vma_stats.html',1,'']]], ['vmavulkanfunctions',['VmaVulkanFunctions',['../struct_vma_vulkan_functions.html',1,'']]] diff --git a/docs/html/search/defines_0.js b/docs/html/search/defines_0.js index 336effe..bf18592 100644 --- a/docs/html/search/defines_0.js +++ b/docs/html/search/defines_0.js @@ -1,5 +1,6 @@ var searchData= [ ['vma_5fdedicated_5fallocation',['VMA_DEDICATED_ALLOCATION',['../vk__mem__alloc_8h.html#af7b860e63b96d11e44ae8587ba06bbf4',1,'vk_mem_alloc.h']]], + ['vma_5frecording_5fenabled',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], ['vma_5fstats_5fstring_5fenabled',['VMA_STATS_STRING_ENABLED',['../vk__mem__alloc_8h.html#ae25f0d55fd91cb166f002b63244800e1',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/enums_0.js b/docs/html/search/enums_0.js index 9bd6e39..c5ed539 100644 --- a/docs/html/search/enums_0.js +++ b/docs/html/search/enums_0.js @@ -3,5 +3,6 @@ var searchData= ['vmaallocationcreateflagbits',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'vk_mem_alloc.h']]], ['vmaallocatorcreateflagbits',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'vk_mem_alloc.h']]], ['vmamemoryusage',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflagbits',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'vk_mem_alloc.h']]] + ['vmapoolcreateflagbits',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'vk_mem_alloc.h']]], + ['vmarecordflagbits',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/enumvalues_0.js b/docs/html/search/enumvalues_0.js index ea47966..9f462fc 100644 --- a/docs/html/search/enumvalues_0.js +++ b/docs/html/search/enumvalues_0.js @@ -17,5 +17,7 @@ var searchData= ['vma_5fmemory_5fusage_5fmax_5fenum',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], ['vma_5fmemory_5fusage_5funknown',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum',['VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a1c7312bea9ea246846b9054fd6bd6aec',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fignore_5fbuffer_5fimage_5fgranularity_5fbit',['VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a9f1a499508a8edb4e8ba40aa0290a3d2',1,'vk_mem_alloc.h']]] + ['vma_5fpool_5fcreate_5fignore_5fbuffer_5fimage_5fgranularity_5fbit',['VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a9f1a499508a8edb4e8ba40aa0290a3d2',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflag_5fbits_5fmax_5fenum',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflush_5fafter_5fcall_5fbit',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/pages_7.js b/docs/html/search/pages_7.js index 1e4f738..7394f7d 100644 --- a/docs/html/search/pages_7.js +++ b/docs/html/search/pages_7.js @@ -1,4 +1,5 @@ var searchData= [ + ['record_20and_20replay',['Record and replay',['../record_and_replay.html',1,'index']]], ['recommended_20usage_20patterns',['Recommended usage patterns',['../usage_patterns.html',1,'index']]] ]; diff --git a/docs/html/search/typedefs_1.js b/docs/html/search/typedefs_1.js index 716f5e3..5d53a90 100644 --- a/docs/html/search/typedefs_1.js +++ b/docs/html/search/typedefs_1.js @@ -15,6 +15,9 @@ var searchData= ['vmapoolcreateflags',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], ['vmapoolcreateinfo',['VmaPoolCreateInfo',['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'vk_mem_alloc.h']]], ['vmapoolstats',['VmaPoolStats',['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'vk_mem_alloc.h']]], + ['vmarecordflagbits',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'vk_mem_alloc.h']]], + ['vmarecordflags',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], + ['vmarecordsettings',['VmaRecordSettings',['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'vk_mem_alloc.h']]], ['vmastatinfo',['VmaStatInfo',['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'vk_mem_alloc.h']]], ['vmastats',['VmaStats',['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'vk_mem_alloc.h']]], ['vmavulkanfunctions',['VmaVulkanFunctions',['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'vk_mem_alloc.h']]] diff --git a/docs/html/search/variables_3.js b/docs/html/search/variables_3.js index 7bacfcc..347c9f3 100644 --- a/docs/html/search/variables_3.js +++ b/docs/html/search/variables_3.js @@ -1,5 +1,5 @@ var searchData= [ - ['flags',['flags',['../struct_vma_allocator_create_info.html#a392ea2ecbaff93f91a7c49f735ad4346',1,'VmaAllocatorCreateInfo::flags()'],['../struct_vma_allocation_create_info.html#add09658ac14fe290ace25470ddd6d41b',1,'VmaAllocationCreateInfo::flags()'],['../struct_vma_pool_create_info.html#a8405139f63d078340ae74513a59f5446',1,'VmaPoolCreateInfo::flags()']]], + ['flags',['flags',['../struct_vma_record_settings.html#ad8fdcc92119ae7a8c08c1a564c01d63a',1,'VmaRecordSettings::flags()'],['../struct_vma_allocator_create_info.html#a392ea2ecbaff93f91a7c49f735ad4346',1,'VmaAllocatorCreateInfo::flags()'],['../struct_vma_allocation_create_info.html#add09658ac14fe290ace25470ddd6d41b',1,'VmaAllocationCreateInfo::flags()'],['../struct_vma_pool_create_info.html#a8405139f63d078340ae74513a59f5446',1,'VmaPoolCreateInfo::flags()']]], ['frameinusecount',['frameInUseCount',['../struct_vma_allocator_create_info.html#a21ea188dd212b8171cb9ecbed4a2a3a7',1,'VmaAllocatorCreateInfo::frameInUseCount()'],['../struct_vma_pool_create_info.html#a9437e43ffbb644dbbf7fc4e50cfad6aa',1,'VmaPoolCreateInfo::frameInUseCount()']]] ]; diff --git a/docs/html/search/variables_6.js b/docs/html/search/variables_6.js index 731ce38..46cab85 100644 --- a/docs/html/search/variables_6.js +++ b/docs/html/search/variables_6.js @@ -2,12 +2,14 @@ var searchData= [ ['pallocationcallbacks',['pAllocationCallbacks',['../struct_vma_allocator_create_info.html#a6e409087e3be55400d0e4ccbe43c608d',1,'VmaAllocatorCreateInfo']]], ['pdevicememorycallbacks',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], + ['pfilepath',['pFilePath',['../struct_vma_record_settings.html#a6cb1fdbf6bcb610b68f2010dd629e89d',1,'VmaRecordSettings']]], ['pfnallocate',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], ['pfnfree',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], ['pheapsizelimit',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], ['physicaldevice',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], ['pmappeddata',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], ['pool',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], + ['precordsettings',['pRecordSettings',['../struct_vma_allocator_create_info.html#ace2aa4877b16a42b0b7673d4e26000ee',1,'VmaAllocatorCreateInfo']]], ['preferredflags',['preferredFlags',['../struct_vma_allocation_create_info.html#a7fe8d81a1ad10b2a2faacacee5b15d6d',1,'VmaAllocationCreateInfo']]], ['preferredlargeheapblocksize',['preferredLargeHeapBlockSize',['../struct_vma_allocator_create_info.html#a8e4714298e3121cdd8b214a1ae7a637a',1,'VmaAllocatorCreateInfo']]], ['puserdata',['pUserData',['../struct_vma_allocation_create_info.html#a8259e85c272683434f4abb4ddddffe19',1,'VmaAllocationCreateInfo::pUserData()'],['../struct_vma_allocation_info.html#adc507656149c04de7ed95d0042ba2a13',1,'VmaAllocationInfo::pUserData()']]], diff --git a/docs/html/struct_vma_allocator_create_info-members.html b/docs/html/struct_vma_allocator_create_info-members.html index 9340920..598ecde 100644 --- a/docs/html/struct_vma_allocator_create_info-members.html +++ b/docs/html/struct_vma_allocator_create_info-members.html @@ -72,8 +72,9 @@ $(function() { pDeviceMemoryCallbacksVmaAllocatorCreateInfo pHeapSizeLimitVmaAllocatorCreateInfo physicalDeviceVmaAllocatorCreateInfo - preferredLargeHeapBlockSizeVmaAllocatorCreateInfo - pVulkanFunctionsVmaAllocatorCreateInfo + pRecordSettingsVmaAllocatorCreateInfo + preferredLargeHeapBlockSizeVmaAllocatorCreateInfo + pVulkanFunctionsVmaAllocatorCreateInfo
      diff --git a/docs/html/struct_vma_allocator_create_info.html b/docs/html/struct_vma_allocator_create_info.html index 35e8d05..f9735fb 100644 --- a/docs/html/struct_vma_allocator_create_info.html +++ b/docs/html/struct_vma_allocator_create_info.html @@ -100,6 +100,9 @@ Public Attributes const VmaVulkanFunctions * pVulkanFunctions  Pointers to Vulkan functions. Can be null if you leave define VMA_STATIC_VULKAN_FUNCTIONS 1. More...
        +const VmaRecordSettings * pRecordSettings + Parameters for recording of VMA calls. Can be null. More...
      + 

      Detailed Description

      Description of a Allocator to be created.

      @@ -229,6 +232,23 @@ Public Attributes

      Vulkan physical device.

      It must be valid throughout whole lifetime of created allocator.

      +
      + + +

      ◆ pRecordSettings

      + +
      +
      + + + + +
      const VmaRecordSettings* VmaAllocatorCreateInfo::pRecordSettings
      +
      + +

      Parameters for recording of VMA calls. Can be null.

      +

      If not null, it enables recording of calls to VMA functions to a file. If support for recording is not enabled using VMA_RECORDING_ENABLED macro, creation of the allocator object fails with VK_ERROR_FEATURE_NOT_PRESENT.

      +
      diff --git a/docs/html/struct_vma_record_settings-members.html b/docs/html/struct_vma_record_settings-members.html new file mode 100644 index 0000000..8079ef8 --- /dev/null +++ b/docs/html/struct_vma_record_settings-members.html @@ -0,0 +1,78 @@ + + + + + + + +Vulkan Memory Allocator: Member List + + + + + + + + + +
      +
      + + + + + + +
      +
      Vulkan Memory Allocator +
      +
      +
      + + + + + + + + +
      +
      + + +
      + +
      + +
      +
      +
      +
      VmaRecordSettings Member List
      +
      +
      + +

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

      + + + +
      flagsVmaRecordSettings
      pFilePathVmaRecordSettings
      + +
      +Generated by   +doxygen + 1.8.13 +
      + + diff --git a/docs/html/struct_vma_record_settings.html b/docs/html/struct_vma_record_settings.html new file mode 100644 index 0000000..fe9f186 --- /dev/null +++ b/docs/html/struct_vma_record_settings.html @@ -0,0 +1,130 @@ + + + + + + + +Vulkan Memory Allocator: VmaRecordSettings Struct Reference + + + + + + + + + +
      +
      + + + + + + +
      +
      Vulkan Memory Allocator +
      +
      +
      + + + + + + + + +
      +
      + + +
      + +
      + +
      +
      +
      +Public Attributes | +List of all members
      +
      +
      VmaRecordSettings Struct Reference
      +
      +
      + +

      Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings. + More...

      + +

      #include <vk_mem_alloc.h>

      + + + + + + + + +

      +Public Attributes

      VmaRecordFlags flags
       Flags for recording. Use VmaRecordFlagBits enum. More...
       
      const char * pFilePath
       Path to the file that should be written by the recording. More...
       
      +

      Detailed Description

      +

      Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings.

      +

      Member Data Documentation

      + +

      ◆ flags

      + +
      +
      + + + + +
      VmaRecordFlags VmaRecordSettings::flags
      +
      + +

      Flags for recording. Use VmaRecordFlagBits enum.

      + +
      +
      + +

      ◆ pFilePath

      + +
      +
      + + + + +
      const char* VmaRecordSettings::pFilePath
      +
      + +

      Path to the file that should be written by the recording.

      +

      Suggested extension: "csv". If the file already exists, it will be overwritten. It will be opened for the whole time VmaAllocator object is alive. If opening this file fails, creation of the whole allocator object fails.

      + +
      +
      +
      The documentation for this struct was generated from the following file: +
      + +
      +Generated by   +doxygen + 1.8.13 +
      + + diff --git a/docs/html/vk__mem__alloc_8h.html b/docs/html/vk__mem__alloc_8h.html index 8a066b6..4c2a48f 100644 --- a/docs/html/vk__mem__alloc_8h.html +++ b/docs/html/vk__mem__alloc_8h.html @@ -80,6 +80,9 @@ Classes struct  VmaVulkanFunctions  Pointers to some Vulkan functions - a subset used by the library. More...
        +struct  VmaRecordSettings + Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings. More...
      +  struct  VmaAllocatorCreateInfo  Description of a Allocator to be created. More...
        @@ -111,6 +114,8 @@ Classes Macros #define VMA_DEDICATED_ALLOCATION   0   +#define VMA_RECORDING_ENABLED   0 +  #define VMA_STATS_STRING_ENABLED   1   @@ -133,6 +138,14 @@ Typedefs + + + + + + + + @@ -180,6 +193,11 @@ Enumerations } + + +
      typedef struct VmaVulkanFunctions VmaVulkanFunctions
       Pointers to some Vulkan functions - a subset used by the library. More...
       
      typedef enum VmaRecordFlagBits VmaRecordFlagBits
       Flags to be used in VmaRecordSettings::flags. More...
       
      typedef VkFlags VmaRecordFlags
       
      typedef struct VmaRecordSettings VmaRecordSettings
       Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings. More...
       
      typedef struct VmaAllocatorCreateInfo VmaAllocatorCreateInfo
       Description of a Allocator to be created. More...
       
       Flags for created VmaAllocator. More...
       
      enum  VmaRecordFlagBits { VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001, +VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF + }
       Flags to be used in VmaRecordSettings::flags. More...
       
      enum  VmaMemoryUsage {
        VMA_MEMORY_USAGE_UNKNOWN = 0, VMA_MEMORY_USAGE_GPU_ONLY = 1, @@ -332,6 +350,20 @@ Functions
      +
      + + +

      ◆ VMA_RECORDING_ENABLED

      + +
      +
      + + + + +
      #define VMA_RECORDING_ENABLED   0
      +
      +
      @@ -611,6 +643,52 @@ Functions

      Describes parameter of existing VmaPool.

      + + + +

      ◆ VmaRecordFlagBits

      + +
      +
      + + + + +
      typedef enum VmaRecordFlagBits VmaRecordFlagBits
      +
      + +

      Flags to be used in VmaRecordSettings::flags.

      + +
      +
      + +

      ◆ VmaRecordFlags

      + +
      +
      + + + + +
      typedef VkFlags VmaRecordFlags
      +
      + +
      +
      + +

      ◆ VmaRecordSettings

      + +
      +
      + + + + +
      typedef struct VmaRecordSettings VmaRecordSettings
      +
      + +

      Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings.

      +
      @@ -803,6 +881,28 @@ Functions VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM  + + + +

      ◆ VmaRecordFlagBits

      + +
      +
      + + + + +
      enum VmaRecordFlagBits
      +
      + +

      Flags to be used in VmaRecordSettings::flags.

      + + + +
      Enumerator
      VMA_RECORD_FLUSH_AFTER_CALL_BIT 

      Enables flush after recording every function call.

      +

      Enable it if you expect your application to crash, which may leave recording file truncated. It may degrade performance though.

      +
      VMA_RECORD_FLAG_BITS_MAX_ENUM 
      +

      Function Documentation

      diff --git a/docs/html/vk__mem__alloc_8h_source.html b/docs/html/vk__mem__alloc_8h_source.html index 8354ec9..ea6d4ef 100644 --- a/docs/html/vk__mem__alloc_8h_source.html +++ b/docs/html/vk__mem__alloc_8h_source.html @@ -62,166 +62,176 @@ $(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 
      1184 #include <vulkan/vulkan.h>
      1185 
      1186 #if !defined(VMA_DEDICATED_ALLOCATION)
      1187  #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
      1188  #define VMA_DEDICATED_ALLOCATION 1
      1189  #else
      1190  #define VMA_DEDICATED_ALLOCATION 0
      1191  #endif
      1192 #endif
      1193 
      1203 VK_DEFINE_HANDLE(VmaAllocator)
      1204 
      1205 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
      1207  VmaAllocator allocator,
      1208  uint32_t memoryType,
      1209  VkDeviceMemory memory,
      1210  VkDeviceSize size);
      1212 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
      1213  VmaAllocator allocator,
      1214  uint32_t memoryType,
      1215  VkDeviceMemory memory,
      1216  VkDeviceSize size);
      1217 
      1225 typedef struct VmaDeviceMemoryCallbacks {
      1227  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
      1229  PFN_vmaFreeDeviceMemoryFunction pfnFree;
      1230 } VmaDeviceMemoryCallbacks;
      1231 
      1233 typedef enum VmaAllocatorCreateFlagBits {
      1238  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
      1260  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
      1261 
      1262  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1263 } VmaAllocatorCreateFlagBits;
      1264 typedef VkFlags VmaAllocatorCreateFlags;
      1265 
      1270 typedef struct VmaVulkanFunctions {
      1271  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
      1272  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
      1273  PFN_vkAllocateMemory vkAllocateMemory;
      1274  PFN_vkFreeMemory vkFreeMemory;
      1275  PFN_vkMapMemory vkMapMemory;
      1276  PFN_vkUnmapMemory vkUnmapMemory;
      1277  PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
      1278  PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
      1279  PFN_vkBindBufferMemory vkBindBufferMemory;
      1280  PFN_vkBindImageMemory vkBindImageMemory;
      1281  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
      1282  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
      1283  PFN_vkCreateBuffer vkCreateBuffer;
      1284  PFN_vkDestroyBuffer vkDestroyBuffer;
      1285  PFN_vkCreateImage vkCreateImage;
      1286  PFN_vkDestroyImage vkDestroyImage;
      1287 #if VMA_DEDICATED_ALLOCATION
      1288  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
      1289  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
      1290 #endif
      1291 } VmaVulkanFunctions;
      1292 
      1294 typedef struct VmaAllocatorCreateInfo
      1295 {
      1297  VmaAllocatorCreateFlags flags;
      1299 
      1300  VkPhysicalDevice physicalDevice;
      1302 
      1303  VkDevice device;
      1305 
      1306  VkDeviceSize preferredLargeHeapBlockSize;
      1308 
      1309  const VkAllocationCallbacks* pAllocationCallbacks;
      1311 
      1312  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
      1326  uint32_t frameInUseCount;
      1350  const VkDeviceSize* pHeapSizeLimit;
      1362  const VmaVulkanFunctions* pVulkanFunctions;
      1363 } VmaAllocatorCreateInfo;
      1364 
      1366 VkResult vmaCreateAllocator(
      1367  const VmaAllocatorCreateInfo* pCreateInfo,
      1368  VmaAllocator* pAllocator);
      1369 
      1371 void vmaDestroyAllocator(
      1372  VmaAllocator allocator);
      1373 
      1378 void vmaGetPhysicalDeviceProperties(
      1379  VmaAllocator allocator,
      1380  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
      1381 
      1386 void vmaGetMemoryProperties(
      1387  VmaAllocator allocator,
      1388  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
      1389 
      1396 void vmaGetMemoryTypeProperties(
      1397  VmaAllocator allocator,
      1398  uint32_t memoryTypeIndex,
      1399  VkMemoryPropertyFlags* pFlags);
      1400 
      1409 void vmaSetCurrentFrameIndex(
      1410  VmaAllocator allocator,
      1411  uint32_t frameIndex);
      1412 
      1415 typedef struct VmaStatInfo
      1416 {
      1418  uint32_t blockCount;
      1420  uint32_t allocationCount;
      1422  uint32_t unusedRangeCount;
      1424  VkDeviceSize usedBytes;
      1426  VkDeviceSize unusedBytes;
      1427  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
      1428  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
      1429 } VmaStatInfo;
      1430 
      1432 typedef struct VmaStats
      1433 {
      1434  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
      1435  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
      1436  VmaStatInfo total;
      1437 } VmaStats;
      1438 
      1440 void vmaCalculateStats(
      1441  VmaAllocator allocator,
      1442  VmaStats* pStats);
      1443 
      1444 #define VMA_STATS_STRING_ENABLED 1
      1445 
      1446 #if VMA_STATS_STRING_ENABLED
      1447 
      1449 
      1451 void vmaBuildStatsString(
      1452  VmaAllocator allocator,
      1453  char** ppStatsString,
      1454  VkBool32 detailedMap);
      1455 
      1456 void vmaFreeStatsString(
      1457  VmaAllocator allocator,
      1458  char* pStatsString);
      1459 
      1460 #endif // #if VMA_STATS_STRING_ENABLED
      1461 
      1470 VK_DEFINE_HANDLE(VmaPool)
      1471 
      1472 typedef enum VmaMemoryUsage
      1473 {
      1477  VMA_MEMORY_USAGE_UNKNOWN = 0,
      1494  VMA_MEMORY_USAGE_GPU_ONLY = 1,
      1504  VMA_MEMORY_USAGE_CPU_ONLY = 2,
      1511  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
      1520  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
      1521  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
      1522 } VmaMemoryUsage;
      1523 
      1525 typedef enum VmaAllocationCreateFlagBits {
      1537  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
      1538 
      1548  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
      1561  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
      1574  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
      1581  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
      1587  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
      1588 
      1589  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1590 } VmaAllocationCreateFlagBits;
      1591 typedef VkFlags VmaAllocationCreateFlags;
      1592 
      1593 typedef struct VmaAllocationCreateInfo
      1594 {
      1596  VmaAllocationCreateFlags flags;
      1602  VmaMemoryUsage usage;
      1607  VkMemoryPropertyFlags requiredFlags;
      1612  VkMemoryPropertyFlags preferredFlags;
      1620  uint32_t memoryTypeBits;
      1626  VmaPool pool;
      1633  void* pUserData;
      1634 } VmaAllocationCreateInfo;
      1635 
      1652 VkResult vmaFindMemoryTypeIndex(
      1653  VmaAllocator allocator,
      1654  uint32_t memoryTypeBits,
      1655  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      1656  uint32_t* pMemoryTypeIndex);
      1657 
      1670 VkResult vmaFindMemoryTypeIndexForBufferInfo(
      1671  VmaAllocator allocator,
      1672  const VkBufferCreateInfo* pBufferCreateInfo,
      1673  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      1674  uint32_t* pMemoryTypeIndex);
      1675 
      1688 VkResult vmaFindMemoryTypeIndexForImageInfo(
      1689  VmaAllocator allocator,
      1690  const VkImageCreateInfo* pImageCreateInfo,
      1691  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      1692  uint32_t* pMemoryTypeIndex);
      1693 
      1695 typedef enum VmaPoolCreateFlagBits {
      1713  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
      1714 
      1715  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1716 } VmaPoolCreateFlagBits;
      1717 typedef VkFlags VmaPoolCreateFlags;
      1718 
      1721 typedef struct VmaPoolCreateInfo {
      1724  uint32_t memoryTypeIndex;
      1727  VmaPoolCreateFlags flags;
      1732  VkDeviceSize blockSize;
      1737  size_t minBlockCount;
      1745  size_t maxBlockCount;
      1759  uint32_t frameInUseCount;
      1760 } VmaPoolCreateInfo;
      1761 
      1764 typedef struct VmaPoolStats {
      1767  VkDeviceSize size;
      1770  VkDeviceSize unusedSize;
      1773  size_t allocationCount;
      1776  size_t unusedRangeCount;
      1783  VkDeviceSize unusedRangeSizeMax;
      1784 } VmaPoolStats;
      1785 
      1792 VkResult vmaCreatePool(
      1793  VmaAllocator allocator,
      1794  const VmaPoolCreateInfo* pCreateInfo,
      1795  VmaPool* pPool);
      1796 
      1799 void vmaDestroyPool(
      1800  VmaAllocator allocator,
      1801  VmaPool pool);
      1802 
      1809 void vmaGetPoolStats(
      1810  VmaAllocator allocator,
      1811  VmaPool pool,
      1812  VmaPoolStats* pPoolStats);
      1813 
      1820 void vmaMakePoolAllocationsLost(
      1821  VmaAllocator allocator,
      1822  VmaPool pool,
      1823  size_t* pLostAllocationCount);
      1824 
      1839 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
      1840 
      1865 VK_DEFINE_HANDLE(VmaAllocation)
      1866 
      1867 
      1869 typedef struct VmaAllocationInfo {
      1874  uint32_t memoryType;
      1883  VkDeviceMemory deviceMemory;
      1888  VkDeviceSize offset;
      1893  VkDeviceSize size;
      1902  void* pMappedData;
      1907  void* pUserData;
      1908 } VmaAllocationInfo;
      1909 
      1920 VkResult vmaAllocateMemory(
      1921  VmaAllocator allocator,
      1922  const VkMemoryRequirements* pVkMemoryRequirements,
      1923  const VmaAllocationCreateInfo* pCreateInfo,
      1924  VmaAllocation* pAllocation,
      1925  VmaAllocationInfo* pAllocationInfo);
      1926 
      1933 VkResult vmaAllocateMemoryForBuffer(
      1934  VmaAllocator allocator,
      1935  VkBuffer buffer,
      1936  const VmaAllocationCreateInfo* pCreateInfo,
      1937  VmaAllocation* pAllocation,
      1938  VmaAllocationInfo* pAllocationInfo);
      1939 
      1941 VkResult vmaAllocateMemoryForImage(
      1942  VmaAllocator allocator,
      1943  VkImage image,
      1944  const VmaAllocationCreateInfo* pCreateInfo,
      1945  VmaAllocation* pAllocation,
      1946  VmaAllocationInfo* pAllocationInfo);
      1947 
      1949 void vmaFreeMemory(
      1950  VmaAllocator allocator,
      1951  VmaAllocation allocation);
      1952 
      1969 void vmaGetAllocationInfo(
      1970  VmaAllocator allocator,
      1971  VmaAllocation allocation,
      1972  VmaAllocationInfo* pAllocationInfo);
      1973 
      1988 VkBool32 vmaTouchAllocation(
      1989  VmaAllocator allocator,
      1990  VmaAllocation allocation);
      1991 
      2005 void vmaSetAllocationUserData(
      2006  VmaAllocator allocator,
      2007  VmaAllocation allocation,
      2008  void* pUserData);
      2009 
      2020 void vmaCreateLostAllocation(
      2021  VmaAllocator allocator,
      2022  VmaAllocation* pAllocation);
      2023 
      2058 VkResult vmaMapMemory(
      2059  VmaAllocator allocator,
      2060  VmaAllocation allocation,
      2061  void** ppData);
      2062 
      2067 void vmaUnmapMemory(
      2068  VmaAllocator allocator,
      2069  VmaAllocation allocation);
      2070 
      2083 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      2084 
      2097 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      2098 
      2115 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
      2116 
      2118 typedef struct VmaDefragmentationInfo {
      2123  VkDeviceSize maxBytesToMove;
      2128  uint32_t maxAllocationsToMove;
      2129 } VmaDefragmentationInfo;
      2130 
      2132 typedef struct VmaDefragmentationStats {
      2134  VkDeviceSize bytesMoved;
      2136  VkDeviceSize bytesFreed;
      2138  uint32_t allocationsMoved;
      2140  uint32_t deviceMemoryBlocksFreed;
      2141 } VmaDefragmentationStats;
      2142 
      2225 VkResult vmaDefragment(
      2226  VmaAllocator allocator,
      2227  VmaAllocation* pAllocations,
      2228  size_t allocationCount,
      2229  VkBool32* pAllocationsChanged,
      2230  const VmaDefragmentationInfo *pDefragmentationInfo,
      2231  VmaDefragmentationStats* pDefragmentationStats);
      2232 
      2245 VkResult vmaBindBufferMemory(
      2246  VmaAllocator allocator,
      2247  VmaAllocation allocation,
      2248  VkBuffer buffer);
      2249 
      2262 VkResult vmaBindImageMemory(
      2263  VmaAllocator allocator,
      2264  VmaAllocation allocation,
      2265  VkImage image);
      2266 
      2293 VkResult vmaCreateBuffer(
      2294  VmaAllocator allocator,
      2295  const VkBufferCreateInfo* pBufferCreateInfo,
      2296  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      2297  VkBuffer* pBuffer,
      2298  VmaAllocation* pAllocation,
      2299  VmaAllocationInfo* pAllocationInfo);
      2300 
      2312 void vmaDestroyBuffer(
      2313  VmaAllocator allocator,
      2314  VkBuffer buffer,
      2315  VmaAllocation allocation);
      2316 
      2318 VkResult vmaCreateImage(
      2319  VmaAllocator allocator,
      2320  const VkImageCreateInfo* pImageCreateInfo,
      2321  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      2322  VkImage* pImage,
      2323  VmaAllocation* pAllocation,
      2324  VmaAllocationInfo* pAllocationInfo);
      2325 
      2337 void vmaDestroyImage(
      2338  VmaAllocator allocator,
      2339  VkImage image,
      2340  VmaAllocation allocation);
      2341 
      2342 #ifdef __cplusplus
      2343 }
      2344 #endif
      2345 
      2346 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
      2347 
      2348 // For Visual Studio IntelliSense.
      2349 #if defined(__cplusplus) && defined(__INTELLISENSE__)
      2350 #define VMA_IMPLEMENTATION
      2351 #endif
      2352 
      2353 #ifdef VMA_IMPLEMENTATION
      2354 #undef VMA_IMPLEMENTATION
      2355 
      2356 #include <cstdint>
      2357 #include <cstdlib>
      2358 #include <cstring>
      2359 
      2360 /*******************************************************************************
      2361 CONFIGURATION SECTION
      2362 
      2363 Define some of these macros before each #include of this header or change them
      2364 here if you need other then default behavior depending on your environment.
      2365 */
      2366 
      2367 /*
      2368 Define this macro to 1 to make the library fetch pointers to Vulkan functions
      2369 internally, like:
      2370 
      2371  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
      2372 
      2373 Define to 0 if you are going to provide you own pointers to Vulkan functions via
      2374 VmaAllocatorCreateInfo::pVulkanFunctions.
      2375 */
      2376 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
      2377 #define VMA_STATIC_VULKAN_FUNCTIONS 1
      2378 #endif
      2379 
      2380 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
      2381 //#define VMA_USE_STL_CONTAINERS 1
      2382 
      2383 /* Set this macro to 1 to make the library including and using STL containers:
      2384 std::pair, std::vector, std::list, std::unordered_map.
      2385 
      2386 Set it to 0 or undefined to make the library using its own implementation of
      2387 the containers.
      2388 */
      2389 #if VMA_USE_STL_CONTAINERS
      2390  #define VMA_USE_STL_VECTOR 1
      2391  #define VMA_USE_STL_UNORDERED_MAP 1
      2392  #define VMA_USE_STL_LIST 1
      2393 #endif
      2394 
      2395 #if VMA_USE_STL_VECTOR
      2396  #include <vector>
      2397 #endif
      2398 
      2399 #if VMA_USE_STL_UNORDERED_MAP
      2400  #include <unordered_map>
      2401 #endif
      2402 
      2403 #if VMA_USE_STL_LIST
      2404  #include <list>
      2405 #endif
      2406 
      2407 /*
      2408 Following headers are used in this CONFIGURATION section only, so feel free to
      2409 remove them if not needed.
      2410 */
      2411 #include <cassert> // for assert
      2412 #include <algorithm> // for min, max
      2413 #include <mutex> // for std::mutex
      2414 #include <atomic> // for std::atomic
      2415 
      2416 #ifndef VMA_NULL
      2417  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
      2418  #define VMA_NULL nullptr
      2419 #endif
      2420 
      2421 #if defined(__APPLE__) || defined(__ANDROID__)
      2422 #include <cstdlib>
      2423 void *aligned_alloc(size_t alignment, size_t size)
      2424 {
      2425  // alignment must be >= sizeof(void*)
      2426  if(alignment < sizeof(void*))
      2427  {
      2428  alignment = sizeof(void*);
      2429  }
      2430 
      2431  void *pointer;
      2432  if(posix_memalign(&pointer, alignment, size) == 0)
      2433  return pointer;
      2434  return VMA_NULL;
      2435 }
      2436 #endif
      2437 
      2438 // If your compiler is not compatible with C++11 and definition of
      2439 // aligned_alloc() function is missing, uncommeting following line may help:
      2440 
      2441 //#include <malloc.h>
      2442 
      2443 // Normal assert to check for programmer's errors, especially in Debug configuration.
      2444 #ifndef VMA_ASSERT
      2445  #ifdef _DEBUG
      2446  #define VMA_ASSERT(expr) assert(expr)
      2447  #else
      2448  #define VMA_ASSERT(expr)
      2449  #endif
      2450 #endif
      2451 
      2452 // Assert that will be called very often, like inside data structures e.g. operator[].
      2453 // Making it non-empty can make program slow.
      2454 #ifndef VMA_HEAVY_ASSERT
      2455  #ifdef _DEBUG
      2456  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
      2457  #else
      2458  #define VMA_HEAVY_ASSERT(expr)
      2459  #endif
      2460 #endif
      2461 
      2462 #ifndef VMA_ALIGN_OF
      2463  #define VMA_ALIGN_OF(type) (__alignof(type))
      2464 #endif
      2465 
      2466 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
      2467  #if defined(_WIN32)
      2468  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
      2469  #else
      2470  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
      2471  #endif
      2472 #endif
      2473 
      2474 #ifndef VMA_SYSTEM_FREE
      2475  #if defined(_WIN32)
      2476  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
      2477  #else
      2478  #define VMA_SYSTEM_FREE(ptr) free(ptr)
      2479  #endif
      2480 #endif
      2481 
      2482 #ifndef VMA_MIN
      2483  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
      2484 #endif
      2485 
      2486 #ifndef VMA_MAX
      2487  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
      2488 #endif
      2489 
      2490 #ifndef VMA_SWAP
      2491  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
      2492 #endif
      2493 
      2494 #ifndef VMA_SORT
      2495  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
      2496 #endif
      2497 
      2498 #ifndef VMA_DEBUG_LOG
      2499  #define VMA_DEBUG_LOG(format, ...)
      2500  /*
      2501  #define VMA_DEBUG_LOG(format, ...) do { \
      2502  printf(format, __VA_ARGS__); \
      2503  printf("\n"); \
      2504  } while(false)
      2505  */
      2506 #endif
      2507 
      2508 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
      2509 #if VMA_STATS_STRING_ENABLED
      2510  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
      2511  {
      2512  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
      2513  }
      2514  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
      2515  {
      2516  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
      2517  }
      2518  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
      2519  {
      2520  snprintf(outStr, strLen, "%p", ptr);
      2521  }
      2522 #endif
      2523 
      2524 #ifndef VMA_MUTEX
      2525  class VmaMutex
      2526  {
      2527  public:
      2528  VmaMutex() { }
      2529  ~VmaMutex() { }
      2530  void Lock() { m_Mutex.lock(); }
      2531  void Unlock() { m_Mutex.unlock(); }
      2532  private:
      2533  std::mutex m_Mutex;
      2534  };
      2535  #define VMA_MUTEX VmaMutex
      2536 #endif
      2537 
      2538 /*
      2539 If providing your own implementation, you need to implement a subset of std::atomic:
      2540 
      2541 - Constructor(uint32_t desired)
      2542 - uint32_t load() const
      2543 - void store(uint32_t desired)
      2544 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
      2545 */
      2546 #ifndef VMA_ATOMIC_UINT32
      2547  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
      2548 #endif
      2549 
      2550 #ifndef VMA_BEST_FIT
      2551 
      2563  #define VMA_BEST_FIT (1)
      2564 #endif
      2565 
      2566 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
      2567 
      2571  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
      2572 #endif
      2573 
      2574 #ifndef VMA_DEBUG_ALIGNMENT
      2575 
      2579  #define VMA_DEBUG_ALIGNMENT (1)
      2580 #endif
      2581 
      2582 #ifndef VMA_DEBUG_MARGIN
      2583 
      2587  #define VMA_DEBUG_MARGIN (0)
      2588 #endif
      2589 
      2590 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
      2591 
      2595  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
      2596 #endif
      2597 
      2598 #ifndef VMA_DEBUG_DETECT_CORRUPTION
      2599 
      2604  #define VMA_DEBUG_DETECT_CORRUPTION (0)
      2605 #endif
      2606 
      2607 #ifndef VMA_DEBUG_GLOBAL_MUTEX
      2608 
      2612  #define VMA_DEBUG_GLOBAL_MUTEX (0)
      2613 #endif
      2614 
      2615 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
      2616 
      2620  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
      2621 #endif
      2622 
      2623 #ifndef VMA_SMALL_HEAP_MAX_SIZE
      2624  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
      2626 #endif
      2627 
      2628 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
      2629  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
      2631 #endif
      2632 
      2633 #ifndef VMA_CLASS_NO_COPY
      2634  #define VMA_CLASS_NO_COPY(className) \
      2635  private: \
      2636  className(const className&) = delete; \
      2637  className& operator=(const className&) = delete;
      2638 #endif
      2639 
      2640 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
      2641 
      2642 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
      2643 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
      2644 
      2645 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
      2646 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
      2647 
      2648 /*******************************************************************************
      2649 END OF CONFIGURATION
      2650 */
      2651 
      2652 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
      2653  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
      2654 
      2655 // Returns number of bits set to 1 in (v).
      2656 static inline uint32_t VmaCountBitsSet(uint32_t v)
      2657 {
      2658  uint32_t c = v - ((v >> 1) & 0x55555555);
      2659  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
      2660  c = ((c >> 4) + c) & 0x0F0F0F0F;
      2661  c = ((c >> 8) + c) & 0x00FF00FF;
      2662  c = ((c >> 16) + c) & 0x0000FFFF;
      2663  return c;
      2664 }
      2665 
      2666 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
      2667 // Use types like uint32_t, uint64_t as T.
      2668 template <typename T>
      2669 static inline T VmaAlignUp(T val, T align)
      2670 {
      2671  return (val + align - 1) / align * align;
      2672 }
      2673 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
      2674 // Use types like uint32_t, uint64_t as T.
      2675 template <typename T>
      2676 static inline T VmaAlignDown(T val, T align)
      2677 {
      2678  return val / align * align;
      2679 }
      2680 
      2681 // Division with mathematical rounding to nearest number.
      2682 template <typename T>
      2683 inline T VmaRoundDiv(T x, T y)
      2684 {
      2685  return (x + (y / (T)2)) / y;
      2686 }
      2687 
      2688 #ifndef VMA_SORT
      2689 
      2690 template<typename Iterator, typename Compare>
      2691 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
      2692 {
      2693  Iterator centerValue = end; --centerValue;
      2694  Iterator insertIndex = beg;
      2695  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
      2696  {
      2697  if(cmp(*memTypeIndex, *centerValue))
      2698  {
      2699  if(insertIndex != memTypeIndex)
      2700  {
      2701  VMA_SWAP(*memTypeIndex, *insertIndex);
      2702  }
      2703  ++insertIndex;
      2704  }
      2705  }
      2706  if(insertIndex != centerValue)
      2707  {
      2708  VMA_SWAP(*insertIndex, *centerValue);
      2709  }
      2710  return insertIndex;
      2711 }
      2712 
      2713 template<typename Iterator, typename Compare>
      2714 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
      2715 {
      2716  if(beg < end)
      2717  {
      2718  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
      2719  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
      2720  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
      2721  }
      2722 }
      2723 
      2724 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
      2725 
      2726 #endif // #ifndef VMA_SORT
      2727 
      2728 /*
      2729 Returns true if two memory blocks occupy overlapping pages.
      2730 ResourceA must be in less memory offset than ResourceB.
      2731 
      2732 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
      2733 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
      2734 */
      2735 static inline bool VmaBlocksOnSamePage(
      2736  VkDeviceSize resourceAOffset,
      2737  VkDeviceSize resourceASize,
      2738  VkDeviceSize resourceBOffset,
      2739  VkDeviceSize pageSize)
      2740 {
      2741  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
      2742  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
      2743  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
      2744  VkDeviceSize resourceBStart = resourceBOffset;
      2745  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
      2746  return resourceAEndPage == resourceBStartPage;
      2747 }
      2748 
      2749 enum VmaSuballocationType
      2750 {
      2751  VMA_SUBALLOCATION_TYPE_FREE = 0,
      2752  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
      2753  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
      2754  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
      2755  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
      2756  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
      2757  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
      2758 };
      2759 
      2760 /*
      2761 Returns true if given suballocation types could conflict and must respect
      2762 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
      2763 or linear image and another one is optimal image. If type is unknown, behave
      2764 conservatively.
      2765 */
      2766 static inline bool VmaIsBufferImageGranularityConflict(
      2767  VmaSuballocationType suballocType1,
      2768  VmaSuballocationType suballocType2)
      2769 {
      2770  if(suballocType1 > suballocType2)
      2771  {
      2772  VMA_SWAP(suballocType1, suballocType2);
      2773  }
      2774 
      2775  switch(suballocType1)
      2776  {
      2777  case VMA_SUBALLOCATION_TYPE_FREE:
      2778  return false;
      2779  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
      2780  return true;
      2781  case VMA_SUBALLOCATION_TYPE_BUFFER:
      2782  return
      2783  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      2784  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      2785  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
      2786  return
      2787  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      2788  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
      2789  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      2790  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
      2791  return
      2792  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      2793  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
      2794  return false;
      2795  default:
      2796  VMA_ASSERT(0);
      2797  return true;
      2798  }
      2799 }
      2800 
      2801 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
      2802 {
      2803  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
      2804  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      2805  for(size_t i = 0; i < numberCount; ++i, ++pDst)
      2806  {
      2807  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
      2808  }
      2809 }
      2810 
      2811 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
      2812 {
      2813  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
      2814  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      2815  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
      2816  {
      2817  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
      2818  {
      2819  return false;
      2820  }
      2821  }
      2822  return true;
      2823 }
      2824 
      2825 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
      2826 struct VmaMutexLock
      2827 {
      2828  VMA_CLASS_NO_COPY(VmaMutexLock)
      2829 public:
      2830  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
      2831  m_pMutex(useMutex ? &mutex : VMA_NULL)
      2832  {
      2833  if(m_pMutex)
      2834  {
      2835  m_pMutex->Lock();
      2836  }
      2837  }
      2838 
      2839  ~VmaMutexLock()
      2840  {
      2841  if(m_pMutex)
      2842  {
      2843  m_pMutex->Unlock();
      2844  }
      2845  }
      2846 
      2847 private:
      2848  VMA_MUTEX* m_pMutex;
      2849 };
      2850 
      2851 #if VMA_DEBUG_GLOBAL_MUTEX
      2852  static VMA_MUTEX gDebugGlobalMutex;
      2853  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
      2854 #else
      2855  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
      2856 #endif
      2857 
      2858 // Minimum size of a free suballocation to register it in the free suballocation collection.
      2859 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
      2860 
      2861 /*
      2862 Performs binary search and returns iterator to first element that is greater or
      2863 equal to (key), according to comparison (cmp).
      2864 
      2865 Cmp should return true if first argument is less than second argument.
      2866 
      2867 Returned value is the found element, if present in the collection or place where
      2868 new element with value (key) should be inserted.
      2869 */
      2870 template <typename IterT, typename KeyT, typename CmpT>
      2871 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)
      2872 {
      2873  size_t down = 0, up = (end - beg);
      2874  while(down < up)
      2875  {
      2876  const size_t mid = (down + up) / 2;
      2877  if(cmp(*(beg+mid), key))
      2878  {
      2879  down = mid + 1;
      2880  }
      2881  else
      2882  {
      2883  up = mid;
      2884  }
      2885  }
      2886  return beg + down;
      2887 }
      2888 
      2890 // Memory allocation
      2891 
      2892 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
      2893 {
      2894  if((pAllocationCallbacks != VMA_NULL) &&
      2895  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
      2896  {
      2897  return (*pAllocationCallbacks->pfnAllocation)(
      2898  pAllocationCallbacks->pUserData,
      2899  size,
      2900  alignment,
      2901  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
      2902  }
      2903  else
      2904  {
      2905  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
      2906  }
      2907 }
      2908 
      2909 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
      2910 {
      2911  if((pAllocationCallbacks != VMA_NULL) &&
      2912  (pAllocationCallbacks->pfnFree != VMA_NULL))
      2913  {
      2914  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
      2915  }
      2916  else
      2917  {
      2918  VMA_SYSTEM_FREE(ptr);
      2919  }
      2920 }
      2921 
      2922 template<typename T>
      2923 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
      2924 {
      2925  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
      2926 }
      2927 
      2928 template<typename T>
      2929 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
      2930 {
      2931  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
      2932 }
      2933 
      2934 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
      2935 
      2936 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
      2937 
      2938 template<typename T>
      2939 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
      2940 {
      2941  ptr->~T();
      2942  VmaFree(pAllocationCallbacks, ptr);
      2943 }
      2944 
      2945 template<typename T>
      2946 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
      2947 {
      2948  if(ptr != VMA_NULL)
      2949  {
      2950  for(size_t i = count; i--; )
      2951  {
      2952  ptr[i].~T();
      2953  }
      2954  VmaFree(pAllocationCallbacks, ptr);
      2955  }
      2956 }
      2957 
      2958 // STL-compatible allocator.
      2959 template<typename T>
      2960 class VmaStlAllocator
      2961 {
      2962 public:
      2963  const VkAllocationCallbacks* const m_pCallbacks;
      2964  typedef T value_type;
      2965 
      2966  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
      2967  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
      2968 
      2969  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
      2970  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
      2971 
      2972  template<typename U>
      2973  bool operator==(const VmaStlAllocator<U>& rhs) const
      2974  {
      2975  return m_pCallbacks == rhs.m_pCallbacks;
      2976  }
      2977  template<typename U>
      2978  bool operator!=(const VmaStlAllocator<U>& rhs) const
      2979  {
      2980  return m_pCallbacks != rhs.m_pCallbacks;
      2981  }
      2982 
      2983  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
      2984 };
      2985 
      2986 #if VMA_USE_STL_VECTOR
      2987 
      2988 #define VmaVector std::vector
      2989 
      2990 template<typename T, typename allocatorT>
      2991 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
      2992 {
      2993  vec.insert(vec.begin() + index, item);
      2994 }
      2995 
      2996 template<typename T, typename allocatorT>
      2997 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
      2998 {
      2999  vec.erase(vec.begin() + index);
      3000 }
      3001 
      3002 #else // #if VMA_USE_STL_VECTOR
      3003 
      3004 /* Class with interface compatible with subset of std::vector.
      3005 T must be POD because constructors and destructors are not called and memcpy is
      3006 used for these objects. */
      3007 template<typename T, typename AllocatorT>
      3008 class VmaVector
      3009 {
      3010 public:
      3011  typedef T value_type;
      3012 
      3013  VmaVector(const AllocatorT& allocator) :
      3014  m_Allocator(allocator),
      3015  m_pArray(VMA_NULL),
      3016  m_Count(0),
      3017  m_Capacity(0)
      3018  {
      3019  }
      3020 
      3021  VmaVector(size_t count, const AllocatorT& allocator) :
      3022  m_Allocator(allocator),
      3023  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
      3024  m_Count(count),
      3025  m_Capacity(count)
      3026  {
      3027  }
      3028 
      3029  VmaVector(const VmaVector<T, AllocatorT>& src) :
      3030  m_Allocator(src.m_Allocator),
      3031  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
      3032  m_Count(src.m_Count),
      3033  m_Capacity(src.m_Count)
      3034  {
      3035  if(m_Count != 0)
      3036  {
      3037  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
      3038  }
      3039  }
      3040 
      3041  ~VmaVector()
      3042  {
      3043  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      3044  }
      3045 
      3046  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
      3047  {
      3048  if(&rhs != this)
      3049  {
      3050  resize(rhs.m_Count);
      3051  if(m_Count != 0)
      3052  {
      3053  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
      3054  }
      3055  }
      3056  return *this;
      3057  }
      3058 
      3059  bool empty() const { return m_Count == 0; }
      3060  size_t size() const { return m_Count; }
      3061  T* data() { return m_pArray; }
      3062  const T* data() const { return m_pArray; }
      3063 
      3064  T& operator[](size_t index)
      3065  {
      3066  VMA_HEAVY_ASSERT(index < m_Count);
      3067  return m_pArray[index];
      3068  }
      3069  const T& operator[](size_t index) const
      3070  {
      3071  VMA_HEAVY_ASSERT(index < m_Count);
      3072  return m_pArray[index];
      3073  }
      3074 
      3075  T& front()
      3076  {
      3077  VMA_HEAVY_ASSERT(m_Count > 0);
      3078  return m_pArray[0];
      3079  }
      3080  const T& front() const
      3081  {
      3082  VMA_HEAVY_ASSERT(m_Count > 0);
      3083  return m_pArray[0];
      3084  }
      3085  T& back()
      3086  {
      3087  VMA_HEAVY_ASSERT(m_Count > 0);
      3088  return m_pArray[m_Count - 1];
      3089  }
      3090  const T& back() const
      3091  {
      3092  VMA_HEAVY_ASSERT(m_Count > 0);
      3093  return m_pArray[m_Count - 1];
      3094  }
      3095 
      3096  void reserve(size_t newCapacity, bool freeMemory = false)
      3097  {
      3098  newCapacity = VMA_MAX(newCapacity, m_Count);
      3099 
      3100  if((newCapacity < m_Capacity) && !freeMemory)
      3101  {
      3102  newCapacity = m_Capacity;
      3103  }
      3104 
      3105  if(newCapacity != m_Capacity)
      3106  {
      3107  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
      3108  if(m_Count != 0)
      3109  {
      3110  memcpy(newArray, m_pArray, m_Count * sizeof(T));
      3111  }
      3112  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      3113  m_Capacity = newCapacity;
      3114  m_pArray = newArray;
      3115  }
      3116  }
      3117 
      3118  void resize(size_t newCount, bool freeMemory = false)
      3119  {
      3120  size_t newCapacity = m_Capacity;
      3121  if(newCount > m_Capacity)
      3122  {
      3123  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
      3124  }
      3125  else if(freeMemory)
      3126  {
      3127  newCapacity = newCount;
      3128  }
      3129 
      3130  if(newCapacity != m_Capacity)
      3131  {
      3132  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
      3133  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
      3134  if(elementsToCopy != 0)
      3135  {
      3136  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
      3137  }
      3138  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      3139  m_Capacity = newCapacity;
      3140  m_pArray = newArray;
      3141  }
      3142 
      3143  m_Count = newCount;
      3144  }
      3145 
      3146  void clear(bool freeMemory = false)
      3147  {
      3148  resize(0, freeMemory);
      3149  }
      3150 
      3151  void insert(size_t index, const T& src)
      3152  {
      3153  VMA_HEAVY_ASSERT(index <= m_Count);
      3154  const size_t oldCount = size();
      3155  resize(oldCount + 1);
      3156  if(index < oldCount)
      3157  {
      3158  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
      3159  }
      3160  m_pArray[index] = src;
      3161  }
      3162 
      3163  void remove(size_t index)
      3164  {
      3165  VMA_HEAVY_ASSERT(index < m_Count);
      3166  const size_t oldCount = size();
      3167  if(index < oldCount - 1)
      3168  {
      3169  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
      3170  }
      3171  resize(oldCount - 1);
      3172  }
      3173 
      3174  void push_back(const T& src)
      3175  {
      3176  const size_t newIndex = size();
      3177  resize(newIndex + 1);
      3178  m_pArray[newIndex] = src;
      3179  }
      3180 
      3181  void pop_back()
      3182  {
      3183  VMA_HEAVY_ASSERT(m_Count > 0);
      3184  resize(size() - 1);
      3185  }
      3186 
      3187  void push_front(const T& src)
      3188  {
      3189  insert(0, src);
      3190  }
      3191 
      3192  void pop_front()
      3193  {
      3194  VMA_HEAVY_ASSERT(m_Count > 0);
      3195  remove(0);
      3196  }
      3197 
      3198  typedef T* iterator;
      3199 
      3200  iterator begin() { return m_pArray; }
      3201  iterator end() { return m_pArray + m_Count; }
      3202 
      3203 private:
      3204  AllocatorT m_Allocator;
      3205  T* m_pArray;
      3206  size_t m_Count;
      3207  size_t m_Capacity;
      3208 };
      3209 
      3210 template<typename T, typename allocatorT>
      3211 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
      3212 {
      3213  vec.insert(index, item);
      3214 }
      3215 
      3216 template<typename T, typename allocatorT>
      3217 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
      3218 {
      3219  vec.remove(index);
      3220 }
      3221 
      3222 #endif // #if VMA_USE_STL_VECTOR
      3223 
      3224 template<typename CmpLess, typename VectorT>
      3225 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
      3226 {
      3227  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      3228  vector.data(),
      3229  vector.data() + vector.size(),
      3230  value,
      3231  CmpLess()) - vector.data();
      3232  VmaVectorInsert(vector, indexToInsert, value);
      3233  return indexToInsert;
      3234 }
      3235 
      3236 template<typename CmpLess, typename VectorT>
      3237 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
      3238 {
      3239  CmpLess comparator;
      3240  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
      3241  vector.begin(),
      3242  vector.end(),
      3243  value,
      3244  comparator);
      3245  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
      3246  {
      3247  size_t indexToRemove = it - vector.begin();
      3248  VmaVectorRemove(vector, indexToRemove);
      3249  return true;
      3250  }
      3251  return false;
      3252 }
      3253 
      3254 template<typename CmpLess, typename VectorT>
      3255 size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)
      3256 {
      3257  CmpLess comparator;
      3258  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
      3259  vector.data(),
      3260  vector.data() + vector.size(),
      3261  value,
      3262  comparator);
      3263  if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))
      3264  {
      3265  return it - vector.begin();
      3266  }
      3267  else
      3268  {
      3269  return vector.size();
      3270  }
      3271 }
      3272 
      3274 // class VmaPoolAllocator
      3275 
      3276 /*
      3277 Allocator for objects of type T using a list of arrays (pools) to speed up
      3278 allocation. Number of elements that can be allocated is not bounded because
      3279 allocator can create multiple blocks.
      3280 */
      3281 template<typename T>
      3282 class VmaPoolAllocator
      3283 {
      3284  VMA_CLASS_NO_COPY(VmaPoolAllocator)
      3285 public:
      3286  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
      3287  ~VmaPoolAllocator();
      3288  void Clear();
      3289  T* Alloc();
      3290  void Free(T* ptr);
      3291 
      3292 private:
      3293  union Item
      3294  {
      3295  uint32_t NextFreeIndex;
      3296  T Value;
      3297  };
      3298 
      3299  struct ItemBlock
      3300  {
      3301  Item* pItems;
      3302  uint32_t FirstFreeIndex;
      3303  };
      3304 
      3305  const VkAllocationCallbacks* m_pAllocationCallbacks;
      3306  size_t m_ItemsPerBlock;
      3307  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
      3308 
      3309  ItemBlock& CreateNewBlock();
      3310 };
      3311 
      3312 template<typename T>
      3313 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
      3314  m_pAllocationCallbacks(pAllocationCallbacks),
      3315  m_ItemsPerBlock(itemsPerBlock),
      3316  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
      3317 {
      3318  VMA_ASSERT(itemsPerBlock > 0);
      3319 }
      3320 
      3321 template<typename T>
      3322 VmaPoolAllocator<T>::~VmaPoolAllocator()
      3323 {
      3324  Clear();
      3325 }
      3326 
      3327 template<typename T>
      3328 void VmaPoolAllocator<T>::Clear()
      3329 {
      3330  for(size_t i = m_ItemBlocks.size(); i--; )
      3331  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
      3332  m_ItemBlocks.clear();
      3333 }
      3334 
      3335 template<typename T>
      3336 T* VmaPoolAllocator<T>::Alloc()
      3337 {
      3338  for(size_t i = m_ItemBlocks.size(); i--; )
      3339  {
      3340  ItemBlock& block = m_ItemBlocks[i];
      3341  // This block has some free items: Use first one.
      3342  if(block.FirstFreeIndex != UINT32_MAX)
      3343  {
      3344  Item* const pItem = &block.pItems[block.FirstFreeIndex];
      3345  block.FirstFreeIndex = pItem->NextFreeIndex;
      3346  return &pItem->Value;
      3347  }
      3348  }
      3349 
      3350  // No block has free item: Create new one and use it.
      3351  ItemBlock& newBlock = CreateNewBlock();
      3352  Item* const pItem = &newBlock.pItems[0];
      3353  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
      3354  return &pItem->Value;
      3355 }
      3356 
      3357 template<typename T>
      3358 void VmaPoolAllocator<T>::Free(T* ptr)
      3359 {
      3360  // Search all memory blocks to find ptr.
      3361  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
      3362  {
      3363  ItemBlock& block = m_ItemBlocks[i];
      3364 
      3365  // Casting to union.
      3366  Item* pItemPtr;
      3367  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
      3368 
      3369  // Check if pItemPtr is in address range of this block.
      3370  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
      3371  {
      3372  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
      3373  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
      3374  block.FirstFreeIndex = index;
      3375  return;
      3376  }
      3377  }
      3378  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
      3379 }
      3380 
      3381 template<typename T>
      3382 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
      3383 {
      3384  ItemBlock newBlock = {
      3385  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
      3386 
      3387  m_ItemBlocks.push_back(newBlock);
      3388 
      3389  // Setup singly-linked list of all free items in this block.
      3390  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
      3391  newBlock.pItems[i].NextFreeIndex = i + 1;
      3392  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
      3393  return m_ItemBlocks.back();
      3394 }
      3395 
      3397 // class VmaRawList, VmaList
      3398 
      3399 #if VMA_USE_STL_LIST
      3400 
      3401 #define VmaList std::list
      3402 
      3403 #else // #if VMA_USE_STL_LIST
      3404 
      3405 template<typename T>
      3406 struct VmaListItem
      3407 {
      3408  VmaListItem* pPrev;
      3409  VmaListItem* pNext;
      3410  T Value;
      3411 };
      3412 
      3413 // Doubly linked list.
      3414 template<typename T>
      3415 class VmaRawList
      3416 {
      3417  VMA_CLASS_NO_COPY(VmaRawList)
      3418 public:
      3419  typedef VmaListItem<T> ItemType;
      3420 
      3421  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
      3422  ~VmaRawList();
      3423  void Clear();
      3424 
      3425  size_t GetCount() const { return m_Count; }
      3426  bool IsEmpty() const { return m_Count == 0; }
      3427 
      3428  ItemType* Front() { return m_pFront; }
      3429  const ItemType* Front() const { return m_pFront; }
      3430  ItemType* Back() { return m_pBack; }
      3431  const ItemType* Back() const { return m_pBack; }
      3432 
      3433  ItemType* PushBack();
      3434  ItemType* PushFront();
      3435  ItemType* PushBack(const T& value);
      3436  ItemType* PushFront(const T& value);
      3437  void PopBack();
      3438  void PopFront();
      3439 
      3440  // Item can be null - it means PushBack.
      3441  ItemType* InsertBefore(ItemType* pItem);
      3442  // Item can be null - it means PushFront.
      3443  ItemType* InsertAfter(ItemType* pItem);
      3444 
      3445  ItemType* InsertBefore(ItemType* pItem, const T& value);
      3446  ItemType* InsertAfter(ItemType* pItem, const T& value);
      3447 
      3448  void Remove(ItemType* pItem);
      3449 
      3450 private:
      3451  const VkAllocationCallbacks* const m_pAllocationCallbacks;
      3452  VmaPoolAllocator<ItemType> m_ItemAllocator;
      3453  ItemType* m_pFront;
      3454  ItemType* m_pBack;
      3455  size_t m_Count;
      3456 };
      3457 
      3458 template<typename T>
      3459 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
      3460  m_pAllocationCallbacks(pAllocationCallbacks),
      3461  m_ItemAllocator(pAllocationCallbacks, 128),
      3462  m_pFront(VMA_NULL),
      3463  m_pBack(VMA_NULL),
      3464  m_Count(0)
      3465 {
      3466 }
      3467 
      3468 template<typename T>
      3469 VmaRawList<T>::~VmaRawList()
      3470 {
      3471  // Intentionally not calling Clear, because that would be unnecessary
      3472  // computations to return all items to m_ItemAllocator as free.
      3473 }
      3474 
      3475 template<typename T>
      3476 void VmaRawList<T>::Clear()
      3477 {
      3478  if(IsEmpty() == false)
      3479  {
      3480  ItemType* pItem = m_pBack;
      3481  while(pItem != VMA_NULL)
      3482  {
      3483  ItemType* const pPrevItem = pItem->pPrev;
      3484  m_ItemAllocator.Free(pItem);
      3485  pItem = pPrevItem;
      3486  }
      3487  m_pFront = VMA_NULL;
      3488  m_pBack = VMA_NULL;
      3489  m_Count = 0;
      3490  }
      3491 }
      3492 
      3493 template<typename T>
      3494 VmaListItem<T>* VmaRawList<T>::PushBack()
      3495 {
      3496  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      3497  pNewItem->pNext = VMA_NULL;
      3498  if(IsEmpty())
      3499  {
      3500  pNewItem->pPrev = VMA_NULL;
      3501  m_pFront = pNewItem;
      3502  m_pBack = pNewItem;
      3503  m_Count = 1;
      3504  }
      3505  else
      3506  {
      3507  pNewItem->pPrev = m_pBack;
      3508  m_pBack->pNext = pNewItem;
      3509  m_pBack = pNewItem;
      3510  ++m_Count;
      3511  }
      3512  return pNewItem;
      3513 }
      3514 
      3515 template<typename T>
      3516 VmaListItem<T>* VmaRawList<T>::PushFront()
      3517 {
      3518  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      3519  pNewItem->pPrev = VMA_NULL;
      3520  if(IsEmpty())
      3521  {
      3522  pNewItem->pNext = VMA_NULL;
      3523  m_pFront = pNewItem;
      3524  m_pBack = pNewItem;
      3525  m_Count = 1;
      3526  }
      3527  else
      3528  {
      3529  pNewItem->pNext = m_pFront;
      3530  m_pFront->pPrev = pNewItem;
      3531  m_pFront = pNewItem;
      3532  ++m_Count;
      3533  }
      3534  return pNewItem;
      3535 }
      3536 
      3537 template<typename T>
      3538 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
      3539 {
      3540  ItemType* const pNewItem = PushBack();
      3541  pNewItem->Value = value;
      3542  return pNewItem;
      3543 }
      3544 
      3545 template<typename T>
      3546 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
      3547 {
      3548  ItemType* const pNewItem = PushFront();
      3549  pNewItem->Value = value;
      3550  return pNewItem;
      3551 }
      3552 
      3553 template<typename T>
      3554 void VmaRawList<T>::PopBack()
      3555 {
      3556  VMA_HEAVY_ASSERT(m_Count > 0);
      3557  ItemType* const pBackItem = m_pBack;
      3558  ItemType* const pPrevItem = pBackItem->pPrev;
      3559  if(pPrevItem != VMA_NULL)
      3560  {
      3561  pPrevItem->pNext = VMA_NULL;
      3562  }
      3563  m_pBack = pPrevItem;
      3564  m_ItemAllocator.Free(pBackItem);
      3565  --m_Count;
      3566 }
      3567 
      3568 template<typename T>
      3569 void VmaRawList<T>::PopFront()
      3570 {
      3571  VMA_HEAVY_ASSERT(m_Count > 0);
      3572  ItemType* const pFrontItem = m_pFront;
      3573  ItemType* const pNextItem = pFrontItem->pNext;
      3574  if(pNextItem != VMA_NULL)
      3575  {
      3576  pNextItem->pPrev = VMA_NULL;
      3577  }
      3578  m_pFront = pNextItem;
      3579  m_ItemAllocator.Free(pFrontItem);
      3580  --m_Count;
      3581 }
      3582 
      3583 template<typename T>
      3584 void VmaRawList<T>::Remove(ItemType* pItem)
      3585 {
      3586  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
      3587  VMA_HEAVY_ASSERT(m_Count > 0);
      3588 
      3589  if(pItem->pPrev != VMA_NULL)
      3590  {
      3591  pItem->pPrev->pNext = pItem->pNext;
      3592  }
      3593  else
      3594  {
      3595  VMA_HEAVY_ASSERT(m_pFront == pItem);
      3596  m_pFront = pItem->pNext;
      3597  }
      3598 
      3599  if(pItem->pNext != VMA_NULL)
      3600  {
      3601  pItem->pNext->pPrev = pItem->pPrev;
      3602  }
      3603  else
      3604  {
      3605  VMA_HEAVY_ASSERT(m_pBack == pItem);
      3606  m_pBack = pItem->pPrev;
      3607  }
      3608 
      3609  m_ItemAllocator.Free(pItem);
      3610  --m_Count;
      3611 }
      3612 
      3613 template<typename T>
      3614 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
      3615 {
      3616  if(pItem != VMA_NULL)
      3617  {
      3618  ItemType* const prevItem = pItem->pPrev;
      3619  ItemType* const newItem = m_ItemAllocator.Alloc();
      3620  newItem->pPrev = prevItem;
      3621  newItem->pNext = pItem;
      3622  pItem->pPrev = newItem;
      3623  if(prevItem != VMA_NULL)
      3624  {
      3625  prevItem->pNext = newItem;
      3626  }
      3627  else
      3628  {
      3629  VMA_HEAVY_ASSERT(m_pFront == pItem);
      3630  m_pFront = newItem;
      3631  }
      3632  ++m_Count;
      3633  return newItem;
      3634  }
      3635  else
      3636  return PushBack();
      3637 }
      3638 
      3639 template<typename T>
      3640 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
      3641 {
      3642  if(pItem != VMA_NULL)
      3643  {
      3644  ItemType* const nextItem = pItem->pNext;
      3645  ItemType* const newItem = m_ItemAllocator.Alloc();
      3646  newItem->pNext = nextItem;
      3647  newItem->pPrev = pItem;
      3648  pItem->pNext = newItem;
      3649  if(nextItem != VMA_NULL)
      3650  {
      3651  nextItem->pPrev = newItem;
      3652  }
      3653  else
      3654  {
      3655  VMA_HEAVY_ASSERT(m_pBack == pItem);
      3656  m_pBack = newItem;
      3657  }
      3658  ++m_Count;
      3659  return newItem;
      3660  }
      3661  else
      3662  return PushFront();
      3663 }
      3664 
      3665 template<typename T>
      3666 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
      3667 {
      3668  ItemType* const newItem = InsertBefore(pItem);
      3669  newItem->Value = value;
      3670  return newItem;
      3671 }
      3672 
      3673 template<typename T>
      3674 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
      3675 {
      3676  ItemType* const newItem = InsertAfter(pItem);
      3677  newItem->Value = value;
      3678  return newItem;
      3679 }
      3680 
      3681 template<typename T, typename AllocatorT>
      3682 class VmaList
      3683 {
      3684  VMA_CLASS_NO_COPY(VmaList)
      3685 public:
      3686  class iterator
      3687  {
      3688  public:
      3689  iterator() :
      3690  m_pList(VMA_NULL),
      3691  m_pItem(VMA_NULL)
      3692  {
      3693  }
      3694 
      3695  T& operator*() const
      3696  {
      3697  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3698  return m_pItem->Value;
      3699  }
      3700  T* operator->() const
      3701  {
      3702  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3703  return &m_pItem->Value;
      3704  }
      3705 
      3706  iterator& operator++()
      3707  {
      3708  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3709  m_pItem = m_pItem->pNext;
      3710  return *this;
      3711  }
      3712  iterator& operator--()
      3713  {
      3714  if(m_pItem != VMA_NULL)
      3715  {
      3716  m_pItem = m_pItem->pPrev;
      3717  }
      3718  else
      3719  {
      3720  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      3721  m_pItem = m_pList->Back();
      3722  }
      3723  return *this;
      3724  }
      3725 
      3726  iterator operator++(int)
      3727  {
      3728  iterator result = *this;
      3729  ++*this;
      3730  return result;
      3731  }
      3732  iterator operator--(int)
      3733  {
      3734  iterator result = *this;
      3735  --*this;
      3736  return result;
      3737  }
      3738 
      3739  bool operator==(const iterator& rhs) const
      3740  {
      3741  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3742  return m_pItem == rhs.m_pItem;
      3743  }
      3744  bool operator!=(const iterator& rhs) const
      3745  {
      3746  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3747  return m_pItem != rhs.m_pItem;
      3748  }
      3749 
      3750  private:
      3751  VmaRawList<T>* m_pList;
      3752  VmaListItem<T>* m_pItem;
      3753 
      3754  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
      3755  m_pList(pList),
      3756  m_pItem(pItem)
      3757  {
      3758  }
      3759 
      3760  friend class VmaList<T, AllocatorT>;
      3761  };
      3762 
      3763  class const_iterator
      3764  {
      3765  public:
      3766  const_iterator() :
      3767  m_pList(VMA_NULL),
      3768  m_pItem(VMA_NULL)
      3769  {
      3770  }
      3771 
      3772  const_iterator(const iterator& src) :
      3773  m_pList(src.m_pList),
      3774  m_pItem(src.m_pItem)
      3775  {
      3776  }
      3777 
      3778  const T& operator*() const
      3779  {
      3780  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3781  return m_pItem->Value;
      3782  }
      3783  const T* operator->() const
      3784  {
      3785  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3786  return &m_pItem->Value;
      3787  }
      3788 
      3789  const_iterator& operator++()
      3790  {
      3791  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3792  m_pItem = m_pItem->pNext;
      3793  return *this;
      3794  }
      3795  const_iterator& operator--()
      3796  {
      3797  if(m_pItem != VMA_NULL)
      3798  {
      3799  m_pItem = m_pItem->pPrev;
      3800  }
      3801  else
      3802  {
      3803  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      3804  m_pItem = m_pList->Back();
      3805  }
      3806  return *this;
      3807  }
      3808 
      3809  const_iterator operator++(int)
      3810  {
      3811  const_iterator result = *this;
      3812  ++*this;
      3813  return result;
      3814  }
      3815  const_iterator operator--(int)
      3816  {
      3817  const_iterator result = *this;
      3818  --*this;
      3819  return result;
      3820  }
      3821 
      3822  bool operator==(const const_iterator& rhs) const
      3823  {
      3824  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3825  return m_pItem == rhs.m_pItem;
      3826  }
      3827  bool operator!=(const const_iterator& rhs) const
      3828  {
      3829  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3830  return m_pItem != rhs.m_pItem;
      3831  }
      3832 
      3833  private:
      3834  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
      3835  m_pList(pList),
      3836  m_pItem(pItem)
      3837  {
      3838  }
      3839 
      3840  const VmaRawList<T>* m_pList;
      3841  const VmaListItem<T>* m_pItem;
      3842 
      3843  friend class VmaList<T, AllocatorT>;
      3844  };
      3845 
      3846  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
      3847 
      3848  bool empty() const { return m_RawList.IsEmpty(); }
      3849  size_t size() const { return m_RawList.GetCount(); }
      3850 
      3851  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
      3852  iterator end() { return iterator(&m_RawList, VMA_NULL); }
      3853 
      3854  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
      3855  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
      3856 
      3857  void clear() { m_RawList.Clear(); }
      3858  void push_back(const T& value) { m_RawList.PushBack(value); }
      3859  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
      3860  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
      3861 
      3862 private:
      3863  VmaRawList<T> m_RawList;
      3864 };
      3865 
      3866 #endif // #if VMA_USE_STL_LIST
      3867 
      3869 // class VmaMap
      3870 
      3871 // Unused in this version.
      3872 #if 0
      3873 
      3874 #if VMA_USE_STL_UNORDERED_MAP
      3875 
      3876 #define VmaPair std::pair
      3877 
      3878 #define VMA_MAP_TYPE(KeyT, ValueT) \
      3879  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
      3880 
      3881 #else // #if VMA_USE_STL_UNORDERED_MAP
      3882 
      3883 template<typename T1, typename T2>
      3884 struct VmaPair
      3885 {
      3886  T1 first;
      3887  T2 second;
      3888 
      3889  VmaPair() : first(), second() { }
      3890  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
      3891 };
      3892 
      3893 /* Class compatible with subset of interface of std::unordered_map.
      3894 KeyT, ValueT must be POD because they will be stored in VmaVector.
      3895 */
      3896 template<typename KeyT, typename ValueT>
      3897 class VmaMap
      3898 {
      3899 public:
      3900  typedef VmaPair<KeyT, ValueT> PairType;
      3901  typedef PairType* iterator;
      3902 
      3903  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
      3904 
      3905  iterator begin() { return m_Vector.begin(); }
      3906  iterator end() { return m_Vector.end(); }
      3907 
      3908  void insert(const PairType& pair);
      3909  iterator find(const KeyT& key);
      3910  void erase(iterator it);
      3911 
      3912 private:
      3913  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
      3914 };
      3915 
      3916 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
      3917 
      3918 template<typename FirstT, typename SecondT>
      3919 struct VmaPairFirstLess
      3920 {
      3921  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
      3922  {
      3923  return lhs.first < rhs.first;
      3924  }
      3925  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
      3926  {
      3927  return lhs.first < rhsFirst;
      3928  }
      3929 };
      3930 
      3931 template<typename KeyT, typename ValueT>
      3932 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
      3933 {
      3934  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      3935  m_Vector.data(),
      3936  m_Vector.data() + m_Vector.size(),
      3937  pair,
      3938  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
      3939  VmaVectorInsert(m_Vector, indexToInsert, pair);
      3940 }
      3941 
      3942 template<typename KeyT, typename ValueT>
      3943 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
      3944 {
      3945  PairType* it = VmaBinaryFindFirstNotLess(
      3946  m_Vector.data(),
      3947  m_Vector.data() + m_Vector.size(),
      3948  key,
      3949  VmaPairFirstLess<KeyT, ValueT>());
      3950  if((it != m_Vector.end()) && (it->first == key))
      3951  {
      3952  return it;
      3953  }
      3954  else
      3955  {
      3956  return m_Vector.end();
      3957  }
      3958 }
      3959 
      3960 template<typename KeyT, typename ValueT>
      3961 void VmaMap<KeyT, ValueT>::erase(iterator it)
      3962 {
      3963  VmaVectorRemove(m_Vector, it - m_Vector.begin());
      3964 }
      3965 
      3966 #endif // #if VMA_USE_STL_UNORDERED_MAP
      3967 
      3968 #endif // #if 0
      3969 
      3971 
      3972 class VmaDeviceMemoryBlock;
      3973 
      3974 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
      3975 
      3976 struct VmaAllocation_T
      3977 {
      3978  VMA_CLASS_NO_COPY(VmaAllocation_T)
      3979 private:
      3980  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
      3981 
      3982  enum FLAGS
      3983  {
      3984  FLAG_USER_DATA_STRING = 0x01,
      3985  };
      3986 
      3987 public:
      3988  enum ALLOCATION_TYPE
      3989  {
      3990  ALLOCATION_TYPE_NONE,
      3991  ALLOCATION_TYPE_BLOCK,
      3992  ALLOCATION_TYPE_DEDICATED,
      3993  };
      3994 
      3995  VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
      3996  m_Alignment(1),
      3997  m_Size(0),
      3998  m_pUserData(VMA_NULL),
      3999  m_LastUseFrameIndex(currentFrameIndex),
      4000  m_Type((uint8_t)ALLOCATION_TYPE_NONE),
      4001  m_SuballocationType((uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN),
      4002  m_MapCount(0),
      4003  m_Flags(userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0)
      4004  {
      4005 #if VMA_STATS_STRING_ENABLED
      4006  m_CreationFrameIndex = currentFrameIndex;
      4007  m_BufferImageUsage = 0;
      4008 #endif
      4009  }
      4010 
      4011  ~VmaAllocation_T()
      4012  {
      4013  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
      4014 
      4015  // Check if owned string was freed.
      4016  VMA_ASSERT(m_pUserData == VMA_NULL);
      4017  }
      4018 
      4019  void InitBlockAllocation(
      4020  VmaPool hPool,
      4021  VmaDeviceMemoryBlock* block,
      4022  VkDeviceSize offset,
      4023  VkDeviceSize alignment,
      4024  VkDeviceSize size,
      4025  VmaSuballocationType suballocationType,
      4026  bool mapped,
      4027  bool canBecomeLost)
      4028  {
      4029  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      4030  VMA_ASSERT(block != VMA_NULL);
      4031  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      4032  m_Alignment = alignment;
      4033  m_Size = size;
      4034  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      4035  m_SuballocationType = (uint8_t)suballocationType;
      4036  m_BlockAllocation.m_hPool = hPool;
      4037  m_BlockAllocation.m_Block = block;
      4038  m_BlockAllocation.m_Offset = offset;
      4039  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
      4040  }
      4041 
      4042  void InitLost()
      4043  {
      4044  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      4045  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
      4046  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      4047  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
      4048  m_BlockAllocation.m_Block = VMA_NULL;
      4049  m_BlockAllocation.m_Offset = 0;
      4050  m_BlockAllocation.m_CanBecomeLost = true;
      4051  }
      4052 
      4053  void ChangeBlockAllocation(
      4054  VmaAllocator hAllocator,
      4055  VmaDeviceMemoryBlock* block,
      4056  VkDeviceSize offset);
      4057 
      4058  // pMappedData not null means allocation is created with MAPPED flag.
      4059  void InitDedicatedAllocation(
      4060  uint32_t memoryTypeIndex,
      4061  VkDeviceMemory hMemory,
      4062  VmaSuballocationType suballocationType,
      4063  void* pMappedData,
      4064  VkDeviceSize size)
      4065  {
      4066  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      4067  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
      4068  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
      4069  m_Alignment = 0;
      4070  m_Size = size;
      4071  m_SuballocationType = (uint8_t)suballocationType;
      4072  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      4073  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
      4074  m_DedicatedAllocation.m_hMemory = hMemory;
      4075  m_DedicatedAllocation.m_pMappedData = pMappedData;
      4076  }
      4077 
      4078  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
      4079  VkDeviceSize GetAlignment() const { return m_Alignment; }
      4080  VkDeviceSize GetSize() const { return m_Size; }
      4081  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
      4082  void* GetUserData() const { return m_pUserData; }
      4083  void SetUserData(VmaAllocator hAllocator, void* pUserData);
      4084  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
      4085 
      4086  VmaDeviceMemoryBlock* GetBlock() const
      4087  {
      4088  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      4089  return m_BlockAllocation.m_Block;
      4090  }
      4091  VkDeviceSize GetOffset() const;
      4092  VkDeviceMemory GetMemory() const;
      4093  uint32_t GetMemoryTypeIndex() const;
      4094  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
      4095  void* GetMappedData() const;
      4096  bool CanBecomeLost() const;
      4097  VmaPool GetPool() const;
      4098 
      4099  uint32_t GetLastUseFrameIndex() const
      4100  {
      4101  return m_LastUseFrameIndex.load();
      4102  }
      4103  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
      4104  {
      4105  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
      4106  }
      4107  /*
      4108  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
      4109  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
      4110  - Else, returns false.
      4111 
      4112  If hAllocation is already lost, assert - you should not call it then.
      4113  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
      4114  */
      4115  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      4116 
      4117  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
      4118  {
      4119  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
      4120  outInfo.blockCount = 1;
      4121  outInfo.allocationCount = 1;
      4122  outInfo.unusedRangeCount = 0;
      4123  outInfo.usedBytes = m_Size;
      4124  outInfo.unusedBytes = 0;
      4125  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
      4126  outInfo.unusedRangeSizeMin = UINT64_MAX;
      4127  outInfo.unusedRangeSizeMax = 0;
      4128  }
      4129 
      4130  void BlockAllocMap();
      4131  void BlockAllocUnmap();
      4132  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
      4133  void DedicatedAllocUnmap(VmaAllocator hAllocator);
      4134 
      4135 #if VMA_STATS_STRING_ENABLED
      4136  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
      4137  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
      4138 
      4139  void InitBufferImageUsage(uint32_t bufferImageUsage)
      4140  {
      4141  VMA_ASSERT(m_BufferImageUsage == 0);
      4142  m_BufferImageUsage = bufferImageUsage;
      4143  }
      4144 
      4145  void PrintParameters(class VmaJsonWriter& json) const;
      4146 #endif
      4147 
      4148 private:
      4149  VkDeviceSize m_Alignment;
      4150  VkDeviceSize m_Size;
      4151  void* m_pUserData;
      4152  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
      4153  uint8_t m_Type; // ALLOCATION_TYPE
      4154  uint8_t m_SuballocationType; // VmaSuballocationType
      4155  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
      4156  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
      4157  uint8_t m_MapCount;
      4158  uint8_t m_Flags; // enum FLAGS
      4159 
      4160  // Allocation out of VmaDeviceMemoryBlock.
      4161  struct BlockAllocation
      4162  {
      4163  VmaPool m_hPool; // Null if belongs to general memory.
      4164  VmaDeviceMemoryBlock* m_Block;
      4165  VkDeviceSize m_Offset;
      4166  bool m_CanBecomeLost;
      4167  };
      4168 
      4169  // Allocation for an object that has its own private VkDeviceMemory.
      4170  struct DedicatedAllocation
      4171  {
      4172  uint32_t m_MemoryTypeIndex;
      4173  VkDeviceMemory m_hMemory;
      4174  void* m_pMappedData; // Not null means memory is mapped.
      4175  };
      4176 
      4177  union
      4178  {
      4179  // Allocation out of VmaDeviceMemoryBlock.
      4180  BlockAllocation m_BlockAllocation;
      4181  // Allocation for an object that has its own private VkDeviceMemory.
      4182  DedicatedAllocation m_DedicatedAllocation;
      4183  };
      4184 
      4185 #if VMA_STATS_STRING_ENABLED
      4186  uint32_t m_CreationFrameIndex;
      4187  uint32_t m_BufferImageUsage; // 0 if unknown.
      4188 #endif
      4189 
      4190  void FreeUserDataString(VmaAllocator hAllocator);
      4191 };
      4192 
      4193 /*
      4194 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
      4195 allocated memory block or free.
      4196 */
      4197 struct VmaSuballocation
      4198 {
      4199  VkDeviceSize offset;
      4200  VkDeviceSize size;
      4201  VmaAllocation hAllocation;
      4202  VmaSuballocationType type;
      4203 };
      4204 
      4205 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
      4206 
      4207 // Cost of one additional allocation lost, as equivalent in bytes.
      4208 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
      4209 
      4210 /*
      4211 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
      4212 
      4213 If canMakeOtherLost was false:
      4214 - item points to a FREE suballocation.
      4215 - itemsToMakeLostCount is 0.
      4216 
      4217 If canMakeOtherLost was true:
      4218 - item points to first of sequence of suballocations, which are either FREE,
      4219  or point to VmaAllocations that can become lost.
      4220 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
      4221  the requested allocation to succeed.
      4222 */
      4223 struct VmaAllocationRequest
      4224 {
      4225  VkDeviceSize offset;
      4226  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
      4227  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
      4228  VmaSuballocationList::iterator item;
      4229  size_t itemsToMakeLostCount;
      4230 
      4231  VkDeviceSize CalcCost() const
      4232  {
      4233  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
      4234  }
      4235 };
      4236 
      4237 /*
      4238 Data structure used for bookkeeping of allocations and unused ranges of memory
      4239 in a single VkDeviceMemory block.
      4240 */
      4241 class VmaBlockMetadata
      4242 {
      4243  VMA_CLASS_NO_COPY(VmaBlockMetadata)
      4244 public:
      4245  VmaBlockMetadata(VmaAllocator hAllocator);
      4246  ~VmaBlockMetadata();
      4247  void Init(VkDeviceSize size);
      4248 
      4249  // Validates all data structures inside this object. If not valid, returns false.
      4250  bool Validate() const;
      4251  VkDeviceSize GetSize() const { return m_Size; }
      4252  size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
      4253  VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
      4254  VkDeviceSize GetUnusedRangeSizeMax() const;
      4255  // Returns true if this block is empty - contains only single free suballocation.
      4256  bool IsEmpty() const;
      4257 
      4258  void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      4259  void AddPoolStats(VmaPoolStats& inoutStats) const;
      4260 
      4261 #if VMA_STATS_STRING_ENABLED
      4262  void PrintDetailedMap(class VmaJsonWriter& json) const;
      4263 #endif
      4264 
      4265  // Tries to find a place for suballocation with given parameters inside this block.
      4266  // If succeeded, fills pAllocationRequest and returns true.
      4267  // If failed, returns false.
      4268  bool CreateAllocationRequest(
      4269  uint32_t currentFrameIndex,
      4270  uint32_t frameInUseCount,
      4271  VkDeviceSize bufferImageGranularity,
      4272  VkDeviceSize allocSize,
      4273  VkDeviceSize allocAlignment,
      4274  VmaSuballocationType allocType,
      4275  bool canMakeOtherLost,
      4276  VmaAllocationRequest* pAllocationRequest);
      4277 
      4278  bool MakeRequestedAllocationsLost(
      4279  uint32_t currentFrameIndex,
      4280  uint32_t frameInUseCount,
      4281  VmaAllocationRequest* pAllocationRequest);
      4282 
      4283  uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      4284 
      4285  VkResult CheckCorruption(const void* pBlockData);
      4286 
      4287  // Makes actual allocation based on request. Request must already be checked and valid.
      4288  void Alloc(
      4289  const VmaAllocationRequest& request,
      4290  VmaSuballocationType type,
      4291  VkDeviceSize allocSize,
      4292  VmaAllocation hAllocation);
      4293 
      4294  // Frees suballocation assigned to given memory region.
      4295  void Free(const VmaAllocation allocation);
      4296  void FreeAtOffset(VkDeviceSize offset);
      4297 
      4298 private:
      4299  VkDeviceSize m_Size;
      4300  uint32_t m_FreeCount;
      4301  VkDeviceSize m_SumFreeSize;
      4302  VmaSuballocationList m_Suballocations;
      4303  // Suballocations that are free and have size greater than certain threshold.
      4304  // Sorted by size, ascending.
      4305  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
      4306 
      4307  bool ValidateFreeSuballocationList() const;
      4308 
      4309  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
      4310  // If yes, fills pOffset and returns true. If no, returns false.
      4311  bool CheckAllocation(
      4312  uint32_t currentFrameIndex,
      4313  uint32_t frameInUseCount,
      4314  VkDeviceSize bufferImageGranularity,
      4315  VkDeviceSize allocSize,
      4316  VkDeviceSize allocAlignment,
      4317  VmaSuballocationType allocType,
      4318  VmaSuballocationList::const_iterator suballocItem,
      4319  bool canMakeOtherLost,
      4320  VkDeviceSize* pOffset,
      4321  size_t* itemsToMakeLostCount,
      4322  VkDeviceSize* pSumFreeSize,
      4323  VkDeviceSize* pSumItemSize) const;
      4324  // Given free suballocation, it merges it with following one, which must also be free.
      4325  void MergeFreeWithNext(VmaSuballocationList::iterator item);
      4326  // Releases given suballocation, making it free.
      4327  // Merges it with adjacent free suballocations if applicable.
      4328  // Returns iterator to new free suballocation at this place.
      4329  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
      4330  // Given free suballocation, it inserts it into sorted list of
      4331  // m_FreeSuballocationsBySize if it's suitable.
      4332  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
      4333  // Given free suballocation, it removes it from sorted list of
      4334  // m_FreeSuballocationsBySize if it's suitable.
      4335  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
      4336 };
      4337 
      4338 /*
      4339 Represents a single block of device memory (`VkDeviceMemory`) with all the
      4340 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
      4341 
      4342 Thread-safety: This class must be externally synchronized.
      4343 */
      4344 class VmaDeviceMemoryBlock
      4345 {
      4346  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
      4347 public:
      4348  VmaBlockMetadata m_Metadata;
      4349 
      4350  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
      4351 
      4352  ~VmaDeviceMemoryBlock()
      4353  {
      4354  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
      4355  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      4356  }
      4357 
      4358  // Always call after construction.
      4359  void Init(
      4360  uint32_t newMemoryTypeIndex,
      4361  VkDeviceMemory newMemory,
      4362  VkDeviceSize newSize,
      4363  uint32_t id);
      4364  // Always call before destruction.
      4365  void Destroy(VmaAllocator allocator);
      4366 
      4367  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
      4368  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      4369  uint32_t GetId() const { return m_Id; }
      4370  void* GetMappedData() const { return m_pMappedData; }
      4371 
      4372  // Validates all data structures inside this object. If not valid, returns false.
      4373  bool Validate() const;
      4374 
      4375  VkResult CheckCorruption(VmaAllocator hAllocator);
      4376 
      4377  // ppData can be null.
      4378  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
      4379  void Unmap(VmaAllocator hAllocator, uint32_t count);
      4380 
      4381  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      4382  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      4383 
      4384  VkResult BindBufferMemory(
      4385  const VmaAllocator hAllocator,
      4386  const VmaAllocation hAllocation,
      4387  VkBuffer hBuffer);
      4388  VkResult BindImageMemory(
      4389  const VmaAllocator hAllocator,
      4390  const VmaAllocation hAllocation,
      4391  VkImage hImage);
      4392 
      4393 private:
      4394  uint32_t m_MemoryTypeIndex;
      4395  uint32_t m_Id;
      4396  VkDeviceMemory m_hMemory;
      4397 
      4398  // Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
      4399  // Also protects m_MapCount, m_pMappedData.
      4400  VMA_MUTEX m_Mutex;
      4401  uint32_t m_MapCount;
      4402  void* m_pMappedData;
      4403 };
      4404 
      4405 struct VmaPointerLess
      4406 {
      4407  bool operator()(const void* lhs, const void* rhs) const
      4408  {
      4409  return lhs < rhs;
      4410  }
      4411 };
      4412 
      4413 class VmaDefragmentator;
      4414 
      4415 /*
      4416 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
      4417 Vulkan memory type.
      4418 
      4419 Synchronized internally with a mutex.
      4420 */
      4421 struct VmaBlockVector
      4422 {
      4423  VMA_CLASS_NO_COPY(VmaBlockVector)
      4424 public:
      4425  VmaBlockVector(
      4426  VmaAllocator hAllocator,
      4427  uint32_t memoryTypeIndex,
      4428  VkDeviceSize preferredBlockSize,
      4429  size_t minBlockCount,
      4430  size_t maxBlockCount,
      4431  VkDeviceSize bufferImageGranularity,
      4432  uint32_t frameInUseCount,
      4433  bool isCustomPool);
      4434  ~VmaBlockVector();
      4435 
      4436  VkResult CreateMinBlocks();
      4437 
      4438  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      4439  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
      4440  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
      4441  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
      4442 
      4443  void GetPoolStats(VmaPoolStats* pStats);
      4444 
      4445  bool IsEmpty() const { return m_Blocks.empty(); }
      4446  bool IsCorruptionDetectionEnabled() const;
      4447 
      4448  VkResult Allocate(
      4449  VmaPool hCurrentPool,
      4450  uint32_t currentFrameIndex,
      4451  VkDeviceSize size,
      4452  VkDeviceSize alignment,
      4453  const VmaAllocationCreateInfo& createInfo,
      4454  VmaSuballocationType suballocType,
      4455  VmaAllocation* pAllocation);
      4456 
      4457  void Free(
      4458  VmaAllocation hAllocation);
      4459 
      4460  // Adds statistics of this BlockVector to pStats.
      4461  void AddStats(VmaStats* pStats);
      4462 
      4463 #if VMA_STATS_STRING_ENABLED
      4464  void PrintDetailedMap(class VmaJsonWriter& json);
      4465 #endif
      4466 
      4467  void MakePoolAllocationsLost(
      4468  uint32_t currentFrameIndex,
      4469  size_t* pLostAllocationCount);
      4470  VkResult CheckCorruption();
      4471 
      4472  VmaDefragmentator* EnsureDefragmentator(
      4473  VmaAllocator hAllocator,
      4474  uint32_t currentFrameIndex);
      4475 
      4476  VkResult Defragment(
      4477  VmaDefragmentationStats* pDefragmentationStats,
      4478  VkDeviceSize& maxBytesToMove,
      4479  uint32_t& maxAllocationsToMove);
      4480 
      4481  void DestroyDefragmentator();
      4482 
      4483 private:
      4484  friend class VmaDefragmentator;
      4485 
      4486  const VmaAllocator m_hAllocator;
      4487  const uint32_t m_MemoryTypeIndex;
      4488  const VkDeviceSize m_PreferredBlockSize;
      4489  const size_t m_MinBlockCount;
      4490  const size_t m_MaxBlockCount;
      4491  const VkDeviceSize m_BufferImageGranularity;
      4492  const uint32_t m_FrameInUseCount;
      4493  const bool m_IsCustomPool;
      4494  VMA_MUTEX m_Mutex;
      4495  // Incrementally sorted by sumFreeSize, ascending.
      4496  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
      4497  /* There can be at most one allocation that is completely empty - a
      4498  hysteresis to avoid pessimistic case of alternating creation and destruction
      4499  of a VkDeviceMemory. */
      4500  bool m_HasEmptyBlock;
      4501  VmaDefragmentator* m_pDefragmentator;
      4502  uint32_t m_NextBlockId;
      4503 
      4504  VkDeviceSize CalcMaxBlockSize() const;
      4505 
      4506  // Finds and removes given block from vector.
      4507  void Remove(VmaDeviceMemoryBlock* pBlock);
      4508 
      4509  // Performs single step in sorting m_Blocks. They may not be fully sorted
      4510  // after this call.
      4511  void IncrementallySortBlocks();
      4512 
      4513  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
      4514 };
      4515 
      4516 struct VmaPool_T
      4517 {
      4518  VMA_CLASS_NO_COPY(VmaPool_T)
      4519 public:
      4520  VmaBlockVector m_BlockVector;
      4521 
      4522  VmaPool_T(
      4523  VmaAllocator hAllocator,
      4524  const VmaPoolCreateInfo& createInfo);
      4525  ~VmaPool_T();
      4526 
      4527  VmaBlockVector& GetBlockVector() { return m_BlockVector; }
      4528  uint32_t GetId() const { return m_Id; }
      4529  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
      4530 
      4531 #if VMA_STATS_STRING_ENABLED
      4532  //void PrintDetailedMap(class VmaStringBuilder& sb);
      4533 #endif
      4534 
      4535 private:
      4536  uint32_t m_Id;
      4537 };
      4538 
      4539 class VmaDefragmentator
      4540 {
      4541  VMA_CLASS_NO_COPY(VmaDefragmentator)
      4542 private:
      4543  const VmaAllocator m_hAllocator;
      4544  VmaBlockVector* const m_pBlockVector;
      4545  uint32_t m_CurrentFrameIndex;
      4546  VkDeviceSize m_BytesMoved;
      4547  uint32_t m_AllocationsMoved;
      4548 
      4549  struct AllocationInfo
      4550  {
      4551  VmaAllocation m_hAllocation;
      4552  VkBool32* m_pChanged;
      4553 
      4554  AllocationInfo() :
      4555  m_hAllocation(VK_NULL_HANDLE),
      4556  m_pChanged(VMA_NULL)
      4557  {
      4558  }
      4559  };
      4560 
      4561  struct AllocationInfoSizeGreater
      4562  {
      4563  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
      4564  {
      4565  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
      4566  }
      4567  };
      4568 
      4569  // Used between AddAllocation and Defragment.
      4570  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
      4571 
      4572  struct BlockInfo
      4573  {
      4574  VmaDeviceMemoryBlock* m_pBlock;
      4575  bool m_HasNonMovableAllocations;
      4576  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
      4577 
      4578  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
      4579  m_pBlock(VMA_NULL),
      4580  m_HasNonMovableAllocations(true),
      4581  m_Allocations(pAllocationCallbacks),
      4582  m_pMappedDataForDefragmentation(VMA_NULL)
      4583  {
      4584  }
      4585 
      4586  void CalcHasNonMovableAllocations()
      4587  {
      4588  const size_t blockAllocCount = m_pBlock->m_Metadata.GetAllocationCount();
      4589  const size_t defragmentAllocCount = m_Allocations.size();
      4590  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
      4591  }
      4592 
      4593  void SortAllocationsBySizeDescecnding()
      4594  {
      4595  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
      4596  }
      4597 
      4598  VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);
      4599  void Unmap(VmaAllocator hAllocator);
      4600 
      4601  private:
      4602  // Not null if mapped for defragmentation only, not originally mapped.
      4603  void* m_pMappedDataForDefragmentation;
      4604  };
      4605 
      4606  struct BlockPointerLess
      4607  {
      4608  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
      4609  {
      4610  return pLhsBlockInfo->m_pBlock < pRhsBlock;
      4611  }
      4612  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      4613  {
      4614  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
      4615  }
      4616  };
      4617 
      4618  // 1. Blocks with some non-movable allocations go first.
      4619  // 2. Blocks with smaller sumFreeSize go first.
      4620  struct BlockInfoCompareMoveDestination
      4621  {
      4622  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      4623  {
      4624  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
      4625  {
      4626  return true;
      4627  }
      4628  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
      4629  {
      4630  return false;
      4631  }
      4632  if(pLhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize())
      4633  {
      4634  return true;
      4635  }
      4636  return false;
      4637  }
      4638  };
      4639 
      4640  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
      4641  BlockInfoVector m_Blocks;
      4642 
      4643  VkResult DefragmentRound(
      4644  VkDeviceSize maxBytesToMove,
      4645  uint32_t maxAllocationsToMove);
      4646 
      4647  static bool MoveMakesSense(
      4648  size_t dstBlockIndex, VkDeviceSize dstOffset,
      4649  size_t srcBlockIndex, VkDeviceSize srcOffset);
      4650 
      4651 public:
      4652  VmaDefragmentator(
      4653  VmaAllocator hAllocator,
      4654  VmaBlockVector* pBlockVector,
      4655  uint32_t currentFrameIndex);
      4656 
      4657  ~VmaDefragmentator();
      4658 
      4659  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
      4660  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
      4661 
      4662  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
      4663 
      4664  VkResult Defragment(
      4665  VkDeviceSize maxBytesToMove,
      4666  uint32_t maxAllocationsToMove);
      4667 };
      4668 
      4669 // Main allocator object.
      4670 struct VmaAllocator_T
      4671 {
      4672  VMA_CLASS_NO_COPY(VmaAllocator_T)
      4673 public:
      4674  bool m_UseMutex;
      4675  bool m_UseKhrDedicatedAllocation;
      4676  VkDevice m_hDevice;
      4677  bool m_AllocationCallbacksSpecified;
      4678  VkAllocationCallbacks m_AllocationCallbacks;
      4679  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
      4680 
      4681  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
      4682  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
      4683  VMA_MUTEX m_HeapSizeLimitMutex;
      4684 
      4685  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
      4686  VkPhysicalDeviceMemoryProperties m_MemProps;
      4687 
      4688  // Default pools.
      4689  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
      4690 
      4691  // Each vector is sorted by memory (handle value).
      4692  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
      4693  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
      4694  VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
      4695 
      4696  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
      4697  ~VmaAllocator_T();
      4698 
      4699  const VkAllocationCallbacks* GetAllocationCallbacks() const
      4700  {
      4701  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
      4702  }
      4703  const VmaVulkanFunctions& GetVulkanFunctions() const
      4704  {
      4705  return m_VulkanFunctions;
      4706  }
      4707 
      4708  VkDeviceSize GetBufferImageGranularity() const
      4709  {
      4710  return VMA_MAX(
      4711  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
      4712  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
      4713  }
      4714 
      4715  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
      4716  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
      4717 
      4718  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
      4719  {
      4720  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
      4721  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
      4722  }
      4723  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
      4724  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
      4725  {
      4726  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
      4727  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      4728  }
      4729  // Minimum alignment for all allocations in specific memory type.
      4730  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
      4731  {
      4732  return IsMemoryTypeNonCoherent(memTypeIndex) ?
      4733  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
      4734  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
      4735  }
      4736 
      4737  bool IsIntegratedGpu() const
      4738  {
      4739  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
      4740  }
      4741 
      4742  void GetBufferMemoryRequirements(
      4743  VkBuffer hBuffer,
      4744  VkMemoryRequirements& memReq,
      4745  bool& requiresDedicatedAllocation,
      4746  bool& prefersDedicatedAllocation) const;
      4747  void GetImageMemoryRequirements(
      4748  VkImage hImage,
      4749  VkMemoryRequirements& memReq,
      4750  bool& requiresDedicatedAllocation,
      4751  bool& prefersDedicatedAllocation) const;
      4752 
      4753  // Main allocation function.
      4754  VkResult AllocateMemory(
      4755  const VkMemoryRequirements& vkMemReq,
      4756  bool requiresDedicatedAllocation,
      4757  bool prefersDedicatedAllocation,
      4758  VkBuffer dedicatedBuffer,
      4759  VkImage dedicatedImage,
      4760  const VmaAllocationCreateInfo& createInfo,
      4761  VmaSuballocationType suballocType,
      4762  VmaAllocation* pAllocation);
      4763 
      4764  // Main deallocation function.
      4765  void FreeMemory(const VmaAllocation allocation);
      4766 
      4767  void CalculateStats(VmaStats* pStats);
      4768 
      4769 #if VMA_STATS_STRING_ENABLED
      4770  void PrintDetailedMap(class VmaJsonWriter& json);
      4771 #endif
      4772 
      4773  VkResult Defragment(
      4774  VmaAllocation* pAllocations,
      4775  size_t allocationCount,
      4776  VkBool32* pAllocationsChanged,
      4777  const VmaDefragmentationInfo* pDefragmentationInfo,
      4778  VmaDefragmentationStats* pDefragmentationStats);
      4779 
      4780  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
      4781  bool TouchAllocation(VmaAllocation hAllocation);
      4782 
      4783  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
      4784  void DestroyPool(VmaPool pool);
      4785  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
      4786 
      4787  void SetCurrentFrameIndex(uint32_t frameIndex);
      4788 
      4789  void MakePoolAllocationsLost(
      4790  VmaPool hPool,
      4791  size_t* pLostAllocationCount);
      4792  VkResult CheckPoolCorruption(VmaPool hPool);
      4793  VkResult CheckCorruption(uint32_t memoryTypeBits);
      4794 
      4795  void CreateLostAllocation(VmaAllocation* pAllocation);
      4796 
      4797  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
      4798  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
      4799 
      4800  VkResult Map(VmaAllocation hAllocation, void** ppData);
      4801  void Unmap(VmaAllocation hAllocation);
      4802 
      4803  VkResult BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer);
      4804  VkResult BindImageMemory(VmaAllocation hAllocation, VkImage hImage);
      4805 
      4806  void FlushOrInvalidateAllocation(
      4807  VmaAllocation hAllocation,
      4808  VkDeviceSize offset, VkDeviceSize size,
      4809  VMA_CACHE_OPERATION op);
      4810 
      4811  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
      4812 
      4813 private:
      4814  VkDeviceSize m_PreferredLargeHeapBlockSize;
      4815 
      4816  VkPhysicalDevice m_PhysicalDevice;
      4817  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
      4818 
      4819  VMA_MUTEX m_PoolsMutex;
      4820  // Protected by m_PoolsMutex. Sorted by pointer value.
      4821  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
      4822  uint32_t m_NextPoolId;
      4823 
      4824  VmaVulkanFunctions m_VulkanFunctions;
      4825 
      4826  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
      4827 
      4828  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
      4829 
      4830  VkResult AllocateMemoryOfType(
      4831  VkDeviceSize size,
      4832  VkDeviceSize alignment,
      4833  bool dedicatedAllocation,
      4834  VkBuffer dedicatedBuffer,
      4835  VkImage dedicatedImage,
      4836  const VmaAllocationCreateInfo& createInfo,
      4837  uint32_t memTypeIndex,
      4838  VmaSuballocationType suballocType,
      4839  VmaAllocation* pAllocation);
      4840 
      4841  // Allocates and registers new VkDeviceMemory specifically for single allocation.
      4842  VkResult AllocateDedicatedMemory(
      4843  VkDeviceSize size,
      4844  VmaSuballocationType suballocType,
      4845  uint32_t memTypeIndex,
      4846  bool map,
      4847  bool isUserDataString,
      4848  void* pUserData,
      4849  VkBuffer dedicatedBuffer,
      4850  VkImage dedicatedImage,
      4851  VmaAllocation* pAllocation);
      4852 
      4853  // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.
      4854  void FreeDedicatedMemory(VmaAllocation allocation);
      4855 };
      4856 
      4858 // Memory allocation #2 after VmaAllocator_T definition
      4859 
      4860 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
      4861 {
      4862  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
      4863 }
      4864 
      4865 static void VmaFree(VmaAllocator hAllocator, void* ptr)
      4866 {
      4867  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
      4868 }
      4869 
      4870 template<typename T>
      4871 static T* VmaAllocate(VmaAllocator hAllocator)
      4872 {
      4873  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
      4874 }
      4875 
      4876 template<typename T>
      4877 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
      4878 {
      4879  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
      4880 }
      4881 
      4882 template<typename T>
      4883 static void vma_delete(VmaAllocator hAllocator, T* ptr)
      4884 {
      4885  if(ptr != VMA_NULL)
      4886  {
      4887  ptr->~T();
      4888  VmaFree(hAllocator, ptr);
      4889  }
      4890 }
      4891 
      4892 template<typename T>
      4893 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
      4894 {
      4895  if(ptr != VMA_NULL)
      4896  {
      4897  for(size_t i = count; i--; )
      4898  ptr[i].~T();
      4899  VmaFree(hAllocator, ptr);
      4900  }
      4901 }
      4902 
      4904 // VmaStringBuilder
      4905 
      4906 #if VMA_STATS_STRING_ENABLED
      4907 
      4908 class VmaStringBuilder
      4909 {
      4910 public:
      4911  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
      4912  size_t GetLength() const { return m_Data.size(); }
      4913  const char* GetData() const { return m_Data.data(); }
      4914 
      4915  void Add(char ch) { m_Data.push_back(ch); }
      4916  void Add(const char* pStr);
      4917  void AddNewLine() { Add('\n'); }
      4918  void AddNumber(uint32_t num);
      4919  void AddNumber(uint64_t num);
      4920  void AddPointer(const void* ptr);
      4921 
      4922 private:
      4923  VmaVector< char, VmaStlAllocator<char> > m_Data;
      4924 };
      4925 
      4926 void VmaStringBuilder::Add(const char* pStr)
      4927 {
      4928  const size_t strLen = strlen(pStr);
      4929  if(strLen > 0)
      4930  {
      4931  const size_t oldCount = m_Data.size();
      4932  m_Data.resize(oldCount + strLen);
      4933  memcpy(m_Data.data() + oldCount, pStr, strLen);
      4934  }
      4935 }
      4936 
      4937 void VmaStringBuilder::AddNumber(uint32_t num)
      4938 {
      4939  char buf[11];
      4940  VmaUint32ToStr(buf, sizeof(buf), num);
      4941  Add(buf);
      4942 }
      4943 
      4944 void VmaStringBuilder::AddNumber(uint64_t num)
      4945 {
      4946  char buf[21];
      4947  VmaUint64ToStr(buf, sizeof(buf), num);
      4948  Add(buf);
      4949 }
      4950 
      4951 void VmaStringBuilder::AddPointer(const void* ptr)
      4952 {
      4953  char buf[21];
      4954  VmaPtrToStr(buf, sizeof(buf), ptr);
      4955  Add(buf);
      4956 }
      4957 
      4958 #endif // #if VMA_STATS_STRING_ENABLED
      4959 
      4961 // VmaJsonWriter
      4962 
      4963 #if VMA_STATS_STRING_ENABLED
      4964 
      4965 class VmaJsonWriter
      4966 {
      4967  VMA_CLASS_NO_COPY(VmaJsonWriter)
      4968 public:
      4969  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
      4970  ~VmaJsonWriter();
      4971 
      4972  void BeginObject(bool singleLine = false);
      4973  void EndObject();
      4974 
      4975  void BeginArray(bool singleLine = false);
      4976  void EndArray();
      4977 
      4978  void WriteString(const char* pStr);
      4979  void BeginString(const char* pStr = VMA_NULL);
      4980  void ContinueString(const char* pStr);
      4981  void ContinueString(uint32_t n);
      4982  void ContinueString(uint64_t n);
      4983  void ContinueString_Pointer(const void* ptr);
      4984  void EndString(const char* pStr = VMA_NULL);
      4985 
      4986  void WriteNumber(uint32_t n);
      4987  void WriteNumber(uint64_t n);
      4988  void WriteBool(bool b);
      4989  void WriteNull();
      4990 
      4991 private:
      4992  static const char* const INDENT;
      4993 
      4994  enum COLLECTION_TYPE
      4995  {
      4996  COLLECTION_TYPE_OBJECT,
      4997  COLLECTION_TYPE_ARRAY,
      4998  };
      4999  struct StackItem
      5000  {
      5001  COLLECTION_TYPE type;
      5002  uint32_t valueCount;
      5003  bool singleLineMode;
      5004  };
      5005 
      5006  VmaStringBuilder& m_SB;
      5007  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
      5008  bool m_InsideString;
      5009 
      5010  void BeginValue(bool isString);
      5011  void WriteIndent(bool oneLess = false);
      5012 };
      5013 
      5014 const char* const VmaJsonWriter::INDENT = " ";
      5015 
      5016 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
      5017  m_SB(sb),
      5018  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
      5019  m_InsideString(false)
      5020 {
      5021 }
      5022 
      5023 VmaJsonWriter::~VmaJsonWriter()
      5024 {
      5025  VMA_ASSERT(!m_InsideString);
      5026  VMA_ASSERT(m_Stack.empty());
      5027 }
      5028 
      5029 void VmaJsonWriter::BeginObject(bool singleLine)
      5030 {
      5031  VMA_ASSERT(!m_InsideString);
      5032 
      5033  BeginValue(false);
      5034  m_SB.Add('{');
      5035 
      5036  StackItem item;
      5037  item.type = COLLECTION_TYPE_OBJECT;
      5038  item.valueCount = 0;
      5039  item.singleLineMode = singleLine;
      5040  m_Stack.push_back(item);
      5041 }
      5042 
      5043 void VmaJsonWriter::EndObject()
      5044 {
      5045  VMA_ASSERT(!m_InsideString);
      5046 
      5047  WriteIndent(true);
      5048  m_SB.Add('}');
      5049 
      5050  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
      5051  m_Stack.pop_back();
      5052 }
      5053 
      5054 void VmaJsonWriter::BeginArray(bool singleLine)
      5055 {
      5056  VMA_ASSERT(!m_InsideString);
      5057 
      5058  BeginValue(false);
      5059  m_SB.Add('[');
      5060 
      5061  StackItem item;
      5062  item.type = COLLECTION_TYPE_ARRAY;
      5063  item.valueCount = 0;
      5064  item.singleLineMode = singleLine;
      5065  m_Stack.push_back(item);
      5066 }
      5067 
      5068 void VmaJsonWriter::EndArray()
      5069 {
      5070  VMA_ASSERT(!m_InsideString);
      5071 
      5072  WriteIndent(true);
      5073  m_SB.Add(']');
      5074 
      5075  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
      5076  m_Stack.pop_back();
      5077 }
      5078 
      5079 void VmaJsonWriter::WriteString(const char* pStr)
      5080 {
      5081  BeginString(pStr);
      5082  EndString();
      5083 }
      5084 
      5085 void VmaJsonWriter::BeginString(const char* pStr)
      5086 {
      5087  VMA_ASSERT(!m_InsideString);
      5088 
      5089  BeginValue(true);
      5090  m_SB.Add('"');
      5091  m_InsideString = true;
      5092  if(pStr != VMA_NULL && pStr[0] != '\0')
      5093  {
      5094  ContinueString(pStr);
      5095  }
      5096 }
      5097 
      5098 void VmaJsonWriter::ContinueString(const char* pStr)
      5099 {
      5100  VMA_ASSERT(m_InsideString);
      5101 
      5102  const size_t strLen = strlen(pStr);
      5103  for(size_t i = 0; i < strLen; ++i)
      5104  {
      5105  char ch = pStr[i];
      5106  if(ch == '\'')
      5107  {
      5108  m_SB.Add("\\\\");
      5109  }
      5110  else if(ch == '"')
      5111  {
      5112  m_SB.Add("\\\"");
      5113  }
      5114  else if(ch >= 32)
      5115  {
      5116  m_SB.Add(ch);
      5117  }
      5118  else switch(ch)
      5119  {
      5120  case '\b':
      5121  m_SB.Add("\\b");
      5122  break;
      5123  case '\f':
      5124  m_SB.Add("\\f");
      5125  break;
      5126  case '\n':
      5127  m_SB.Add("\\n");
      5128  break;
      5129  case '\r':
      5130  m_SB.Add("\\r");
      5131  break;
      5132  case '\t':
      5133  m_SB.Add("\\t");
      5134  break;
      5135  default:
      5136  VMA_ASSERT(0 && "Character not currently supported.");
      5137  break;
      5138  }
      5139  }
      5140 }
      5141 
      5142 void VmaJsonWriter::ContinueString(uint32_t n)
      5143 {
      5144  VMA_ASSERT(m_InsideString);
      5145  m_SB.AddNumber(n);
      5146 }
      5147 
      5148 void VmaJsonWriter::ContinueString(uint64_t n)
      5149 {
      5150  VMA_ASSERT(m_InsideString);
      5151  m_SB.AddNumber(n);
      5152 }
      5153 
      5154 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
      5155 {
      5156  VMA_ASSERT(m_InsideString);
      5157  m_SB.AddPointer(ptr);
      5158 }
      5159 
      5160 void VmaJsonWriter::EndString(const char* pStr)
      5161 {
      5162  VMA_ASSERT(m_InsideString);
      5163  if(pStr != VMA_NULL && pStr[0] != '\0')
      5164  {
      5165  ContinueString(pStr);
      5166  }
      5167  m_SB.Add('"');
      5168  m_InsideString = false;
      5169 }
      5170 
      5171 void VmaJsonWriter::WriteNumber(uint32_t n)
      5172 {
      5173  VMA_ASSERT(!m_InsideString);
      5174  BeginValue(false);
      5175  m_SB.AddNumber(n);
      5176 }
      5177 
      5178 void VmaJsonWriter::WriteNumber(uint64_t n)
      5179 {
      5180  VMA_ASSERT(!m_InsideString);
      5181  BeginValue(false);
      5182  m_SB.AddNumber(n);
      5183 }
      5184 
      5185 void VmaJsonWriter::WriteBool(bool b)
      5186 {
      5187  VMA_ASSERT(!m_InsideString);
      5188  BeginValue(false);
      5189  m_SB.Add(b ? "true" : "false");
      5190 }
      5191 
      5192 void VmaJsonWriter::WriteNull()
      5193 {
      5194  VMA_ASSERT(!m_InsideString);
      5195  BeginValue(false);
      5196  m_SB.Add("null");
      5197 }
      5198 
      5199 void VmaJsonWriter::BeginValue(bool isString)
      5200 {
      5201  if(!m_Stack.empty())
      5202  {
      5203  StackItem& currItem = m_Stack.back();
      5204  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      5205  currItem.valueCount % 2 == 0)
      5206  {
      5207  VMA_ASSERT(isString);
      5208  }
      5209 
      5210  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      5211  currItem.valueCount % 2 != 0)
      5212  {
      5213  m_SB.Add(": ");
      5214  }
      5215  else if(currItem.valueCount > 0)
      5216  {
      5217  m_SB.Add(", ");
      5218  WriteIndent();
      5219  }
      5220  else
      5221  {
      5222  WriteIndent();
      5223  }
      5224  ++currItem.valueCount;
      5225  }
      5226 }
      5227 
      5228 void VmaJsonWriter::WriteIndent(bool oneLess)
      5229 {
      5230  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
      5231  {
      5232  m_SB.AddNewLine();
      5233 
      5234  size_t count = m_Stack.size();
      5235  if(count > 0 && oneLess)
      5236  {
      5237  --count;
      5238  }
      5239  for(size_t i = 0; i < count; ++i)
      5240  {
      5241  m_SB.Add(INDENT);
      5242  }
      5243  }
      5244 }
      5245 
      5246 #endif // #if VMA_STATS_STRING_ENABLED
      5247 
      5249 
      5250 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
      5251 {
      5252  if(IsUserDataString())
      5253  {
      5254  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
      5255 
      5256  FreeUserDataString(hAllocator);
      5257 
      5258  if(pUserData != VMA_NULL)
      5259  {
      5260  const char* const newStrSrc = (char*)pUserData;
      5261  const size_t newStrLen = strlen(newStrSrc);
      5262  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
      5263  memcpy(newStrDst, newStrSrc, newStrLen + 1);
      5264  m_pUserData = newStrDst;
      5265  }
      5266  }
      5267  else
      5268  {
      5269  m_pUserData = pUserData;
      5270  }
      5271 }
      5272 
      5273 void VmaAllocation_T::ChangeBlockAllocation(
      5274  VmaAllocator hAllocator,
      5275  VmaDeviceMemoryBlock* block,
      5276  VkDeviceSize offset)
      5277 {
      5278  VMA_ASSERT(block != VMA_NULL);
      5279  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      5280 
      5281  // Move mapping reference counter from old block to new block.
      5282  if(block != m_BlockAllocation.m_Block)
      5283  {
      5284  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
      5285  if(IsPersistentMap())
      5286  ++mapRefCount;
      5287  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
      5288  block->Map(hAllocator, mapRefCount, VMA_NULL);
      5289  }
      5290 
      5291  m_BlockAllocation.m_Block = block;
      5292  m_BlockAllocation.m_Offset = offset;
      5293 }
      5294 
      5295 VkDeviceSize VmaAllocation_T::GetOffset() const
      5296 {
      5297  switch(m_Type)
      5298  {
      5299  case ALLOCATION_TYPE_BLOCK:
      5300  return m_BlockAllocation.m_Offset;
      5301  case ALLOCATION_TYPE_DEDICATED:
      5302  return 0;
      5303  default:
      5304  VMA_ASSERT(0);
      5305  return 0;
      5306  }
      5307 }
      5308 
      5309 VkDeviceMemory VmaAllocation_T::GetMemory() const
      5310 {
      5311  switch(m_Type)
      5312  {
      5313  case ALLOCATION_TYPE_BLOCK:
      5314  return m_BlockAllocation.m_Block->GetDeviceMemory();
      5315  case ALLOCATION_TYPE_DEDICATED:
      5316  return m_DedicatedAllocation.m_hMemory;
      5317  default:
      5318  VMA_ASSERT(0);
      5319  return VK_NULL_HANDLE;
      5320  }
      5321 }
      5322 
      5323 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
      5324 {
      5325  switch(m_Type)
      5326  {
      5327  case ALLOCATION_TYPE_BLOCK:
      5328  return m_BlockAllocation.m_Block->GetMemoryTypeIndex();
      5329  case ALLOCATION_TYPE_DEDICATED:
      5330  return m_DedicatedAllocation.m_MemoryTypeIndex;
      5331  default:
      5332  VMA_ASSERT(0);
      5333  return UINT32_MAX;
      5334  }
      5335 }
      5336 
      5337 void* VmaAllocation_T::GetMappedData() const
      5338 {
      5339  switch(m_Type)
      5340  {
      5341  case ALLOCATION_TYPE_BLOCK:
      5342  if(m_MapCount != 0)
      5343  {
      5344  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
      5345  VMA_ASSERT(pBlockData != VMA_NULL);
      5346  return (char*)pBlockData + m_BlockAllocation.m_Offset;
      5347  }
      5348  else
      5349  {
      5350  return VMA_NULL;
      5351  }
      5352  break;
      5353  case ALLOCATION_TYPE_DEDICATED:
      5354  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
      5355  return m_DedicatedAllocation.m_pMappedData;
      5356  default:
      5357  VMA_ASSERT(0);
      5358  return VMA_NULL;
      5359  }
      5360 }
      5361 
      5362 bool VmaAllocation_T::CanBecomeLost() const
      5363 {
      5364  switch(m_Type)
      5365  {
      5366  case ALLOCATION_TYPE_BLOCK:
      5367  return m_BlockAllocation.m_CanBecomeLost;
      5368  case ALLOCATION_TYPE_DEDICATED:
      5369  return false;
      5370  default:
      5371  VMA_ASSERT(0);
      5372  return false;
      5373  }
      5374 }
      5375 
      5376 VmaPool VmaAllocation_T::GetPool() const
      5377 {
      5378  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      5379  return m_BlockAllocation.m_hPool;
      5380 }
      5381 
      5382 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      5383 {
      5384  VMA_ASSERT(CanBecomeLost());
      5385 
      5386  /*
      5387  Warning: This is a carefully designed algorithm.
      5388  Do not modify unless you really know what you're doing :)
      5389  */
      5390  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
      5391  for(;;)
      5392  {
      5393  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      5394  {
      5395  VMA_ASSERT(0);
      5396  return false;
      5397  }
      5398  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
      5399  {
      5400  return false;
      5401  }
      5402  else // Last use time earlier than current time.
      5403  {
      5404  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
      5405  {
      5406  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
      5407  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
      5408  return true;
      5409  }
      5410  }
      5411  }
      5412 }
      5413 
      5414 #if VMA_STATS_STRING_ENABLED
      5415 
      5416 // Correspond to values of enum VmaSuballocationType.
      5417 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
      5418  "FREE",
      5419  "UNKNOWN",
      5420  "BUFFER",
      5421  "IMAGE_UNKNOWN",
      5422  "IMAGE_LINEAR",
      5423  "IMAGE_OPTIMAL",
      5424 };
      5425 
      5426 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
      5427 {
      5428  json.WriteString("Type");
      5429  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
      5430 
      5431  json.WriteString("Size");
      5432  json.WriteNumber(m_Size);
      5433 
      5434  if(m_pUserData != VMA_NULL)
      5435  {
      5436  json.WriteString("UserData");
      5437  if(IsUserDataString())
      5438  {
      5439  json.WriteString((const char*)m_pUserData);
      5440  }
      5441  else
      5442  {
      5443  json.BeginString();
      5444  json.ContinueString_Pointer(m_pUserData);
      5445  json.EndString();
      5446  }
      5447  }
      5448 
      5449  json.WriteString("CreationFrameIndex");
      5450  json.WriteNumber(m_CreationFrameIndex);
      5451 
      5452  json.WriteString("LastUseFrameIndex");
      5453  json.WriteNumber(GetLastUseFrameIndex());
      5454 
      5455  if(m_BufferImageUsage != 0)
      5456  {
      5457  json.WriteString("Usage");
      5458  json.WriteNumber(m_BufferImageUsage);
      5459  }
      5460 }
      5461 
      5462 #endif
      5463 
      5464 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
      5465 {
      5466  VMA_ASSERT(IsUserDataString());
      5467  if(m_pUserData != VMA_NULL)
      5468  {
      5469  char* const oldStr = (char*)m_pUserData;
      5470  const size_t oldStrLen = strlen(oldStr);
      5471  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
      5472  m_pUserData = VMA_NULL;
      5473  }
      5474 }
      5475 
      5476 void VmaAllocation_T::BlockAllocMap()
      5477 {
      5478  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      5479 
      5480  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      5481  {
      5482  ++m_MapCount;
      5483  }
      5484  else
      5485  {
      5486  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
      5487  }
      5488 }
      5489 
      5490 void VmaAllocation_T::BlockAllocUnmap()
      5491 {
      5492  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      5493 
      5494  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      5495  {
      5496  --m_MapCount;
      5497  }
      5498  else
      5499  {
      5500  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
      5501  }
      5502 }
      5503 
      5504 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
      5505 {
      5506  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      5507 
      5508  if(m_MapCount != 0)
      5509  {
      5510  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      5511  {
      5512  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
      5513  *ppData = m_DedicatedAllocation.m_pMappedData;
      5514  ++m_MapCount;
      5515  return VK_SUCCESS;
      5516  }
      5517  else
      5518  {
      5519  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
      5520  return VK_ERROR_MEMORY_MAP_FAILED;
      5521  }
      5522  }
      5523  else
      5524  {
      5525  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      5526  hAllocator->m_hDevice,
      5527  m_DedicatedAllocation.m_hMemory,
      5528  0, // offset
      5529  VK_WHOLE_SIZE,
      5530  0, // flags
      5531  ppData);
      5532  if(result == VK_SUCCESS)
      5533  {
      5534  m_DedicatedAllocation.m_pMappedData = *ppData;
      5535  m_MapCount = 1;
      5536  }
      5537  return result;
      5538  }
      5539 }
      5540 
      5541 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
      5542 {
      5543  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      5544 
      5545  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      5546  {
      5547  --m_MapCount;
      5548  if(m_MapCount == 0)
      5549  {
      5550  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
      5551  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
      5552  hAllocator->m_hDevice,
      5553  m_DedicatedAllocation.m_hMemory);
      5554  }
      5555  }
      5556  else
      5557  {
      5558  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
      5559  }
      5560 }
      5561 
      5562 #if VMA_STATS_STRING_ENABLED
      5563 
      5564 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
      5565 {
      5566  json.BeginObject();
      5567 
      5568  json.WriteString("Blocks");
      5569  json.WriteNumber(stat.blockCount);
      5570 
      5571  json.WriteString("Allocations");
      5572  json.WriteNumber(stat.allocationCount);
      5573 
      5574  json.WriteString("UnusedRanges");
      5575  json.WriteNumber(stat.unusedRangeCount);
      5576 
      5577  json.WriteString("UsedBytes");
      5578  json.WriteNumber(stat.usedBytes);
      5579 
      5580  json.WriteString("UnusedBytes");
      5581  json.WriteNumber(stat.unusedBytes);
      5582 
      5583  if(stat.allocationCount > 1)
      5584  {
      5585  json.WriteString("AllocationSize");
      5586  json.BeginObject(true);
      5587  json.WriteString("Min");
      5588  json.WriteNumber(stat.allocationSizeMin);
      5589  json.WriteString("Avg");
      5590  json.WriteNumber(stat.allocationSizeAvg);
      5591  json.WriteString("Max");
      5592  json.WriteNumber(stat.allocationSizeMax);
      5593  json.EndObject();
      5594  }
      5595 
      5596  if(stat.unusedRangeCount > 1)
      5597  {
      5598  json.WriteString("UnusedRangeSize");
      5599  json.BeginObject(true);
      5600  json.WriteString("Min");
      5601  json.WriteNumber(stat.unusedRangeSizeMin);
      5602  json.WriteString("Avg");
      5603  json.WriteNumber(stat.unusedRangeSizeAvg);
      5604  json.WriteString("Max");
      5605  json.WriteNumber(stat.unusedRangeSizeMax);
      5606  json.EndObject();
      5607  }
      5608 
      5609  json.EndObject();
      5610 }
      5611 
      5612 #endif // #if VMA_STATS_STRING_ENABLED
      5613 
      5614 struct VmaSuballocationItemSizeLess
      5615 {
      5616  bool operator()(
      5617  const VmaSuballocationList::iterator lhs,
      5618  const VmaSuballocationList::iterator rhs) const
      5619  {
      5620  return lhs->size < rhs->size;
      5621  }
      5622  bool operator()(
      5623  const VmaSuballocationList::iterator lhs,
      5624  VkDeviceSize rhsSize) const
      5625  {
      5626  return lhs->size < rhsSize;
      5627  }
      5628 };
      5629 
      5631 // class VmaBlockMetadata
      5632 
      5633 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
      5634  m_Size(0),
      5635  m_FreeCount(0),
      5636  m_SumFreeSize(0),
      5637  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      5638  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
      5639 {
      5640 }
      5641 
      5642 VmaBlockMetadata::~VmaBlockMetadata()
      5643 {
      5644 }
      5645 
      5646 void VmaBlockMetadata::Init(VkDeviceSize size)
      5647 {
      5648  m_Size = size;
      5649  m_FreeCount = 1;
      5650  m_SumFreeSize = size;
      5651 
      5652  VmaSuballocation suballoc = {};
      5653  suballoc.offset = 0;
      5654  suballoc.size = size;
      5655  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      5656  suballoc.hAllocation = VK_NULL_HANDLE;
      5657 
      5658  m_Suballocations.push_back(suballoc);
      5659  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
      5660  --suballocItem;
      5661  m_FreeSuballocationsBySize.push_back(suballocItem);
      5662 }
      5663 
      5664 bool VmaBlockMetadata::Validate() const
      5665 {
      5666  if(m_Suballocations.empty())
      5667  {
      5668  return false;
      5669  }
      5670 
      5671  // Expected offset of new suballocation as calculates from previous ones.
      5672  VkDeviceSize calculatedOffset = 0;
      5673  // Expected number of free suballocations as calculated from traversing their list.
      5674  uint32_t calculatedFreeCount = 0;
      5675  // Expected sum size of free suballocations as calculated from traversing their list.
      5676  VkDeviceSize calculatedSumFreeSize = 0;
      5677  // Expected number of free suballocations that should be registered in
      5678  // m_FreeSuballocationsBySize calculated from traversing their list.
      5679  size_t freeSuballocationsToRegister = 0;
      5680  // True if previous visited suballocation was free.
      5681  bool prevFree = false;
      5682 
      5683  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      5684  suballocItem != m_Suballocations.cend();
      5685  ++suballocItem)
      5686  {
      5687  const VmaSuballocation& subAlloc = *suballocItem;
      5688 
      5689  // Actual offset of this suballocation doesn't match expected one.
      5690  if(subAlloc.offset != calculatedOffset)
      5691  {
      5692  return false;
      5693  }
      5694 
      5695  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
      5696  // Two adjacent free suballocations are invalid. They should be merged.
      5697  if(prevFree && currFree)
      5698  {
      5699  return false;
      5700  }
      5701 
      5702  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
      5703  {
      5704  return false;
      5705  }
      5706 
      5707  if(currFree)
      5708  {
      5709  calculatedSumFreeSize += subAlloc.size;
      5710  ++calculatedFreeCount;
      5711  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      5712  {
      5713  ++freeSuballocationsToRegister;
      5714  }
      5715 
      5716  // Margin required between allocations - every free space must be at least that large.
      5717  if(subAlloc.size < VMA_DEBUG_MARGIN)
      5718  {
      5719  return false;
      5720  }
      5721  }
      5722  else
      5723  {
      5724  if(subAlloc.hAllocation->GetOffset() != subAlloc.offset)
      5725  {
      5726  return false;
      5727  }
      5728  if(subAlloc.hAllocation->GetSize() != subAlloc.size)
      5729  {
      5730  return false;
      5731  }
      5732 
      5733  // Margin required between allocations - previous allocation must be free.
      5734  if(VMA_DEBUG_MARGIN > 0 && !prevFree)
      5735  {
      5736  return false;
      5737  }
      5738  }
      5739 
      5740  calculatedOffset += subAlloc.size;
      5741  prevFree = currFree;
      5742  }
      5743 
      5744  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
      5745  // match expected one.
      5746  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
      5747  {
      5748  return false;
      5749  }
      5750 
      5751  VkDeviceSize lastSize = 0;
      5752  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
      5753  {
      5754  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
      5755 
      5756  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
      5757  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
      5758  {
      5759  return false;
      5760  }
      5761  // They must be sorted by size ascending.
      5762  if(suballocItem->size < lastSize)
      5763  {
      5764  return false;
      5765  }
      5766 
      5767  lastSize = suballocItem->size;
      5768  }
      5769 
      5770  // Check if totals match calculacted values.
      5771  if(!ValidateFreeSuballocationList() ||
      5772  (calculatedOffset != m_Size) ||
      5773  (calculatedSumFreeSize != m_SumFreeSize) ||
      5774  (calculatedFreeCount != m_FreeCount))
      5775  {
      5776  return false;
      5777  }
      5778 
      5779  return true;
      5780 }
      5781 
      5782 VkDeviceSize VmaBlockMetadata::GetUnusedRangeSizeMax() const
      5783 {
      5784  if(!m_FreeSuballocationsBySize.empty())
      5785  {
      5786  return m_FreeSuballocationsBySize.back()->size;
      5787  }
      5788  else
      5789  {
      5790  return 0;
      5791  }
      5792 }
      5793 
      5794 bool VmaBlockMetadata::IsEmpty() const
      5795 {
      5796  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
      5797 }
      5798 
      5799 void VmaBlockMetadata::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      5800 {
      5801  outInfo.blockCount = 1;
      5802 
      5803  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      5804  outInfo.allocationCount = rangeCount - m_FreeCount;
      5805  outInfo.unusedRangeCount = m_FreeCount;
      5806 
      5807  outInfo.unusedBytes = m_SumFreeSize;
      5808  outInfo.usedBytes = m_Size - outInfo.unusedBytes;
      5809 
      5810  outInfo.allocationSizeMin = UINT64_MAX;
      5811  outInfo.allocationSizeMax = 0;
      5812  outInfo.unusedRangeSizeMin = UINT64_MAX;
      5813  outInfo.unusedRangeSizeMax = 0;
      5814 
      5815  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      5816  suballocItem != m_Suballocations.cend();
      5817  ++suballocItem)
      5818  {
      5819  const VmaSuballocation& suballoc = *suballocItem;
      5820  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      5821  {
      5822  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      5823  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
      5824  }
      5825  else
      5826  {
      5827  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
      5828  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
      5829  }
      5830  }
      5831 }
      5832 
      5833 void VmaBlockMetadata::AddPoolStats(VmaPoolStats& inoutStats) const
      5834 {
      5835  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      5836 
      5837  inoutStats.size += m_Size;
      5838  inoutStats.unusedSize += m_SumFreeSize;
      5839  inoutStats.allocationCount += rangeCount - m_FreeCount;
      5840  inoutStats.unusedRangeCount += m_FreeCount;
      5841  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
      5842 }
      5843 
      5844 #if VMA_STATS_STRING_ENABLED
      5845 
      5846 void VmaBlockMetadata::PrintDetailedMap(class VmaJsonWriter& json) const
      5847 {
      5848  json.BeginObject();
      5849 
      5850  json.WriteString("TotalBytes");
      5851  json.WriteNumber(m_Size);
      5852 
      5853  json.WriteString("UnusedBytes");
      5854  json.WriteNumber(m_SumFreeSize);
      5855 
      5856  json.WriteString("Allocations");
      5857  json.WriteNumber((uint64_t)m_Suballocations.size() - m_FreeCount);
      5858 
      5859  json.WriteString("UnusedRanges");
      5860  json.WriteNumber(m_FreeCount);
      5861 
      5862  json.WriteString("Suballocations");
      5863  json.BeginArray();
      5864  size_t i = 0;
      5865  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      5866  suballocItem != m_Suballocations.cend();
      5867  ++suballocItem, ++i)
      5868  {
      5869  json.BeginObject(true);
      5870 
      5871  json.WriteString("Offset");
      5872  json.WriteNumber(suballocItem->offset);
      5873 
      5874  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      5875  {
      5876  json.WriteString("Type");
      5877  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
      5878 
      5879  json.WriteString("Size");
      5880  json.WriteNumber(suballocItem->size);
      5881  }
      5882  else
      5883  {
      5884  suballocItem->hAllocation->PrintParameters(json);
      5885  }
      5886 
      5887  json.EndObject();
      5888  }
      5889  json.EndArray();
      5890 
      5891  json.EndObject();
      5892 }
      5893 
      5894 #endif // #if VMA_STATS_STRING_ENABLED
      5895 
      5896 /*
      5897 How many suitable free suballocations to analyze before choosing best one.
      5898 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
      5899  be chosen.
      5900 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
      5901  suballocations will be analized and best one will be chosen.
      5902 - Any other value is also acceptable.
      5903 */
      5904 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
      5905 
      5906 bool VmaBlockMetadata::CreateAllocationRequest(
      5907  uint32_t currentFrameIndex,
      5908  uint32_t frameInUseCount,
      5909  VkDeviceSize bufferImageGranularity,
      5910  VkDeviceSize allocSize,
      5911  VkDeviceSize allocAlignment,
      5912  VmaSuballocationType allocType,
      5913  bool canMakeOtherLost,
      5914  VmaAllocationRequest* pAllocationRequest)
      5915 {
      5916  VMA_ASSERT(allocSize > 0);
      5917  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      5918  VMA_ASSERT(pAllocationRequest != VMA_NULL);
      5919  VMA_HEAVY_ASSERT(Validate());
      5920 
      5921  // There is not enough total free space in this block to fullfill the request: Early return.
      5922  if(canMakeOtherLost == false && m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
      5923  {
      5924  return false;
      5925  }
      5926 
      5927  // New algorithm, efficiently searching freeSuballocationsBySize.
      5928  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
      5929  if(freeSuballocCount > 0)
      5930  {
      5931  if(VMA_BEST_FIT)
      5932  {
      5933  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
      5934  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      5935  m_FreeSuballocationsBySize.data(),
      5936  m_FreeSuballocationsBySize.data() + freeSuballocCount,
      5937  allocSize + 2 * VMA_DEBUG_MARGIN,
      5938  VmaSuballocationItemSizeLess());
      5939  size_t index = it - m_FreeSuballocationsBySize.data();
      5940  for(; index < freeSuballocCount; ++index)
      5941  {
      5942  if(CheckAllocation(
      5943  currentFrameIndex,
      5944  frameInUseCount,
      5945  bufferImageGranularity,
      5946  allocSize,
      5947  allocAlignment,
      5948  allocType,
      5949  m_FreeSuballocationsBySize[index],
      5950  false, // canMakeOtherLost
      5951  &pAllocationRequest->offset,
      5952  &pAllocationRequest->itemsToMakeLostCount,
      5953  &pAllocationRequest->sumFreeSize,
      5954  &pAllocationRequest->sumItemSize))
      5955  {
      5956  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      5957  return true;
      5958  }
      5959  }
      5960  }
      5961  else
      5962  {
      5963  // Search staring from biggest suballocations.
      5964  for(size_t index = freeSuballocCount; index--; )
      5965  {
      5966  if(CheckAllocation(
      5967  currentFrameIndex,
      5968  frameInUseCount,
      5969  bufferImageGranularity,
      5970  allocSize,
      5971  allocAlignment,
      5972  allocType,
      5973  m_FreeSuballocationsBySize[index],
      5974  false, // canMakeOtherLost
      5975  &pAllocationRequest->offset,
      5976  &pAllocationRequest->itemsToMakeLostCount,
      5977  &pAllocationRequest->sumFreeSize,
      5978  &pAllocationRequest->sumItemSize))
      5979  {
      5980  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      5981  return true;
      5982  }
      5983  }
      5984  }
      5985  }
      5986 
      5987  if(canMakeOtherLost)
      5988  {
      5989  // Brute-force algorithm. TODO: Come up with something better.
      5990 
      5991  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
      5992  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
      5993 
      5994  VmaAllocationRequest tmpAllocRequest = {};
      5995  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
      5996  suballocIt != m_Suballocations.end();
      5997  ++suballocIt)
      5998  {
      5999  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
      6000  suballocIt->hAllocation->CanBecomeLost())
      6001  {
      6002  if(CheckAllocation(
      6003  currentFrameIndex,
      6004  frameInUseCount,
      6005  bufferImageGranularity,
      6006  allocSize,
      6007  allocAlignment,
      6008  allocType,
      6009  suballocIt,
      6010  canMakeOtherLost,
      6011  &tmpAllocRequest.offset,
      6012  &tmpAllocRequest.itemsToMakeLostCount,
      6013  &tmpAllocRequest.sumFreeSize,
      6014  &tmpAllocRequest.sumItemSize))
      6015  {
      6016  tmpAllocRequest.item = suballocIt;
      6017 
      6018  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
      6019  {
      6020  *pAllocationRequest = tmpAllocRequest;
      6021  }
      6022  }
      6023  }
      6024  }
      6025 
      6026  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
      6027  {
      6028  return true;
      6029  }
      6030  }
      6031 
      6032  return false;
      6033 }
      6034 
      6035 bool VmaBlockMetadata::MakeRequestedAllocationsLost(
      6036  uint32_t currentFrameIndex,
      6037  uint32_t frameInUseCount,
      6038  VmaAllocationRequest* pAllocationRequest)
      6039 {
      6040  while(pAllocationRequest->itemsToMakeLostCount > 0)
      6041  {
      6042  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
      6043  {
      6044  ++pAllocationRequest->item;
      6045  }
      6046  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      6047  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
      6048  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
      6049  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      6050  {
      6051  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
      6052  --pAllocationRequest->itemsToMakeLostCount;
      6053  }
      6054  else
      6055  {
      6056  return false;
      6057  }
      6058  }
      6059 
      6060  VMA_HEAVY_ASSERT(Validate());
      6061  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      6062  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6063 
      6064  return true;
      6065 }
      6066 
      6067 uint32_t VmaBlockMetadata::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      6068 {
      6069  uint32_t lostAllocationCount = 0;
      6070  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      6071  it != m_Suballocations.end();
      6072  ++it)
      6073  {
      6074  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
      6075  it->hAllocation->CanBecomeLost() &&
      6076  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      6077  {
      6078  it = FreeSuballocation(it);
      6079  ++lostAllocationCount;
      6080  }
      6081  }
      6082  return lostAllocationCount;
      6083 }
      6084 
      6085 VkResult VmaBlockMetadata::CheckCorruption(const void* pBlockData)
      6086 {
      6087  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      6088  it != m_Suballocations.end();
      6089  ++it)
      6090  {
      6091  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      6092  {
      6093  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
      6094  {
      6095  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      6096  return VK_ERROR_VALIDATION_FAILED_EXT;
      6097  }
      6098  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
      6099  {
      6100  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      6101  return VK_ERROR_VALIDATION_FAILED_EXT;
      6102  }
      6103  }
      6104  }
      6105 
      6106  return VK_SUCCESS;
      6107 }
      6108 
      6109 void VmaBlockMetadata::Alloc(
      6110  const VmaAllocationRequest& request,
      6111  VmaSuballocationType type,
      6112  VkDeviceSize allocSize,
      6113  VmaAllocation hAllocation)
      6114 {
      6115  VMA_ASSERT(request.item != m_Suballocations.end());
      6116  VmaSuballocation& suballoc = *request.item;
      6117  // Given suballocation is a free block.
      6118  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      6119  // Given offset is inside this suballocation.
      6120  VMA_ASSERT(request.offset >= suballoc.offset);
      6121  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
      6122  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
      6123  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
      6124 
      6125  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
      6126  // it to become used.
      6127  UnregisterFreeSuballocation(request.item);
      6128 
      6129  suballoc.offset = request.offset;
      6130  suballoc.size = allocSize;
      6131  suballoc.type = type;
      6132  suballoc.hAllocation = hAllocation;
      6133 
      6134  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
      6135  if(paddingEnd)
      6136  {
      6137  VmaSuballocation paddingSuballoc = {};
      6138  paddingSuballoc.offset = request.offset + allocSize;
      6139  paddingSuballoc.size = paddingEnd;
      6140  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      6141  VmaSuballocationList::iterator next = request.item;
      6142  ++next;
      6143  const VmaSuballocationList::iterator paddingEndItem =
      6144  m_Suballocations.insert(next, paddingSuballoc);
      6145  RegisterFreeSuballocation(paddingEndItem);
      6146  }
      6147 
      6148  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
      6149  if(paddingBegin)
      6150  {
      6151  VmaSuballocation paddingSuballoc = {};
      6152  paddingSuballoc.offset = request.offset - paddingBegin;
      6153  paddingSuballoc.size = paddingBegin;
      6154  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      6155  const VmaSuballocationList::iterator paddingBeginItem =
      6156  m_Suballocations.insert(request.item, paddingSuballoc);
      6157  RegisterFreeSuballocation(paddingBeginItem);
      6158  }
      6159 
      6160  // Update totals.
      6161  m_FreeCount = m_FreeCount - 1;
      6162  if(paddingBegin > 0)
      6163  {
      6164  ++m_FreeCount;
      6165  }
      6166  if(paddingEnd > 0)
      6167  {
      6168  ++m_FreeCount;
      6169  }
      6170  m_SumFreeSize -= allocSize;
      6171 }
      6172 
      6173 void VmaBlockMetadata::Free(const VmaAllocation allocation)
      6174 {
      6175  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      6176  suballocItem != m_Suballocations.end();
      6177  ++suballocItem)
      6178  {
      6179  VmaSuballocation& suballoc = *suballocItem;
      6180  if(suballoc.hAllocation == allocation)
      6181  {
      6182  FreeSuballocation(suballocItem);
      6183  VMA_HEAVY_ASSERT(Validate());
      6184  return;
      6185  }
      6186  }
      6187  VMA_ASSERT(0 && "Not found!");
      6188 }
      6189 
      6190 void VmaBlockMetadata::FreeAtOffset(VkDeviceSize offset)
      6191 {
      6192  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      6193  suballocItem != m_Suballocations.end();
      6194  ++suballocItem)
      6195  {
      6196  VmaSuballocation& suballoc = *suballocItem;
      6197  if(suballoc.offset == offset)
      6198  {
      6199  FreeSuballocation(suballocItem);
      6200  return;
      6201  }
      6202  }
      6203  VMA_ASSERT(0 && "Not found!");
      6204 }
      6205 
      6206 bool VmaBlockMetadata::ValidateFreeSuballocationList() const
      6207 {
      6208  VkDeviceSize lastSize = 0;
      6209  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
      6210  {
      6211  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
      6212 
      6213  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      6214  {
      6215  VMA_ASSERT(0);
      6216  return false;
      6217  }
      6218  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      6219  {
      6220  VMA_ASSERT(0);
      6221  return false;
      6222  }
      6223  if(it->size < lastSize)
      6224  {
      6225  VMA_ASSERT(0);
      6226  return false;
      6227  }
      6228 
      6229  lastSize = it->size;
      6230  }
      6231  return true;
      6232 }
      6233 
      6234 bool VmaBlockMetadata::CheckAllocation(
      6235  uint32_t currentFrameIndex,
      6236  uint32_t frameInUseCount,
      6237  VkDeviceSize bufferImageGranularity,
      6238  VkDeviceSize allocSize,
      6239  VkDeviceSize allocAlignment,
      6240  VmaSuballocationType allocType,
      6241  VmaSuballocationList::const_iterator suballocItem,
      6242  bool canMakeOtherLost,
      6243  VkDeviceSize* pOffset,
      6244  size_t* itemsToMakeLostCount,
      6245  VkDeviceSize* pSumFreeSize,
      6246  VkDeviceSize* pSumItemSize) const
      6247 {
      6248  VMA_ASSERT(allocSize > 0);
      6249  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      6250  VMA_ASSERT(suballocItem != m_Suballocations.cend());
      6251  VMA_ASSERT(pOffset != VMA_NULL);
      6252 
      6253  *itemsToMakeLostCount = 0;
      6254  *pSumFreeSize = 0;
      6255  *pSumItemSize = 0;
      6256 
      6257  if(canMakeOtherLost)
      6258  {
      6259  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6260  {
      6261  *pSumFreeSize = suballocItem->size;
      6262  }
      6263  else
      6264  {
      6265  if(suballocItem->hAllocation->CanBecomeLost() &&
      6266  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      6267  {
      6268  ++*itemsToMakeLostCount;
      6269  *pSumItemSize = suballocItem->size;
      6270  }
      6271  else
      6272  {
      6273  return false;
      6274  }
      6275  }
      6276 
      6277  // Remaining size is too small for this request: Early return.
      6278  if(m_Size - suballocItem->offset < allocSize)
      6279  {
      6280  return false;
      6281  }
      6282 
      6283  // Start from offset equal to beginning of this suballocation.
      6284  *pOffset = suballocItem->offset;
      6285 
      6286  // Apply VMA_DEBUG_MARGIN at the beginning.
      6287  if(VMA_DEBUG_MARGIN > 0)
      6288  {
      6289  *pOffset += VMA_DEBUG_MARGIN;
      6290  }
      6291 
      6292  // Apply alignment.
      6293  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      6294 
      6295  // Check previous suballocations for BufferImageGranularity conflicts.
      6296  // Make bigger alignment if necessary.
      6297  if(bufferImageGranularity > 1)
      6298  {
      6299  bool bufferImageGranularityConflict = false;
      6300  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      6301  while(prevSuballocItem != m_Suballocations.cbegin())
      6302  {
      6303  --prevSuballocItem;
      6304  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      6305  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      6306  {
      6307  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      6308  {
      6309  bufferImageGranularityConflict = true;
      6310  break;
      6311  }
      6312  }
      6313  else
      6314  // Already on previous page.
      6315  break;
      6316  }
      6317  if(bufferImageGranularityConflict)
      6318  {
      6319  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      6320  }
      6321  }
      6322 
      6323  // Now that we have final *pOffset, check if we are past suballocItem.
      6324  // If yes, return false - this function should be called for another suballocItem as starting point.
      6325  if(*pOffset >= suballocItem->offset + suballocItem->size)
      6326  {
      6327  return false;
      6328  }
      6329 
      6330  // Calculate padding at the beginning based on current offset.
      6331  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
      6332 
      6333  // Calculate required margin at the end.
      6334  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      6335 
      6336  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
      6337  // Another early return check.
      6338  if(suballocItem->offset + totalSize > m_Size)
      6339  {
      6340  return false;
      6341  }
      6342 
      6343  // Advance lastSuballocItem until desired size is reached.
      6344  // Update itemsToMakeLostCount.
      6345  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
      6346  if(totalSize > suballocItem->size)
      6347  {
      6348  VkDeviceSize remainingSize = totalSize - suballocItem->size;
      6349  while(remainingSize > 0)
      6350  {
      6351  ++lastSuballocItem;
      6352  if(lastSuballocItem == m_Suballocations.cend())
      6353  {
      6354  return false;
      6355  }
      6356  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6357  {
      6358  *pSumFreeSize += lastSuballocItem->size;
      6359  }
      6360  else
      6361  {
      6362  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
      6363  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
      6364  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      6365  {
      6366  ++*itemsToMakeLostCount;
      6367  *pSumItemSize += lastSuballocItem->size;
      6368  }
      6369  else
      6370  {
      6371  return false;
      6372  }
      6373  }
      6374  remainingSize = (lastSuballocItem->size < remainingSize) ?
      6375  remainingSize - lastSuballocItem->size : 0;
      6376  }
      6377  }
      6378 
      6379  // Check next suballocations for BufferImageGranularity conflicts.
      6380  // If conflict exists, we must mark more allocations lost or fail.
      6381  if(bufferImageGranularity > 1)
      6382  {
      6383  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
      6384  ++nextSuballocItem;
      6385  while(nextSuballocItem != m_Suballocations.cend())
      6386  {
      6387  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      6388  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      6389  {
      6390  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      6391  {
      6392  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
      6393  if(nextSuballoc.hAllocation->CanBecomeLost() &&
      6394  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      6395  {
      6396  ++*itemsToMakeLostCount;
      6397  }
      6398  else
      6399  {
      6400  return false;
      6401  }
      6402  }
      6403  }
      6404  else
      6405  {
      6406  // Already on next page.
      6407  break;
      6408  }
      6409  ++nextSuballocItem;
      6410  }
      6411  }
      6412  }
      6413  else
      6414  {
      6415  const VmaSuballocation& suballoc = *suballocItem;
      6416  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      6417 
      6418  *pSumFreeSize = suballoc.size;
      6419 
      6420  // Size of this suballocation is too small for this request: Early return.
      6421  if(suballoc.size < allocSize)
      6422  {
      6423  return false;
      6424  }
      6425 
      6426  // Start from offset equal to beginning of this suballocation.
      6427  *pOffset = suballoc.offset;
      6428 
      6429  // Apply VMA_DEBUG_MARGIN at the beginning.
      6430  if(VMA_DEBUG_MARGIN > 0)
      6431  {
      6432  *pOffset += VMA_DEBUG_MARGIN;
      6433  }
      6434 
      6435  // Apply alignment.
      6436  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      6437 
      6438  // Check previous suballocations for BufferImageGranularity conflicts.
      6439  // Make bigger alignment if necessary.
      6440  if(bufferImageGranularity > 1)
      6441  {
      6442  bool bufferImageGranularityConflict = false;
      6443  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      6444  while(prevSuballocItem != m_Suballocations.cbegin())
      6445  {
      6446  --prevSuballocItem;
      6447  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      6448  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      6449  {
      6450  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      6451  {
      6452  bufferImageGranularityConflict = true;
      6453  break;
      6454  }
      6455  }
      6456  else
      6457  // Already on previous page.
      6458  break;
      6459  }
      6460  if(bufferImageGranularityConflict)
      6461  {
      6462  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      6463  }
      6464  }
      6465 
      6466  // Calculate padding at the beginning based on current offset.
      6467  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
      6468 
      6469  // Calculate required margin at the end.
      6470  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      6471 
      6472  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
      6473  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
      6474  {
      6475  return false;
      6476  }
      6477 
      6478  // Check next suballocations for BufferImageGranularity conflicts.
      6479  // If conflict exists, allocation cannot be made here.
      6480  if(bufferImageGranularity > 1)
      6481  {
      6482  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
      6483  ++nextSuballocItem;
      6484  while(nextSuballocItem != m_Suballocations.cend())
      6485  {
      6486  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      6487  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      6488  {
      6489  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      6490  {
      6491  return false;
      6492  }
      6493  }
      6494  else
      6495  {
      6496  // Already on next page.
      6497  break;
      6498  }
      6499  ++nextSuballocItem;
      6500  }
      6501  }
      6502  }
      6503 
      6504  // All tests passed: Success. pOffset is already filled.
      6505  return true;
      6506 }
      6507 
      6508 void VmaBlockMetadata::MergeFreeWithNext(VmaSuballocationList::iterator item)
      6509 {
      6510  VMA_ASSERT(item != m_Suballocations.end());
      6511  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6512 
      6513  VmaSuballocationList::iterator nextItem = item;
      6514  ++nextItem;
      6515  VMA_ASSERT(nextItem != m_Suballocations.end());
      6516  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
      6517 
      6518  item->size += nextItem->size;
      6519  --m_FreeCount;
      6520  m_Suballocations.erase(nextItem);
      6521 }
      6522 
      6523 VmaSuballocationList::iterator VmaBlockMetadata::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
      6524 {
      6525  // Change this suballocation to be marked as free.
      6526  VmaSuballocation& suballoc = *suballocItem;
      6527  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      6528  suballoc.hAllocation = VK_NULL_HANDLE;
      6529 
      6530  // Update totals.
      6531  ++m_FreeCount;
      6532  m_SumFreeSize += suballoc.size;
      6533 
      6534  // Merge with previous and/or next suballocation if it's also free.
      6535  bool mergeWithNext = false;
      6536  bool mergeWithPrev = false;
      6537 
      6538  VmaSuballocationList::iterator nextItem = suballocItem;
      6539  ++nextItem;
      6540  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
      6541  {
      6542  mergeWithNext = true;
      6543  }
      6544 
      6545  VmaSuballocationList::iterator prevItem = suballocItem;
      6546  if(suballocItem != m_Suballocations.begin())
      6547  {
      6548  --prevItem;
      6549  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6550  {
      6551  mergeWithPrev = true;
      6552  }
      6553  }
      6554 
      6555  if(mergeWithNext)
      6556  {
      6557  UnregisterFreeSuballocation(nextItem);
      6558  MergeFreeWithNext(suballocItem);
      6559  }
      6560 
      6561  if(mergeWithPrev)
      6562  {
      6563  UnregisterFreeSuballocation(prevItem);
      6564  MergeFreeWithNext(prevItem);
      6565  RegisterFreeSuballocation(prevItem);
      6566  return prevItem;
      6567  }
      6568  else
      6569  {
      6570  RegisterFreeSuballocation(suballocItem);
      6571  return suballocItem;
      6572  }
      6573 }
      6574 
      6575 void VmaBlockMetadata::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
      6576 {
      6577  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6578  VMA_ASSERT(item->size > 0);
      6579 
      6580  // You may want to enable this validation at the beginning or at the end of
      6581  // this function, depending on what do you want to check.
      6582  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6583 
      6584  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      6585  {
      6586  if(m_FreeSuballocationsBySize.empty())
      6587  {
      6588  m_FreeSuballocationsBySize.push_back(item);
      6589  }
      6590  else
      6591  {
      6592  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
      6593  }
      6594  }
      6595 
      6596  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6597 }
      6598 
      6599 
      6600 void VmaBlockMetadata::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
      6601 {
      6602  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6603  VMA_ASSERT(item->size > 0);
      6604 
      6605  // You may want to enable this validation at the beginning or at the end of
      6606  // this function, depending on what do you want to check.
      6607  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6608 
      6609  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      6610  {
      6611  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      6612  m_FreeSuballocationsBySize.data(),
      6613  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
      6614  item,
      6615  VmaSuballocationItemSizeLess());
      6616  for(size_t index = it - m_FreeSuballocationsBySize.data();
      6617  index < m_FreeSuballocationsBySize.size();
      6618  ++index)
      6619  {
      6620  if(m_FreeSuballocationsBySize[index] == item)
      6621  {
      6622  VmaVectorRemove(m_FreeSuballocationsBySize, index);
      6623  return;
      6624  }
      6625  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
      6626  }
      6627  VMA_ASSERT(0 && "Not found.");
      6628  }
      6629 
      6630  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6631 }
      6632 
      6634 // class VmaDeviceMemoryBlock
      6635 
      6636 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
      6637  m_Metadata(hAllocator),
      6638  m_MemoryTypeIndex(UINT32_MAX),
      6639  m_Id(0),
      6640  m_hMemory(VK_NULL_HANDLE),
      6641  m_MapCount(0),
      6642  m_pMappedData(VMA_NULL)
      6643 {
      6644 }
      6645 
      6646 void VmaDeviceMemoryBlock::Init(
      6647  uint32_t newMemoryTypeIndex,
      6648  VkDeviceMemory newMemory,
      6649  VkDeviceSize newSize,
      6650  uint32_t id)
      6651 {
      6652  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      6653 
      6654  m_MemoryTypeIndex = newMemoryTypeIndex;
      6655  m_Id = id;
      6656  m_hMemory = newMemory;
      6657 
      6658  m_Metadata.Init(newSize);
      6659 }
      6660 
      6661 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
      6662 {
      6663  // This is the most important assert in the entire library.
      6664  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
      6665  VMA_ASSERT(m_Metadata.IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
      6666 
      6667  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
      6668  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Metadata.GetSize(), m_hMemory);
      6669  m_hMemory = VK_NULL_HANDLE;
      6670 }
      6671 
      6672 bool VmaDeviceMemoryBlock::Validate() const
      6673 {
      6674  if((m_hMemory == VK_NULL_HANDLE) ||
      6675  (m_Metadata.GetSize() == 0))
      6676  {
      6677  return false;
      6678  }
      6679 
      6680  return m_Metadata.Validate();
      6681 }
      6682 
      6683 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
      6684 {
      6685  void* pData = nullptr;
      6686  VkResult res = Map(hAllocator, 1, &pData);
      6687  if(res != VK_SUCCESS)
      6688  {
      6689  return res;
      6690  }
      6691 
      6692  res = m_Metadata.CheckCorruption(pData);
      6693 
      6694  Unmap(hAllocator, 1);
      6695 
      6696  return res;
      6697 }
      6698 
      6699 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
      6700 {
      6701  if(count == 0)
      6702  {
      6703  return VK_SUCCESS;
      6704  }
      6705 
      6706  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      6707  if(m_MapCount != 0)
      6708  {
      6709  m_MapCount += count;
      6710  VMA_ASSERT(m_pMappedData != VMA_NULL);
      6711  if(ppData != VMA_NULL)
      6712  {
      6713  *ppData = m_pMappedData;
      6714  }
      6715  return VK_SUCCESS;
      6716  }
      6717  else
      6718  {
      6719  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      6720  hAllocator->m_hDevice,
      6721  m_hMemory,
      6722  0, // offset
      6723  VK_WHOLE_SIZE,
      6724  0, // flags
      6725  &m_pMappedData);
      6726  if(result == VK_SUCCESS)
      6727  {
      6728  if(ppData != VMA_NULL)
      6729  {
      6730  *ppData = m_pMappedData;
      6731  }
      6732  m_MapCount = count;
      6733  }
      6734  return result;
      6735  }
      6736 }
      6737 
      6738 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
      6739 {
      6740  if(count == 0)
      6741  {
      6742  return;
      6743  }
      6744 
      6745  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      6746  if(m_MapCount >= count)
      6747  {
      6748  m_MapCount -= count;
      6749  if(m_MapCount == 0)
      6750  {
      6751  m_pMappedData = VMA_NULL;
      6752  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
      6753  }
      6754  }
      6755  else
      6756  {
      6757  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
      6758  }
      6759 }
      6760 
      6761 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      6762 {
      6763  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      6764  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      6765 
      6766  void* pData;
      6767  VkResult res = Map(hAllocator, 1, &pData);
      6768  if(res != VK_SUCCESS)
      6769  {
      6770  return res;
      6771  }
      6772 
      6773  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
      6774  VmaWriteMagicValue(pData, allocOffset + allocSize);
      6775 
      6776  Unmap(hAllocator, 1);
      6777 
      6778  return VK_SUCCESS;
      6779 }
      6780 
      6781 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      6782 {
      6783  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      6784  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      6785 
      6786  void* pData;
      6787  VkResult res = Map(hAllocator, 1, &pData);
      6788  if(res != VK_SUCCESS)
      6789  {
      6790  return res;
      6791  }
      6792 
      6793  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
      6794  {
      6795  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
      6796  }
      6797  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
      6798  {
      6799  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
      6800  }
      6801 
      6802  Unmap(hAllocator, 1);
      6803 
      6804  return VK_SUCCESS;
      6805 }
      6806 
      6807 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
      6808  const VmaAllocator hAllocator,
      6809  const VmaAllocation hAllocation,
      6810  VkBuffer hBuffer)
      6811 {
      6812  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      6813  hAllocation->GetBlock() == this);
      6814  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      6815  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      6816  return hAllocator->GetVulkanFunctions().vkBindBufferMemory(
      6817  hAllocator->m_hDevice,
      6818  hBuffer,
      6819  m_hMemory,
      6820  hAllocation->GetOffset());
      6821 }
      6822 
      6823 VkResult VmaDeviceMemoryBlock::BindImageMemory(
      6824  const VmaAllocator hAllocator,
      6825  const VmaAllocation hAllocation,
      6826  VkImage hImage)
      6827 {
      6828  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      6829  hAllocation->GetBlock() == this);
      6830  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      6831  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      6832  return hAllocator->GetVulkanFunctions().vkBindImageMemory(
      6833  hAllocator->m_hDevice,
      6834  hImage,
      6835  m_hMemory,
      6836  hAllocation->GetOffset());
      6837 }
      6838 
      6839 static void InitStatInfo(VmaStatInfo& outInfo)
      6840 {
      6841  memset(&outInfo, 0, sizeof(outInfo));
      6842  outInfo.allocationSizeMin = UINT64_MAX;
      6843  outInfo.unusedRangeSizeMin = UINT64_MAX;
      6844 }
      6845 
      6846 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
      6847 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
      6848 {
      6849  inoutInfo.blockCount += srcInfo.blockCount;
      6850  inoutInfo.allocationCount += srcInfo.allocationCount;
      6851  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
      6852  inoutInfo.usedBytes += srcInfo.usedBytes;
      6853  inoutInfo.unusedBytes += srcInfo.unusedBytes;
      6854  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
      6855  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
      6856  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
      6857  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
      6858 }
      6859 
      6860 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
      6861 {
      6862  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
      6863  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
      6864  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
      6865  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
      6866 }
      6867 
      6868 VmaPool_T::VmaPool_T(
      6869  VmaAllocator hAllocator,
      6870  const VmaPoolCreateInfo& createInfo) :
      6871  m_BlockVector(
      6872  hAllocator,
      6873  createInfo.memoryTypeIndex,
      6874  createInfo.blockSize,
      6875  createInfo.minBlockCount,
      6876  createInfo.maxBlockCount,
      6877  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
      6878  createInfo.frameInUseCount,
      6879  true), // isCustomPool
      6880  m_Id(0)
      6881 {
      6882 }
      6883 
      6884 VmaPool_T::~VmaPool_T()
      6885 {
      6886 }
      6887 
      6888 #if VMA_STATS_STRING_ENABLED
      6889 
      6890 #endif // #if VMA_STATS_STRING_ENABLED
      6891 
      6892 VmaBlockVector::VmaBlockVector(
      6893  VmaAllocator hAllocator,
      6894  uint32_t memoryTypeIndex,
      6895  VkDeviceSize preferredBlockSize,
      6896  size_t minBlockCount,
      6897  size_t maxBlockCount,
      6898  VkDeviceSize bufferImageGranularity,
      6899  uint32_t frameInUseCount,
      6900  bool isCustomPool) :
      6901  m_hAllocator(hAllocator),
      6902  m_MemoryTypeIndex(memoryTypeIndex),
      6903  m_PreferredBlockSize(preferredBlockSize),
      6904  m_MinBlockCount(minBlockCount),
      6905  m_MaxBlockCount(maxBlockCount),
      6906  m_BufferImageGranularity(bufferImageGranularity),
      6907  m_FrameInUseCount(frameInUseCount),
      6908  m_IsCustomPool(isCustomPool),
      6909  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
      6910  m_HasEmptyBlock(false),
      6911  m_pDefragmentator(VMA_NULL),
      6912  m_NextBlockId(0)
      6913 {
      6914 }
      6915 
      6916 VmaBlockVector::~VmaBlockVector()
      6917 {
      6918  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
      6919 
      6920  for(size_t i = m_Blocks.size(); i--; )
      6921  {
      6922  m_Blocks[i]->Destroy(m_hAllocator);
      6923  vma_delete(m_hAllocator, m_Blocks[i]);
      6924  }
      6925 }
      6926 
      6927 VkResult VmaBlockVector::CreateMinBlocks()
      6928 {
      6929  for(size_t i = 0; i < m_MinBlockCount; ++i)
      6930  {
      6931  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
      6932  if(res != VK_SUCCESS)
      6933  {
      6934  return res;
      6935  }
      6936  }
      6937  return VK_SUCCESS;
      6938 }
      6939 
      6940 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
      6941 {
      6942  pStats->size = 0;
      6943  pStats->unusedSize = 0;
      6944  pStats->allocationCount = 0;
      6945  pStats->unusedRangeCount = 0;
      6946  pStats->unusedRangeSizeMax = 0;
      6947 
      6948  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      6949 
      6950  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      6951  {
      6952  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      6953  VMA_ASSERT(pBlock);
      6954  VMA_HEAVY_ASSERT(pBlock->Validate());
      6955  pBlock->m_Metadata.AddPoolStats(*pStats);
      6956  }
      6957 }
      6958 
      6959 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
      6960 {
      6961  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      6962  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
      6963  (VMA_DEBUG_MARGIN > 0) &&
      6964  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
      6965 }
      6966 
      6967 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
      6968 
      6969 VkResult VmaBlockVector::Allocate(
      6970  VmaPool hCurrentPool,
      6971  uint32_t currentFrameIndex,
      6972  VkDeviceSize size,
      6973  VkDeviceSize alignment,
      6974  const VmaAllocationCreateInfo& createInfo,
      6975  VmaSuballocationType suballocType,
      6976  VmaAllocation* pAllocation)
      6977 {
      6978  // Early reject: requested allocation size is larger that maximum block size for this block vector.
      6979  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
      6980  {
      6981  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      6982  }
      6983 
      6984  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      6985  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
      6986 
      6987  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      6988 
      6989  // 1. Search existing allocations. Try to allocate without making other allocations lost.
      6990  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      6991  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      6992  {
      6993  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      6994  VMA_ASSERT(pCurrBlock);
      6995  VmaAllocationRequest currRequest = {};
      6996  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
      6997  currentFrameIndex,
      6998  m_FrameInUseCount,
      6999  m_BufferImageGranularity,
      7000  size,
      7001  alignment,
      7002  suballocType,
      7003  false, // canMakeOtherLost
      7004  &currRequest))
      7005  {
      7006  // Allocate from pCurrBlock.
      7007  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
      7008 
      7009  if(mapped)
      7010  {
      7011  VkResult res = pCurrBlock->Map(m_hAllocator, 1, VMA_NULL);
      7012  if(res != VK_SUCCESS)
      7013  {
      7014  return res;
      7015  }
      7016  }
      7017 
      7018  // We no longer have an empty Allocation.
      7019  if(pCurrBlock->m_Metadata.IsEmpty())
      7020  {
      7021  m_HasEmptyBlock = false;
      7022  }
      7023 
      7024  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
      7025  pCurrBlock->m_Metadata.Alloc(currRequest, suballocType, size, *pAllocation);
      7026  (*pAllocation)->InitBlockAllocation(
      7027  hCurrentPool,
      7028  pCurrBlock,
      7029  currRequest.offset,
      7030  alignment,
      7031  size,
      7032  suballocType,
      7033  mapped,
      7034  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      7035  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
      7036  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
      7037  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      7038  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      7039  {
      7040  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      7041  }
      7042  if(IsCorruptionDetectionEnabled())
      7043  {
      7044  VkResult res = pCurrBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
      7045  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      7046  }
      7047  return VK_SUCCESS;
      7048  }
      7049  }
      7050 
      7051  const bool canCreateNewBlock =
      7052  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
      7053  (m_Blocks.size() < m_MaxBlockCount);
      7054 
      7055  // 2. Try to create new block.
      7056  if(canCreateNewBlock)
      7057  {
      7058  // Calculate optimal size for new block.
      7059  VkDeviceSize newBlockSize = m_PreferredBlockSize;
      7060  uint32_t newBlockSizeShift = 0;
      7061  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
      7062 
      7063  // Allocating blocks of other sizes is allowed only in default pools.
      7064  // In custom pools block size is fixed.
      7065  if(m_IsCustomPool == false)
      7066  {
      7067  // Allocate 1/8, 1/4, 1/2 as first blocks.
      7068  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
      7069  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
      7070  {
      7071  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      7072  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
      7073  {
      7074  newBlockSize = smallerNewBlockSize;
      7075  ++newBlockSizeShift;
      7076  }
      7077  else
      7078  {
      7079  break;
      7080  }
      7081  }
      7082  }
      7083 
      7084  size_t newBlockIndex = 0;
      7085  VkResult res = CreateBlock(newBlockSize, &newBlockIndex);
      7086  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
      7087  if(m_IsCustomPool == false)
      7088  {
      7089  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
      7090  {
      7091  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      7092  if(smallerNewBlockSize >= size)
      7093  {
      7094  newBlockSize = smallerNewBlockSize;
      7095  ++newBlockSizeShift;
      7096  res = CreateBlock(newBlockSize, &newBlockIndex);
      7097  }
      7098  else
      7099  {
      7100  break;
      7101  }
      7102  }
      7103  }
      7104 
      7105  if(res == VK_SUCCESS)
      7106  {
      7107  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
      7108  VMA_ASSERT(pBlock->m_Metadata.GetSize() >= size);
      7109 
      7110  if(mapped)
      7111  {
      7112  res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
      7113  if(res != VK_SUCCESS)
      7114  {
      7115  return res;
      7116  }
      7117  }
      7118 
      7119  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
      7120  VmaAllocationRequest allocRequest;
      7121  if(pBlock->m_Metadata.CreateAllocationRequest(
      7122  currentFrameIndex,
      7123  m_FrameInUseCount,
      7124  m_BufferImageGranularity,
      7125  size,
      7126  alignment,
      7127  suballocType,
      7128  false, // canMakeOtherLost
      7129  &allocRequest))
      7130  {
      7131  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
      7132  pBlock->m_Metadata.Alloc(allocRequest, suballocType, size, *pAllocation);
      7133  (*pAllocation)->InitBlockAllocation(
      7134  hCurrentPool,
      7135  pBlock,
      7136  allocRequest.offset,
      7137  alignment,
      7138  size,
      7139  suballocType,
      7140  mapped,
      7141  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      7142  VMA_HEAVY_ASSERT(pBlock->Validate());
      7143  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
      7144  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      7145  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      7146  {
      7147  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      7148  }
      7149  if(IsCorruptionDetectionEnabled())
      7150  {
      7151  res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, allocRequest.offset, size);
      7152  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      7153  }
      7154  return VK_SUCCESS;
      7155  }
      7156  else
      7157  {
      7158  // Allocation from empty block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
      7159  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      7160  }
      7161  }
      7162  }
      7163 
      7164  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
      7165 
      7166  // 3. Try to allocate from existing blocks with making other allocations lost.
      7167  if(canMakeOtherLost)
      7168  {
      7169  uint32_t tryIndex = 0;
      7170  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
      7171  {
      7172  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
      7173  VmaAllocationRequest bestRequest = {};
      7174  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
      7175 
      7176  // 1. Search existing allocations.
      7177  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      7178  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      7179  {
      7180  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      7181  VMA_ASSERT(pCurrBlock);
      7182  VmaAllocationRequest currRequest = {};
      7183  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
      7184  currentFrameIndex,
      7185  m_FrameInUseCount,
      7186  m_BufferImageGranularity,
      7187  size,
      7188  alignment,
      7189  suballocType,
      7190  canMakeOtherLost,
      7191  &currRequest))
      7192  {
      7193  const VkDeviceSize currRequestCost = currRequest.CalcCost();
      7194  if(pBestRequestBlock == VMA_NULL ||
      7195  currRequestCost < bestRequestCost)
      7196  {
      7197  pBestRequestBlock = pCurrBlock;
      7198  bestRequest = currRequest;
      7199  bestRequestCost = currRequestCost;
      7200 
      7201  if(bestRequestCost == 0)
      7202  {
      7203  break;
      7204  }
      7205  }
      7206  }
      7207  }
      7208 
      7209  if(pBestRequestBlock != VMA_NULL)
      7210  {
      7211  if(mapped)
      7212  {
      7213  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
      7214  if(res != VK_SUCCESS)
      7215  {
      7216  return res;
      7217  }
      7218  }
      7219 
      7220  if(pBestRequestBlock->m_Metadata.MakeRequestedAllocationsLost(
      7221  currentFrameIndex,
      7222  m_FrameInUseCount,
      7223  &bestRequest))
      7224  {
      7225  // We no longer have an empty Allocation.
      7226  if(pBestRequestBlock->m_Metadata.IsEmpty())
      7227  {
      7228  m_HasEmptyBlock = false;
      7229  }
      7230  // Allocate from this pBlock.
      7231  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
      7232  pBestRequestBlock->m_Metadata.Alloc(bestRequest, suballocType, size, *pAllocation);
      7233  (*pAllocation)->InitBlockAllocation(
      7234  hCurrentPool,
      7235  pBestRequestBlock,
      7236  bestRequest.offset,
      7237  alignment,
      7238  size,
      7239  suballocType,
      7240  mapped,
      7241  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      7242  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
      7243  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
      7244  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      7245  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      7246  {
      7247  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      7248  }
      7249  if(IsCorruptionDetectionEnabled())
      7250  {
      7251  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
      7252  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      7253  }
      7254  return VK_SUCCESS;
      7255  }
      7256  // else: Some allocations must have been touched while we are here. Next try.
      7257  }
      7258  else
      7259  {
      7260  // Could not find place in any of the blocks - break outer loop.
      7261  break;
      7262  }
      7263  }
      7264  /* Maximum number of tries exceeded - a very unlike event when many other
      7265  threads are simultaneously touching allocations making it impossible to make
      7266  lost at the same time as we try to allocate. */
      7267  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
      7268  {
      7269  return VK_ERROR_TOO_MANY_OBJECTS;
      7270  }
      7271  }
      7272 
      7273  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      7274 }
      7275 
      7276 void VmaBlockVector::Free(
      7277  VmaAllocation hAllocation)
      7278 {
      7279  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
      7280 
      7281  // Scope for lock.
      7282  {
      7283  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7284 
      7285  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      7286 
      7287  if(IsCorruptionDetectionEnabled())
      7288  {
      7289  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
      7290  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
      7291  }
      7292 
      7293  if(hAllocation->IsPersistentMap())
      7294  {
      7295  pBlock->Unmap(m_hAllocator, 1);
      7296  }
      7297 
      7298  pBlock->m_Metadata.Free(hAllocation);
      7299  VMA_HEAVY_ASSERT(pBlock->Validate());
      7300 
      7301  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
      7302 
      7303  // pBlock became empty after this deallocation.
      7304  if(pBlock->m_Metadata.IsEmpty())
      7305  {
      7306  // Already has empty Allocation. We don't want to have two, so delete this one.
      7307  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
      7308  {
      7309  pBlockToDelete = pBlock;
      7310  Remove(pBlock);
      7311  }
      7312  // We now have first empty block.
      7313  else
      7314  {
      7315  m_HasEmptyBlock = true;
      7316  }
      7317  }
      7318  // pBlock didn't become empty, but we have another empty block - find and free that one.
      7319  // (This is optional, heuristics.)
      7320  else if(m_HasEmptyBlock)
      7321  {
      7322  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
      7323  if(pLastBlock->m_Metadata.IsEmpty() && m_Blocks.size() > m_MinBlockCount)
      7324  {
      7325  pBlockToDelete = pLastBlock;
      7326  m_Blocks.pop_back();
      7327  m_HasEmptyBlock = false;
      7328  }
      7329  }
      7330 
      7331  IncrementallySortBlocks();
      7332  }
      7333 
      7334  // Destruction of a free Allocation. Deferred until this point, outside of mutex
      7335  // lock, for performance reason.
      7336  if(pBlockToDelete != VMA_NULL)
      7337  {
      7338  VMA_DEBUG_LOG(" Deleted empty allocation");
      7339  pBlockToDelete->Destroy(m_hAllocator);
      7340  vma_delete(m_hAllocator, pBlockToDelete);
      7341  }
      7342 }
      7343 
      7344 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
      7345 {
      7346  VkDeviceSize result = 0;
      7347  for(size_t i = m_Blocks.size(); i--; )
      7348  {
      7349  result = VMA_MAX(result, m_Blocks[i]->m_Metadata.GetSize());
      7350  if(result >= m_PreferredBlockSize)
      7351  {
      7352  break;
      7353  }
      7354  }
      7355  return result;
      7356 }
      7357 
      7358 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
      7359 {
      7360  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7361  {
      7362  if(m_Blocks[blockIndex] == pBlock)
      7363  {
      7364  VmaVectorRemove(m_Blocks, blockIndex);
      7365  return;
      7366  }
      7367  }
      7368  VMA_ASSERT(0);
      7369 }
      7370 
      7371 void VmaBlockVector::IncrementallySortBlocks()
      7372 {
      7373  // Bubble sort only until first swap.
      7374  for(size_t i = 1; i < m_Blocks.size(); ++i)
      7375  {
      7376  if(m_Blocks[i - 1]->m_Metadata.GetSumFreeSize() > m_Blocks[i]->m_Metadata.GetSumFreeSize())
      7377  {
      7378  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
      7379  return;
      7380  }
      7381  }
      7382 }
      7383 
      7384 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
      7385 {
      7386  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      7387  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
      7388  allocInfo.allocationSize = blockSize;
      7389  VkDeviceMemory mem = VK_NULL_HANDLE;
      7390  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
      7391  if(res < 0)
      7392  {
      7393  return res;
      7394  }
      7395 
      7396  // New VkDeviceMemory successfully created.
      7397 
      7398  // Create new Allocation for it.
      7399  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
      7400  pBlock->Init(
      7401  m_MemoryTypeIndex,
      7402  mem,
      7403  allocInfo.allocationSize,
      7404  m_NextBlockId++);
      7405 
      7406  m_Blocks.push_back(pBlock);
      7407  if(pNewBlockIndex != VMA_NULL)
      7408  {
      7409  *pNewBlockIndex = m_Blocks.size() - 1;
      7410  }
      7411 
      7412  return VK_SUCCESS;
      7413 }
      7414 
      7415 #if VMA_STATS_STRING_ENABLED
      7416 
      7417 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
      7418 {
      7419  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7420 
      7421  json.BeginObject();
      7422 
      7423  if(m_IsCustomPool)
      7424  {
      7425  json.WriteString("MemoryTypeIndex");
      7426  json.WriteNumber(m_MemoryTypeIndex);
      7427 
      7428  json.WriteString("BlockSize");
      7429  json.WriteNumber(m_PreferredBlockSize);
      7430 
      7431  json.WriteString("BlockCount");
      7432  json.BeginObject(true);
      7433  if(m_MinBlockCount > 0)
      7434  {
      7435  json.WriteString("Min");
      7436  json.WriteNumber((uint64_t)m_MinBlockCount);
      7437  }
      7438  if(m_MaxBlockCount < SIZE_MAX)
      7439  {
      7440  json.WriteString("Max");
      7441  json.WriteNumber((uint64_t)m_MaxBlockCount);
      7442  }
      7443  json.WriteString("Cur");
      7444  json.WriteNumber((uint64_t)m_Blocks.size());
      7445  json.EndObject();
      7446 
      7447  if(m_FrameInUseCount > 0)
      7448  {
      7449  json.WriteString("FrameInUseCount");
      7450  json.WriteNumber(m_FrameInUseCount);
      7451  }
      7452  }
      7453  else
      7454  {
      7455  json.WriteString("PreferredBlockSize");
      7456  json.WriteNumber(m_PreferredBlockSize);
      7457  }
      7458 
      7459  json.WriteString("Blocks");
      7460  json.BeginObject();
      7461  for(size_t i = 0; i < m_Blocks.size(); ++i)
      7462  {
      7463  json.BeginString();
      7464  json.ContinueString(m_Blocks[i]->GetId());
      7465  json.EndString();
      7466 
      7467  m_Blocks[i]->m_Metadata.PrintDetailedMap(json);
      7468  }
      7469  json.EndObject();
      7470 
      7471  json.EndObject();
      7472 }
      7473 
      7474 #endif // #if VMA_STATS_STRING_ENABLED
      7475 
      7476 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
      7477  VmaAllocator hAllocator,
      7478  uint32_t currentFrameIndex)
      7479 {
      7480  if(m_pDefragmentator == VMA_NULL)
      7481  {
      7482  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
      7483  hAllocator,
      7484  this,
      7485  currentFrameIndex);
      7486  }
      7487 
      7488  return m_pDefragmentator;
      7489 }
      7490 
      7491 VkResult VmaBlockVector::Defragment(
      7492  VmaDefragmentationStats* pDefragmentationStats,
      7493  VkDeviceSize& maxBytesToMove,
      7494  uint32_t& maxAllocationsToMove)
      7495 {
      7496  if(m_pDefragmentator == VMA_NULL)
      7497  {
      7498  return VK_SUCCESS;
      7499  }
      7500 
      7501  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7502 
      7503  // Defragment.
      7504  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
      7505 
      7506  // Accumulate statistics.
      7507  if(pDefragmentationStats != VMA_NULL)
      7508  {
      7509  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
      7510  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
      7511  pDefragmentationStats->bytesMoved += bytesMoved;
      7512  pDefragmentationStats->allocationsMoved += allocationsMoved;
      7513  VMA_ASSERT(bytesMoved <= maxBytesToMove);
      7514  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
      7515  maxBytesToMove -= bytesMoved;
      7516  maxAllocationsToMove -= allocationsMoved;
      7517  }
      7518 
      7519  // Free empty blocks.
      7520  m_HasEmptyBlock = false;
      7521  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      7522  {
      7523  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      7524  if(pBlock->m_Metadata.IsEmpty())
      7525  {
      7526  if(m_Blocks.size() > m_MinBlockCount)
      7527  {
      7528  if(pDefragmentationStats != VMA_NULL)
      7529  {
      7530  ++pDefragmentationStats->deviceMemoryBlocksFreed;
      7531  pDefragmentationStats->bytesFreed += pBlock->m_Metadata.GetSize();
      7532  }
      7533 
      7534  VmaVectorRemove(m_Blocks, blockIndex);
      7535  pBlock->Destroy(m_hAllocator);
      7536  vma_delete(m_hAllocator, pBlock);
      7537  }
      7538  else
      7539  {
      7540  m_HasEmptyBlock = true;
      7541  }
      7542  }
      7543  }
      7544 
      7545  return result;
      7546 }
      7547 
      7548 void VmaBlockVector::DestroyDefragmentator()
      7549 {
      7550  if(m_pDefragmentator != VMA_NULL)
      7551  {
      7552  vma_delete(m_hAllocator, m_pDefragmentator);
      7553  m_pDefragmentator = VMA_NULL;
      7554  }
      7555 }
      7556 
      7557 void VmaBlockVector::MakePoolAllocationsLost(
      7558  uint32_t currentFrameIndex,
      7559  size_t* pLostAllocationCount)
      7560 {
      7561  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7562  size_t lostAllocationCount = 0;
      7563  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7564  {
      7565  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7566  VMA_ASSERT(pBlock);
      7567  lostAllocationCount += pBlock->m_Metadata.MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
      7568  }
      7569  if(pLostAllocationCount != VMA_NULL)
      7570  {
      7571  *pLostAllocationCount = lostAllocationCount;
      7572  }
      7573 }
      7574 
      7575 VkResult VmaBlockVector::CheckCorruption()
      7576 {
      7577  if(!IsCorruptionDetectionEnabled())
      7578  {
      7579  return VK_ERROR_FEATURE_NOT_PRESENT;
      7580  }
      7581 
      7582  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7583  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7584  {
      7585  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7586  VMA_ASSERT(pBlock);
      7587  VkResult res = pBlock->CheckCorruption(m_hAllocator);
      7588  if(res != VK_SUCCESS)
      7589  {
      7590  return res;
      7591  }
      7592  }
      7593  return VK_SUCCESS;
      7594 }
      7595 
      7596 void VmaBlockVector::AddStats(VmaStats* pStats)
      7597 {
      7598  const uint32_t memTypeIndex = m_MemoryTypeIndex;
      7599  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
      7600 
      7601  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7602 
      7603  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7604  {
      7605  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7606  VMA_ASSERT(pBlock);
      7607  VMA_HEAVY_ASSERT(pBlock->Validate());
      7608  VmaStatInfo allocationStatInfo;
      7609  pBlock->m_Metadata.CalcAllocationStatInfo(allocationStatInfo);
      7610  VmaAddStatInfo(pStats->total, allocationStatInfo);
      7611  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      7612  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      7613  }
      7614 }
      7615 
      7617 // VmaDefragmentator members definition
      7618 
      7619 VmaDefragmentator::VmaDefragmentator(
      7620  VmaAllocator hAllocator,
      7621  VmaBlockVector* pBlockVector,
      7622  uint32_t currentFrameIndex) :
      7623  m_hAllocator(hAllocator),
      7624  m_pBlockVector(pBlockVector),
      7625  m_CurrentFrameIndex(currentFrameIndex),
      7626  m_BytesMoved(0),
      7627  m_AllocationsMoved(0),
      7628  m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),
      7629  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
      7630 {
      7631 }
      7632 
      7633 VmaDefragmentator::~VmaDefragmentator()
      7634 {
      7635  for(size_t i = m_Blocks.size(); i--; )
      7636  {
      7637  vma_delete(m_hAllocator, m_Blocks[i]);
      7638  }
      7639 }
      7640 
      7641 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
      7642 {
      7643  AllocationInfo allocInfo;
      7644  allocInfo.m_hAllocation = hAlloc;
      7645  allocInfo.m_pChanged = pChanged;
      7646  m_Allocations.push_back(allocInfo);
      7647 }
      7648 
      7649 VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)
      7650 {
      7651  // It has already been mapped for defragmentation.
      7652  if(m_pMappedDataForDefragmentation)
      7653  {
      7654  *ppMappedData = m_pMappedDataForDefragmentation;
      7655  return VK_SUCCESS;
      7656  }
      7657 
      7658  // It is originally mapped.
      7659  if(m_pBlock->GetMappedData())
      7660  {
      7661  *ppMappedData = m_pBlock->GetMappedData();
      7662  return VK_SUCCESS;
      7663  }
      7664 
      7665  // Map on first usage.
      7666  VkResult res = m_pBlock->Map(hAllocator, 1, &m_pMappedDataForDefragmentation);
      7667  *ppMappedData = m_pMappedDataForDefragmentation;
      7668  return res;
      7669 }
      7670 
      7671 void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)
      7672 {
      7673  if(m_pMappedDataForDefragmentation != VMA_NULL)
      7674  {
      7675  m_pBlock->Unmap(hAllocator, 1);
      7676  }
      7677 }
      7678 
      7679 VkResult VmaDefragmentator::DefragmentRound(
      7680  VkDeviceSize maxBytesToMove,
      7681  uint32_t maxAllocationsToMove)
      7682 {
      7683  if(m_Blocks.empty())
      7684  {
      7685  return VK_SUCCESS;
      7686  }
      7687 
      7688  size_t srcBlockIndex = m_Blocks.size() - 1;
      7689  size_t srcAllocIndex = SIZE_MAX;
      7690  for(;;)
      7691  {
      7692  // 1. Find next allocation to move.
      7693  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
      7694  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
      7695  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
      7696  {
      7697  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
      7698  {
      7699  // Finished: no more allocations to process.
      7700  if(srcBlockIndex == 0)
      7701  {
      7702  return VK_SUCCESS;
      7703  }
      7704  else
      7705  {
      7706  --srcBlockIndex;
      7707  srcAllocIndex = SIZE_MAX;
      7708  }
      7709  }
      7710  else
      7711  {
      7712  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
      7713  }
      7714  }
      7715 
      7716  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
      7717  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
      7718 
      7719  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
      7720  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
      7721  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
      7722  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
      7723 
      7724  // 2. Try to find new place for this allocation in preceding or current block.
      7725  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
      7726  {
      7727  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
      7728  VmaAllocationRequest dstAllocRequest;
      7729  if(pDstBlockInfo->m_pBlock->m_Metadata.CreateAllocationRequest(
      7730  m_CurrentFrameIndex,
      7731  m_pBlockVector->GetFrameInUseCount(),
      7732  m_pBlockVector->GetBufferImageGranularity(),
      7733  size,
      7734  alignment,
      7735  suballocType,
      7736  false, // canMakeOtherLost
      7737  &dstAllocRequest) &&
      7738  MoveMakesSense(
      7739  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
      7740  {
      7741  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
      7742 
      7743  // Reached limit on number of allocations or bytes to move.
      7744  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
      7745  (m_BytesMoved + size > maxBytesToMove))
      7746  {
      7747  return VK_INCOMPLETE;
      7748  }
      7749 
      7750  void* pDstMappedData = VMA_NULL;
      7751  VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);
      7752  if(res != VK_SUCCESS)
      7753  {
      7754  return res;
      7755  }
      7756 
      7757  void* pSrcMappedData = VMA_NULL;
      7758  res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);
      7759  if(res != VK_SUCCESS)
      7760  {
      7761  return res;
      7762  }
      7763 
      7764  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
      7765  memcpy(
      7766  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
      7767  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
      7768  static_cast<size_t>(size));
      7769 
      7770  if(VMA_DEBUG_MARGIN > 0)
      7771  {
      7772  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset - VMA_DEBUG_MARGIN);
      7773  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset + size);
      7774  }
      7775 
      7776  pDstBlockInfo->m_pBlock->m_Metadata.Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);
      7777  pSrcBlockInfo->m_pBlock->m_Metadata.FreeAtOffset(srcOffset);
      7778 
      7779  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
      7780 
      7781  if(allocInfo.m_pChanged != VMA_NULL)
      7782  {
      7783  *allocInfo.m_pChanged = VK_TRUE;
      7784  }
      7785 
      7786  ++m_AllocationsMoved;
      7787  m_BytesMoved += size;
      7788 
      7789  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
      7790 
      7791  break;
      7792  }
      7793  }
      7794 
      7795  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
      7796 
      7797  if(srcAllocIndex > 0)
      7798  {
      7799  --srcAllocIndex;
      7800  }
      7801  else
      7802  {
      7803  if(srcBlockIndex > 0)
      7804  {
      7805  --srcBlockIndex;
      7806  srcAllocIndex = SIZE_MAX;
      7807  }
      7808  else
      7809  {
      7810  return VK_SUCCESS;
      7811  }
      7812  }
      7813  }
      7814 }
      7815 
      7816 VkResult VmaDefragmentator::Defragment(
      7817  VkDeviceSize maxBytesToMove,
      7818  uint32_t maxAllocationsToMove)
      7819 {
      7820  if(m_Allocations.empty())
      7821  {
      7822  return VK_SUCCESS;
      7823  }
      7824 
      7825  // Create block info for each block.
      7826  const size_t blockCount = m_pBlockVector->m_Blocks.size();
      7827  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      7828  {
      7829  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
      7830  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
      7831  m_Blocks.push_back(pBlockInfo);
      7832  }
      7833 
      7834  // Sort them by m_pBlock pointer value.
      7835  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
      7836 
      7837  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
      7838  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
      7839  {
      7840  AllocationInfo& allocInfo = m_Allocations[blockIndex];
      7841  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
      7842  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
      7843  {
      7844  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
      7845  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
      7846  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
      7847  {
      7848  (*it)->m_Allocations.push_back(allocInfo);
      7849  }
      7850  else
      7851  {
      7852  VMA_ASSERT(0);
      7853  }
      7854  }
      7855  }
      7856  m_Allocations.clear();
      7857 
      7858  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      7859  {
      7860  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
      7861  pBlockInfo->CalcHasNonMovableAllocations();
      7862  pBlockInfo->SortAllocationsBySizeDescecnding();
      7863  }
      7864 
      7865  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
      7866  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
      7867 
      7868  // Execute defragmentation rounds (the main part).
      7869  VkResult result = VK_SUCCESS;
      7870  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
      7871  {
      7872  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
      7873  }
      7874 
      7875  // Unmap blocks that were mapped for defragmentation.
      7876  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      7877  {
      7878  m_Blocks[blockIndex]->Unmap(m_hAllocator);
      7879  }
      7880 
      7881  return result;
      7882 }
      7883 
      7884 bool VmaDefragmentator::MoveMakesSense(
      7885  size_t dstBlockIndex, VkDeviceSize dstOffset,
      7886  size_t srcBlockIndex, VkDeviceSize srcOffset)
      7887 {
      7888  if(dstBlockIndex < srcBlockIndex)
      7889  {
      7890  return true;
      7891  }
      7892  if(dstBlockIndex > srcBlockIndex)
      7893  {
      7894  return false;
      7895  }
      7896  if(dstOffset < srcOffset)
      7897  {
      7898  return true;
      7899  }
      7900  return false;
      7901 }
      7902 
      7904 // VmaAllocator_T
      7905 
      7906 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
      7907  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
      7908  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
      7909  m_hDevice(pCreateInfo->device),
      7910  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
      7911  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
      7912  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
      7913  m_PreferredLargeHeapBlockSize(0),
      7914  m_PhysicalDevice(pCreateInfo->physicalDevice),
      7915  m_CurrentFrameIndex(0),
      7916  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
      7917  m_NextPoolId(0)
      7918 {
      7919  if(VMA_DEBUG_DETECT_CORRUPTION)
      7920  {
      7921  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
      7922  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
      7923  }
      7924 
      7925  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
      7926 
      7927 #if !(VMA_DEDICATED_ALLOCATION)
      7928  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
      7929  {
      7930  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
      7931  }
      7932 #endif
      7933 
      7934  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
      7935  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
      7936  memset(&m_MemProps, 0, sizeof(m_MemProps));
      7937 
      7938  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
      7939  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
      7940 
      7941  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
      7942  {
      7943  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
      7944  }
      7945 
      7946  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
      7947  {
      7948  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
      7949  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
      7950  }
      7951 
      7952  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
      7953 
      7954  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
      7955  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
      7956 
      7957  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
      7958  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      7959 
      7960  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
      7961  {
      7962  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
      7963  {
      7964  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
      7965  if(limit != VK_WHOLE_SIZE)
      7966  {
      7967  m_HeapSizeLimit[heapIndex] = limit;
      7968  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
      7969  {
      7970  m_MemProps.memoryHeaps[heapIndex].size = limit;
      7971  }
      7972  }
      7973  }
      7974  }
      7975 
      7976  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      7977  {
      7978  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
      7979 
      7980  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
      7981  this,
      7982  memTypeIndex,
      7983  preferredBlockSize,
      7984  0,
      7985  SIZE_MAX,
      7986  GetBufferImageGranularity(),
      7987  pCreateInfo->frameInUseCount,
      7988  false); // isCustomPool
      7989  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
      7990  // becase minBlockCount is 0.
      7991  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
      7992 
      7993  }
      7994 }
      7995 
      7996 VmaAllocator_T::~VmaAllocator_T()
      7997 {
      7998  VMA_ASSERT(m_Pools.empty());
      7999 
      8000  for(size_t i = GetMemoryTypeCount(); i--; )
      8001  {
      8002  vma_delete(this, m_pDedicatedAllocations[i]);
      8003  vma_delete(this, m_pBlockVectors[i]);
      8004  }
      8005 }
      8006 
      8007 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
      8008 {
      8009 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      8010  m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;
      8011  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;
      8012  m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
      8013  m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;
      8014  m_VulkanFunctions.vkMapMemory = &vkMapMemory;
      8015  m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;
      8016  m_VulkanFunctions.vkFlushMappedMemoryRanges = &vkFlushMappedMemoryRanges;
      8017  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = &vkInvalidateMappedMemoryRanges;
      8018  m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;
      8019  m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;
      8020  m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;
      8021  m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;
      8022  m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;
      8023  m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;
      8024  m_VulkanFunctions.vkCreateImage = &vkCreateImage;
      8025  m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;
      8026 #if VMA_DEDICATED_ALLOCATION
      8027  if(m_UseKhrDedicatedAllocation)
      8028  {
      8029  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
      8030  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
      8031  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
      8032  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
      8033  }
      8034 #endif // #if VMA_DEDICATED_ALLOCATION
      8035 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      8036 
      8037 #define VMA_COPY_IF_NOT_NULL(funcName) \
      8038  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
      8039 
      8040  if(pVulkanFunctions != VMA_NULL)
      8041  {
      8042  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
      8043  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
      8044  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
      8045  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
      8046  VMA_COPY_IF_NOT_NULL(vkMapMemory);
      8047  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
      8048  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
      8049  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
      8050  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
      8051  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
      8052  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
      8053  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
      8054  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
      8055  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
      8056  VMA_COPY_IF_NOT_NULL(vkCreateImage);
      8057  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
      8058 #if VMA_DEDICATED_ALLOCATION
      8059  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
      8060  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
      8061 #endif
      8062  }
      8063 
      8064 #undef VMA_COPY_IF_NOT_NULL
      8065 
      8066  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
      8067  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
      8068  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
      8069  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
      8070  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
      8071  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
      8072  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
      8073  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
      8074  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
      8075  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
      8076  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
      8077  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
      8078  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
      8079  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
      8080  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
      8081  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
      8082  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
      8083  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
      8084 #if VMA_DEDICATED_ALLOCATION
      8085  if(m_UseKhrDedicatedAllocation)
      8086  {
      8087  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
      8088  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
      8089  }
      8090 #endif
      8091 }
      8092 
      8093 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
      8094 {
      8095  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      8096  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
      8097  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
      8098  return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
      8099 }
      8100 
      8101 VkResult VmaAllocator_T::AllocateMemoryOfType(
      8102  VkDeviceSize size,
      8103  VkDeviceSize alignment,
      8104  bool dedicatedAllocation,
      8105  VkBuffer dedicatedBuffer,
      8106  VkImage dedicatedImage,
      8107  const VmaAllocationCreateInfo& createInfo,
      8108  uint32_t memTypeIndex,
      8109  VmaSuballocationType suballocType,
      8110  VmaAllocation* pAllocation)
      8111 {
      8112  VMA_ASSERT(pAllocation != VMA_NULL);
      8113  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
      8114 
      8115  VmaAllocationCreateInfo finalCreateInfo = createInfo;
      8116 
      8117  // If memory type is not HOST_VISIBLE, disable MAPPED.
      8118  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      8119  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      8120  {
      8121  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
      8122  }
      8123 
      8124  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
      8125  VMA_ASSERT(blockVector);
      8126 
      8127  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
      8128  bool preferDedicatedMemory =
      8129  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
      8130  dedicatedAllocation ||
      8131  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
      8132  size > preferredBlockSize / 2;
      8133 
      8134  if(preferDedicatedMemory &&
      8135  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
      8136  finalCreateInfo.pool == VK_NULL_HANDLE)
      8137  {
      8138  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
      8139  }
      8140 
      8141  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
      8142  {
      8143  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      8144  {
      8145  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8146  }
      8147  else
      8148  {
      8149  return AllocateDedicatedMemory(
      8150  size,
      8151  suballocType,
      8152  memTypeIndex,
      8153  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      8154  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      8155  finalCreateInfo.pUserData,
      8156  dedicatedBuffer,
      8157  dedicatedImage,
      8158  pAllocation);
      8159  }
      8160  }
      8161  else
      8162  {
      8163  VkResult res = blockVector->Allocate(
      8164  VK_NULL_HANDLE, // hCurrentPool
      8165  m_CurrentFrameIndex.load(),
      8166  size,
      8167  alignment,
      8168  finalCreateInfo,
      8169  suballocType,
      8170  pAllocation);
      8171  if(res == VK_SUCCESS)
      8172  {
      8173  return res;
      8174  }
      8175 
      8176  // 5. Try dedicated memory.
      8177  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      8178  {
      8179  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8180  }
      8181  else
      8182  {
      8183  res = AllocateDedicatedMemory(
      8184  size,
      8185  suballocType,
      8186  memTypeIndex,
      8187  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      8188  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      8189  finalCreateInfo.pUserData,
      8190  dedicatedBuffer,
      8191  dedicatedImage,
      8192  pAllocation);
      8193  if(res == VK_SUCCESS)
      8194  {
      8195  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
      8196  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
      8197  return VK_SUCCESS;
      8198  }
      8199  else
      8200  {
      8201  // Everything failed: Return error code.
      8202  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      8203  return res;
      8204  }
      8205  }
      8206  }
      8207 }
      8208 
      8209 VkResult VmaAllocator_T::AllocateDedicatedMemory(
      8210  VkDeviceSize size,
      8211  VmaSuballocationType suballocType,
      8212  uint32_t memTypeIndex,
      8213  bool map,
      8214  bool isUserDataString,
      8215  void* pUserData,
      8216  VkBuffer dedicatedBuffer,
      8217  VkImage dedicatedImage,
      8218  VmaAllocation* pAllocation)
      8219 {
      8220  VMA_ASSERT(pAllocation);
      8221 
      8222  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      8223  allocInfo.memoryTypeIndex = memTypeIndex;
      8224  allocInfo.allocationSize = size;
      8225 
      8226 #if VMA_DEDICATED_ALLOCATION
      8227  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
      8228  if(m_UseKhrDedicatedAllocation)
      8229  {
      8230  if(dedicatedBuffer != VK_NULL_HANDLE)
      8231  {
      8232  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
      8233  dedicatedAllocInfo.buffer = dedicatedBuffer;
      8234  allocInfo.pNext = &dedicatedAllocInfo;
      8235  }
      8236  else if(dedicatedImage != VK_NULL_HANDLE)
      8237  {
      8238  dedicatedAllocInfo.image = dedicatedImage;
      8239  allocInfo.pNext = &dedicatedAllocInfo;
      8240  }
      8241  }
      8242 #endif // #if VMA_DEDICATED_ALLOCATION
      8243 
      8244  // Allocate VkDeviceMemory.
      8245  VkDeviceMemory hMemory = VK_NULL_HANDLE;
      8246  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
      8247  if(res < 0)
      8248  {
      8249  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      8250  return res;
      8251  }
      8252 
      8253  void* pMappedData = VMA_NULL;
      8254  if(map)
      8255  {
      8256  res = (*m_VulkanFunctions.vkMapMemory)(
      8257  m_hDevice,
      8258  hMemory,
      8259  0,
      8260  VK_WHOLE_SIZE,
      8261  0,
      8262  &pMappedData);
      8263  if(res < 0)
      8264  {
      8265  VMA_DEBUG_LOG(" vkMapMemory FAILED");
      8266  FreeVulkanMemory(memTypeIndex, size, hMemory);
      8267  return res;
      8268  }
      8269  }
      8270 
      8271  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
      8272  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
      8273  (*pAllocation)->SetUserData(this, pUserData);
      8274  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      8275  {
      8276  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      8277  }
      8278 
      8279  // Register it in m_pDedicatedAllocations.
      8280  {
      8281  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      8282  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      8283  VMA_ASSERT(pDedicatedAllocations);
      8284  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);
      8285  }
      8286 
      8287  VMA_DEBUG_LOG(" Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
      8288 
      8289  return VK_SUCCESS;
      8290 }
      8291 
      8292 void VmaAllocator_T::GetBufferMemoryRequirements(
      8293  VkBuffer hBuffer,
      8294  VkMemoryRequirements& memReq,
      8295  bool& requiresDedicatedAllocation,
      8296  bool& prefersDedicatedAllocation) const
      8297 {
      8298 #if VMA_DEDICATED_ALLOCATION
      8299  if(m_UseKhrDedicatedAllocation)
      8300  {
      8301  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
      8302  memReqInfo.buffer = hBuffer;
      8303 
      8304  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      8305 
      8306  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      8307  memReq2.pNext = &memDedicatedReq;
      8308 
      8309  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      8310 
      8311  memReq = memReq2.memoryRequirements;
      8312  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      8313  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      8314  }
      8315  else
      8316 #endif // #if VMA_DEDICATED_ALLOCATION
      8317  {
      8318  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
      8319  requiresDedicatedAllocation = false;
      8320  prefersDedicatedAllocation = false;
      8321  }
      8322 }
      8323 
      8324 void VmaAllocator_T::GetImageMemoryRequirements(
      8325  VkImage hImage,
      8326  VkMemoryRequirements& memReq,
      8327  bool& requiresDedicatedAllocation,
      8328  bool& prefersDedicatedAllocation) const
      8329 {
      8330 #if VMA_DEDICATED_ALLOCATION
      8331  if(m_UseKhrDedicatedAllocation)
      8332  {
      8333  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
      8334  memReqInfo.image = hImage;
      8335 
      8336  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      8337 
      8338  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      8339  memReq2.pNext = &memDedicatedReq;
      8340 
      8341  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      8342 
      8343  memReq = memReq2.memoryRequirements;
      8344  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      8345  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      8346  }
      8347  else
      8348 #endif // #if VMA_DEDICATED_ALLOCATION
      8349  {
      8350  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
      8351  requiresDedicatedAllocation = false;
      8352  prefersDedicatedAllocation = false;
      8353  }
      8354 }
      8355 
      8356 VkResult VmaAllocator_T::AllocateMemory(
      8357  const VkMemoryRequirements& vkMemReq,
      8358  bool requiresDedicatedAllocation,
      8359  bool prefersDedicatedAllocation,
      8360  VkBuffer dedicatedBuffer,
      8361  VkImage dedicatedImage,
      8362  const VmaAllocationCreateInfo& createInfo,
      8363  VmaSuballocationType suballocType,
      8364  VmaAllocation* pAllocation)
      8365 {
      8366  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
      8367  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      8368  {
      8369  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
      8370  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8371  }
      8372  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      8373  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
      8374  {
      8375  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
      8376  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8377  }
      8378  if(requiresDedicatedAllocation)
      8379  {
      8380  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      8381  {
      8382  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
      8383  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8384  }
      8385  if(createInfo.pool != VK_NULL_HANDLE)
      8386  {
      8387  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
      8388  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8389  }
      8390  }
      8391  if((createInfo.pool != VK_NULL_HANDLE) &&
      8392  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
      8393  {
      8394  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
      8395  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8396  }
      8397 
      8398  if(createInfo.pool != VK_NULL_HANDLE)
      8399  {
      8400  const VkDeviceSize alignmentForPool = VMA_MAX(
      8401  vkMemReq.alignment,
      8402  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
      8403  return createInfo.pool->m_BlockVector.Allocate(
      8404  createInfo.pool,
      8405  m_CurrentFrameIndex.load(),
      8406  vkMemReq.size,
      8407  alignmentForPool,
      8408  createInfo,
      8409  suballocType,
      8410  pAllocation);
      8411  }
      8412  else
      8413  {
      8414  // Bit mask of memory Vulkan types acceptable for this allocation.
      8415  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
      8416  uint32_t memTypeIndex = UINT32_MAX;
      8417  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      8418  if(res == VK_SUCCESS)
      8419  {
      8420  VkDeviceSize alignmentForMemType = VMA_MAX(
      8421  vkMemReq.alignment,
      8422  GetMemoryTypeMinAlignment(memTypeIndex));
      8423 
      8424  res = AllocateMemoryOfType(
      8425  vkMemReq.size,
      8426  alignmentForMemType,
      8427  requiresDedicatedAllocation || prefersDedicatedAllocation,
      8428  dedicatedBuffer,
      8429  dedicatedImage,
      8430  createInfo,
      8431  memTypeIndex,
      8432  suballocType,
      8433  pAllocation);
      8434  // Succeeded on first try.
      8435  if(res == VK_SUCCESS)
      8436  {
      8437  return res;
      8438  }
      8439  // Allocation from this memory type failed. Try other compatible memory types.
      8440  else
      8441  {
      8442  for(;;)
      8443  {
      8444  // Remove old memTypeIndex from list of possibilities.
      8445  memoryTypeBits &= ~(1u << memTypeIndex);
      8446  // Find alternative memTypeIndex.
      8447  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      8448  if(res == VK_SUCCESS)
      8449  {
      8450  alignmentForMemType = VMA_MAX(
      8451  vkMemReq.alignment,
      8452  GetMemoryTypeMinAlignment(memTypeIndex));
      8453 
      8454  res = AllocateMemoryOfType(
      8455  vkMemReq.size,
      8456  alignmentForMemType,
      8457  requiresDedicatedAllocation || prefersDedicatedAllocation,
      8458  dedicatedBuffer,
      8459  dedicatedImage,
      8460  createInfo,
      8461  memTypeIndex,
      8462  suballocType,
      8463  pAllocation);
      8464  // Allocation from this alternative memory type succeeded.
      8465  if(res == VK_SUCCESS)
      8466  {
      8467  return res;
      8468  }
      8469  // else: Allocation from this memory type failed. Try next one - next loop iteration.
      8470  }
      8471  // No other matching memory type index could be found.
      8472  else
      8473  {
      8474  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
      8475  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8476  }
      8477  }
      8478  }
      8479  }
      8480  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
      8481  else
      8482  return res;
      8483  }
      8484 }
      8485 
      8486 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
      8487 {
      8488  VMA_ASSERT(allocation);
      8489 
      8490  if(allocation->CanBecomeLost() == false ||
      8491  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
      8492  {
      8493  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      8494  {
      8495  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
      8496  }
      8497 
      8498  switch(allocation->GetType())
      8499  {
      8500  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      8501  {
      8502  VmaBlockVector* pBlockVector = VMA_NULL;
      8503  VmaPool hPool = allocation->GetPool();
      8504  if(hPool != VK_NULL_HANDLE)
      8505  {
      8506  pBlockVector = &hPool->m_BlockVector;
      8507  }
      8508  else
      8509  {
      8510  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      8511  pBlockVector = m_pBlockVectors[memTypeIndex];
      8512  }
      8513  pBlockVector->Free(allocation);
      8514  }
      8515  break;
      8516  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      8517  FreeDedicatedMemory(allocation);
      8518  break;
      8519  default:
      8520  VMA_ASSERT(0);
      8521  }
      8522  }
      8523 
      8524  allocation->SetUserData(this, VMA_NULL);
      8525  vma_delete(this, allocation);
      8526 }
      8527 
      8528 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
      8529 {
      8530  // Initialize.
      8531  InitStatInfo(pStats->total);
      8532  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
      8533  InitStatInfo(pStats->memoryType[i]);
      8534  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
      8535  InitStatInfo(pStats->memoryHeap[i]);
      8536 
      8537  // Process default pools.
      8538  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      8539  {
      8540  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      8541  VMA_ASSERT(pBlockVector);
      8542  pBlockVector->AddStats(pStats);
      8543  }
      8544 
      8545  // Process custom pools.
      8546  {
      8547  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      8548  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      8549  {
      8550  m_Pools[poolIndex]->GetBlockVector().AddStats(pStats);
      8551  }
      8552  }
      8553 
      8554  // Process dedicated allocations.
      8555  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      8556  {
      8557  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      8558  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      8559  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      8560  VMA_ASSERT(pDedicatedAllocVector);
      8561  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
      8562  {
      8563  VmaStatInfo allocationStatInfo;
      8564  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
      8565  VmaAddStatInfo(pStats->total, allocationStatInfo);
      8566  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      8567  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      8568  }
      8569  }
      8570 
      8571  // Postprocess.
      8572  VmaPostprocessCalcStatInfo(pStats->total);
      8573  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
      8574  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
      8575  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
      8576  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
      8577 }
      8578 
      8579 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
      8580 
      8581 VkResult VmaAllocator_T::Defragment(
      8582  VmaAllocation* pAllocations,
      8583  size_t allocationCount,
      8584  VkBool32* pAllocationsChanged,
      8585  const VmaDefragmentationInfo* pDefragmentationInfo,
      8586  VmaDefragmentationStats* pDefragmentationStats)
      8587 {
      8588  if(pAllocationsChanged != VMA_NULL)
      8589  {
      8590  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
      8591  }
      8592  if(pDefragmentationStats != VMA_NULL)
      8593  {
      8594  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
      8595  }
      8596 
      8597  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
      8598 
      8599  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
      8600 
      8601  const size_t poolCount = m_Pools.size();
      8602 
      8603  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
      8604  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      8605  {
      8606  VmaAllocation hAlloc = pAllocations[allocIndex];
      8607  VMA_ASSERT(hAlloc);
      8608  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
      8609  // DedicatedAlloc cannot be defragmented.
      8610  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
      8611  // Only HOST_VISIBLE memory types can be defragmented.
      8612  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&
      8613  // Lost allocation cannot be defragmented.
      8614  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
      8615  {
      8616  VmaBlockVector* pAllocBlockVector = VMA_NULL;
      8617 
      8618  const VmaPool hAllocPool = hAlloc->GetPool();
      8619  // This allocation belongs to custom pool.
      8620  if(hAllocPool != VK_NULL_HANDLE)
      8621  {
      8622  pAllocBlockVector = &hAllocPool->GetBlockVector();
      8623  }
      8624  // This allocation belongs to general pool.
      8625  else
      8626  {
      8627  pAllocBlockVector = m_pBlockVectors[memTypeIndex];
      8628  }
      8629 
      8630  VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);
      8631 
      8632  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
      8633  &pAllocationsChanged[allocIndex] : VMA_NULL;
      8634  pDefragmentator->AddAllocation(hAlloc, pChanged);
      8635  }
      8636  }
      8637 
      8638  VkResult result = VK_SUCCESS;
      8639 
      8640  // ======== Main processing.
      8641 
      8642  VkDeviceSize maxBytesToMove = SIZE_MAX;
      8643  uint32_t maxAllocationsToMove = UINT32_MAX;
      8644  if(pDefragmentationInfo != VMA_NULL)
      8645  {
      8646  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
      8647  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
      8648  }
      8649 
      8650  // Process standard memory.
      8651  for(uint32_t memTypeIndex = 0;
      8652  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
      8653  ++memTypeIndex)
      8654  {
      8655  // Only HOST_VISIBLE memory types can be defragmented.
      8656  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      8657  {
      8658  result = m_pBlockVectors[memTypeIndex]->Defragment(
      8659  pDefragmentationStats,
      8660  maxBytesToMove,
      8661  maxAllocationsToMove);
      8662  }
      8663  }
      8664 
      8665  // Process custom pools.
      8666  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
      8667  {
      8668  result = m_Pools[poolIndex]->GetBlockVector().Defragment(
      8669  pDefragmentationStats,
      8670  maxBytesToMove,
      8671  maxAllocationsToMove);
      8672  }
      8673 
      8674  // ======== Destroy defragmentators.
      8675 
      8676  // Process custom pools.
      8677  for(size_t poolIndex = poolCount; poolIndex--; )
      8678  {
      8679  m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();
      8680  }
      8681 
      8682  // Process standard memory.
      8683  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
      8684  {
      8685  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      8686  {
      8687  m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();
      8688  }
      8689  }
      8690 
      8691  return result;
      8692 }
      8693 
      8694 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
      8695 {
      8696  if(hAllocation->CanBecomeLost())
      8697  {
      8698  /*
      8699  Warning: This is a carefully designed algorithm.
      8700  Do not modify unless you really know what you're doing :)
      8701  */
      8702  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      8703  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      8704  for(;;)
      8705  {
      8706  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      8707  {
      8708  pAllocationInfo->memoryType = UINT32_MAX;
      8709  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
      8710  pAllocationInfo->offset = 0;
      8711  pAllocationInfo->size = hAllocation->GetSize();
      8712  pAllocationInfo->pMappedData = VMA_NULL;
      8713  pAllocationInfo->pUserData = hAllocation->GetUserData();
      8714  return;
      8715  }
      8716  else if(localLastUseFrameIndex == localCurrFrameIndex)
      8717  {
      8718  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      8719  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      8720  pAllocationInfo->offset = hAllocation->GetOffset();
      8721  pAllocationInfo->size = hAllocation->GetSize();
      8722  pAllocationInfo->pMappedData = VMA_NULL;
      8723  pAllocationInfo->pUserData = hAllocation->GetUserData();
      8724  return;
      8725  }
      8726  else // Last use time earlier than current time.
      8727  {
      8728  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      8729  {
      8730  localLastUseFrameIndex = localCurrFrameIndex;
      8731  }
      8732  }
      8733  }
      8734  }
      8735  else
      8736  {
      8737 #if VMA_STATS_STRING_ENABLED
      8738  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      8739  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      8740  for(;;)
      8741  {
      8742  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      8743  if(localLastUseFrameIndex == localCurrFrameIndex)
      8744  {
      8745  break;
      8746  }
      8747  else // Last use time earlier than current time.
      8748  {
      8749  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      8750  {
      8751  localLastUseFrameIndex = localCurrFrameIndex;
      8752  }
      8753  }
      8754  }
      8755 #endif
      8756 
      8757  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      8758  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      8759  pAllocationInfo->offset = hAllocation->GetOffset();
      8760  pAllocationInfo->size = hAllocation->GetSize();
      8761  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
      8762  pAllocationInfo->pUserData = hAllocation->GetUserData();
      8763  }
      8764 }
      8765 
      8766 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
      8767 {
      8768  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
      8769  if(hAllocation->CanBecomeLost())
      8770  {
      8771  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      8772  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      8773  for(;;)
      8774  {
      8775  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      8776  {
      8777  return false;
      8778  }
      8779  else if(localLastUseFrameIndex == localCurrFrameIndex)
      8780  {
      8781  return true;
      8782  }
      8783  else // Last use time earlier than current time.
      8784  {
      8785  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      8786  {
      8787  localLastUseFrameIndex = localCurrFrameIndex;
      8788  }
      8789  }
      8790  }
      8791  }
      8792  else
      8793  {
      8794 #if VMA_STATS_STRING_ENABLED
      8795  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      8796  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      8797  for(;;)
      8798  {
      8799  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      8800  if(localLastUseFrameIndex == localCurrFrameIndex)
      8801  {
      8802  break;
      8803  }
      8804  else // Last use time earlier than current time.
      8805  {
      8806  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      8807  {
      8808  localLastUseFrameIndex = localCurrFrameIndex;
      8809  }
      8810  }
      8811  }
      8812 #endif
      8813 
      8814  return true;
      8815  }
      8816 }
      8817 
      8818 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
      8819 {
      8820  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);
      8821 
      8822  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
      8823 
      8824  if(newCreateInfo.maxBlockCount == 0)
      8825  {
      8826  newCreateInfo.maxBlockCount = SIZE_MAX;
      8827  }
      8828  if(newCreateInfo.blockSize == 0)
      8829  {
      8830  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
      8831  }
      8832 
      8833  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
      8834 
      8835  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
      8836  if(res != VK_SUCCESS)
      8837  {
      8838  vma_delete(this, *pPool);
      8839  *pPool = VMA_NULL;
      8840  return res;
      8841  }
      8842 
      8843  // Add to m_Pools.
      8844  {
      8845  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      8846  (*pPool)->SetId(m_NextPoolId++);
      8847  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
      8848  }
      8849 
      8850  return VK_SUCCESS;
      8851 }
      8852 
      8853 void VmaAllocator_T::DestroyPool(VmaPool pool)
      8854 {
      8855  // Remove from m_Pools.
      8856  {
      8857  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      8858  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
      8859  VMA_ASSERT(success && "Pool not found in Allocator.");
      8860  }
      8861 
      8862  vma_delete(this, pool);
      8863 }
      8864 
      8865 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
      8866 {
      8867  pool->m_BlockVector.GetPoolStats(pPoolStats);
      8868 }
      8869 
      8870 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
      8871 {
      8872  m_CurrentFrameIndex.store(frameIndex);
      8873 }
      8874 
      8875 void VmaAllocator_T::MakePoolAllocationsLost(
      8876  VmaPool hPool,
      8877  size_t* pLostAllocationCount)
      8878 {
      8879  hPool->m_BlockVector.MakePoolAllocationsLost(
      8880  m_CurrentFrameIndex.load(),
      8881  pLostAllocationCount);
      8882 }
      8883 
      8884 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
      8885 {
      8886  return hPool->m_BlockVector.CheckCorruption();
      8887 }
      8888 
      8889 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
      8890 {
      8891  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
      8892 
      8893  // Process default pools.
      8894  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      8895  {
      8896  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
      8897  {
      8898  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      8899  VMA_ASSERT(pBlockVector);
      8900  VkResult localRes = pBlockVector->CheckCorruption();
      8901  switch(localRes)
      8902  {
      8903  case VK_ERROR_FEATURE_NOT_PRESENT:
      8904  break;
      8905  case VK_SUCCESS:
      8906  finalRes = VK_SUCCESS;
      8907  break;
      8908  default:
      8909  return localRes;
      8910  }
      8911  }
      8912  }
      8913 
      8914  // Process custom pools.
      8915  {
      8916  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      8917  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      8918  {
      8919  if(((1u << m_Pools[poolIndex]->GetBlockVector().GetMemoryTypeIndex()) & memoryTypeBits) != 0)
      8920  {
      8921  VkResult localRes = m_Pools[poolIndex]->GetBlockVector().CheckCorruption();
      8922  switch(localRes)
      8923  {
      8924  case VK_ERROR_FEATURE_NOT_PRESENT:
      8925  break;
      8926  case VK_SUCCESS:
      8927  finalRes = VK_SUCCESS;
      8928  break;
      8929  default:
      8930  return localRes;
      8931  }
      8932  }
      8933  }
      8934  }
      8935 
      8936  return finalRes;
      8937 }
      8938 
      8939 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
      8940 {
      8941  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);
      8942  (*pAllocation)->InitLost();
      8943 }
      8944 
      8945 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
      8946 {
      8947  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
      8948 
      8949  VkResult res;
      8950  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
      8951  {
      8952  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
      8953  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
      8954  {
      8955  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
      8956  if(res == VK_SUCCESS)
      8957  {
      8958  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
      8959  }
      8960  }
      8961  else
      8962  {
      8963  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8964  }
      8965  }
      8966  else
      8967  {
      8968  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
      8969  }
      8970 
      8971  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
      8972  {
      8973  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
      8974  }
      8975 
      8976  return res;
      8977 }
      8978 
      8979 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
      8980 {
      8981  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
      8982  {
      8983  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
      8984  }
      8985 
      8986  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
      8987 
      8988  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
      8989  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
      8990  {
      8991  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
      8992  m_HeapSizeLimit[heapIndex] += size;
      8993  }
      8994 }
      8995 
      8996 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
      8997 {
      8998  if(hAllocation->CanBecomeLost())
      8999  {
      9000  return VK_ERROR_MEMORY_MAP_FAILED;
      9001  }
      9002 
      9003  switch(hAllocation->GetType())
      9004  {
      9005  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9006  {
      9007  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      9008  char *pBytes = VMA_NULL;
      9009  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
      9010  if(res == VK_SUCCESS)
      9011  {
      9012  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
      9013  hAllocation->BlockAllocMap();
      9014  }
      9015  return res;
      9016  }
      9017  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9018  return hAllocation->DedicatedAllocMap(this, ppData);
      9019  default:
      9020  VMA_ASSERT(0);
      9021  return VK_ERROR_MEMORY_MAP_FAILED;
      9022  }
      9023 }
      9024 
      9025 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
      9026 {
      9027  switch(hAllocation->GetType())
      9028  {
      9029  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9030  {
      9031  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      9032  hAllocation->BlockAllocUnmap();
      9033  pBlock->Unmap(this, 1);
      9034  }
      9035  break;
      9036  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9037  hAllocation->DedicatedAllocUnmap(this);
      9038  break;
      9039  default:
      9040  VMA_ASSERT(0);
      9041  }
      9042 }
      9043 
      9044 VkResult VmaAllocator_T::BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer)
      9045 {
      9046  VkResult res = VK_SUCCESS;
      9047  switch(hAllocation->GetType())
      9048  {
      9049  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9050  res = GetVulkanFunctions().vkBindBufferMemory(
      9051  m_hDevice,
      9052  hBuffer,
      9053  hAllocation->GetMemory(),
      9054  0); //memoryOffset
      9055  break;
      9056  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9057  {
      9058  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      9059  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
      9060  res = pBlock->BindBufferMemory(this, hAllocation, hBuffer);
      9061  break;
      9062  }
      9063  default:
      9064  VMA_ASSERT(0);
      9065  }
      9066  return res;
      9067 }
      9068 
      9069 VkResult VmaAllocator_T::BindImageMemory(VmaAllocation hAllocation, VkImage hImage)
      9070 {
      9071  VkResult res = VK_SUCCESS;
      9072  switch(hAllocation->GetType())
      9073  {
      9074  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9075  res = GetVulkanFunctions().vkBindImageMemory(
      9076  m_hDevice,
      9077  hImage,
      9078  hAllocation->GetMemory(),
      9079  0); //memoryOffset
      9080  break;
      9081  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9082  {
      9083  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      9084  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
      9085  res = pBlock->BindImageMemory(this, hAllocation, hImage);
      9086  break;
      9087  }
      9088  default:
      9089  VMA_ASSERT(0);
      9090  }
      9091  return res;
      9092 }
      9093 
      9094 void VmaAllocator_T::FlushOrInvalidateAllocation(
      9095  VmaAllocation hAllocation,
      9096  VkDeviceSize offset, VkDeviceSize size,
      9097  VMA_CACHE_OPERATION op)
      9098 {
      9099  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
      9100  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
      9101  {
      9102  const VkDeviceSize allocationSize = hAllocation->GetSize();
      9103  VMA_ASSERT(offset <= allocationSize);
      9104 
      9105  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
      9106 
      9107  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
      9108  memRange.memory = hAllocation->GetMemory();
      9109 
      9110  switch(hAllocation->GetType())
      9111  {
      9112  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9113  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      9114  if(size == VK_WHOLE_SIZE)
      9115  {
      9116  memRange.size = allocationSize - memRange.offset;
      9117  }
      9118  else
      9119  {
      9120  VMA_ASSERT(offset + size <= allocationSize);
      9121  memRange.size = VMA_MIN(
      9122  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
      9123  allocationSize - memRange.offset);
      9124  }
      9125  break;
      9126 
      9127  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9128  {
      9129  // 1. Still within this allocation.
      9130  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      9131  if(size == VK_WHOLE_SIZE)
      9132  {
      9133  size = allocationSize - offset;
      9134  }
      9135  else
      9136  {
      9137  VMA_ASSERT(offset + size <= allocationSize);
      9138  }
      9139  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
      9140 
      9141  // 2. Adjust to whole block.
      9142  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
      9143  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
      9144  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_Metadata.GetSize();
      9145  memRange.offset += allocationOffset;
      9146  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
      9147 
      9148  break;
      9149  }
      9150 
      9151  default:
      9152  VMA_ASSERT(0);
      9153  }
      9154 
      9155  switch(op)
      9156  {
      9157  case VMA_CACHE_FLUSH:
      9158  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
      9159  break;
      9160  case VMA_CACHE_INVALIDATE:
      9161  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
      9162  break;
      9163  default:
      9164  VMA_ASSERT(0);
      9165  }
      9166  }
      9167  // else: Just ignore this call.
      9168 }
      9169 
      9170 void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
      9171 {
      9172  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
      9173 
      9174  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      9175  {
      9176  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      9177  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      9178  VMA_ASSERT(pDedicatedAllocations);
      9179  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
      9180  VMA_ASSERT(success);
      9181  }
      9182 
      9183  VkDeviceMemory hMemory = allocation->GetMemory();
      9184 
      9185  if(allocation->GetMappedData() != VMA_NULL)
      9186  {
      9187  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
      9188  }
      9189 
      9190  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
      9191 
      9192  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
      9193 }
      9194 
      9195 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
      9196 {
      9197  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
      9198  !hAllocation->CanBecomeLost() &&
      9199  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      9200  {
      9201  void* pData = VMA_NULL;
      9202  VkResult res = Map(hAllocation, &pData);
      9203  if(res == VK_SUCCESS)
      9204  {
      9205  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
      9206  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
      9207  Unmap(hAllocation);
      9208  }
      9209  else
      9210  {
      9211  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
      9212  }
      9213  }
      9214 }
      9215 
      9216 #if VMA_STATS_STRING_ENABLED
      9217 
      9218 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
      9219 {
      9220  bool dedicatedAllocationsStarted = false;
      9221  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      9222  {
      9223  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      9224  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      9225  VMA_ASSERT(pDedicatedAllocVector);
      9226  if(pDedicatedAllocVector->empty() == false)
      9227  {
      9228  if(dedicatedAllocationsStarted == false)
      9229  {
      9230  dedicatedAllocationsStarted = true;
      9231  json.WriteString("DedicatedAllocations");
      9232  json.BeginObject();
      9233  }
      9234 
      9235  json.BeginString("Type ");
      9236  json.ContinueString(memTypeIndex);
      9237  json.EndString();
      9238 
      9239  json.BeginArray();
      9240 
      9241  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
      9242  {
      9243  json.BeginObject(true);
      9244  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
      9245  hAlloc->PrintParameters(json);
      9246  json.EndObject();
      9247  }
      9248 
      9249  json.EndArray();
      9250  }
      9251  }
      9252  if(dedicatedAllocationsStarted)
      9253  {
      9254  json.EndObject();
      9255  }
      9256 
      9257  {
      9258  bool allocationsStarted = false;
      9259  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      9260  {
      9261  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
      9262  {
      9263  if(allocationsStarted == false)
      9264  {
      9265  allocationsStarted = true;
      9266  json.WriteString("DefaultPools");
      9267  json.BeginObject();
      9268  }
      9269 
      9270  json.BeginString("Type ");
      9271  json.ContinueString(memTypeIndex);
      9272  json.EndString();
      9273 
      9274  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
      9275  }
      9276  }
      9277  if(allocationsStarted)
      9278  {
      9279  json.EndObject();
      9280  }
      9281  }
      9282 
      9283  {
      9284  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      9285  const size_t poolCount = m_Pools.size();
      9286  if(poolCount > 0)
      9287  {
      9288  json.WriteString("Pools");
      9289  json.BeginObject();
      9290  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
      9291  {
      9292  json.BeginString();
      9293  json.ContinueString(m_Pools[poolIndex]->GetId());
      9294  json.EndString();
      9295 
      9296  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
      9297  }
      9298  json.EndObject();
      9299  }
      9300  }
      9301 }
      9302 
      9303 #endif // #if VMA_STATS_STRING_ENABLED
      9304 
      9305 static VkResult AllocateMemoryForImage(
      9306  VmaAllocator allocator,
      9307  VkImage image,
      9308  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      9309  VmaSuballocationType suballocType,
      9310  VmaAllocation* pAllocation)
      9311 {
      9312  VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation);
      9313 
      9314  VkMemoryRequirements vkMemReq = {};
      9315  bool requiresDedicatedAllocation = false;
      9316  bool prefersDedicatedAllocation = false;
      9317  allocator->GetImageMemoryRequirements(image, vkMemReq,
      9318  requiresDedicatedAllocation, prefersDedicatedAllocation);
      9319 
      9320  return allocator->AllocateMemory(
      9321  vkMemReq,
      9322  requiresDedicatedAllocation,
      9323  prefersDedicatedAllocation,
      9324  VK_NULL_HANDLE, // dedicatedBuffer
      9325  image, // dedicatedImage
      9326  *pAllocationCreateInfo,
      9327  suballocType,
      9328  pAllocation);
      9329 }
      9330 
      9332 // Public interface
      9333 
      9334 VkResult vmaCreateAllocator(
      9335  const VmaAllocatorCreateInfo* pCreateInfo,
      9336  VmaAllocator* pAllocator)
      9337 {
      9338  VMA_ASSERT(pCreateInfo && pAllocator);
      9339  VMA_DEBUG_LOG("vmaCreateAllocator");
      9340  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
      9341  return VK_SUCCESS;
      9342 }
      9343 
      9344 void vmaDestroyAllocator(
      9345  VmaAllocator allocator)
      9346 {
      9347  if(allocator != VK_NULL_HANDLE)
      9348  {
      9349  VMA_DEBUG_LOG("vmaDestroyAllocator");
      9350  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
      9351  vma_delete(&allocationCallbacks, allocator);
      9352  }
      9353 }
      9354 
      9355 void vmaGetPhysicalDeviceProperties(
      9356  VmaAllocator allocator,
      9357  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
      9358 {
      9359  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
      9360  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
      9361 }
      9362 
      9363 void vmaGetMemoryProperties(
      9364  VmaAllocator allocator,
      9365  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
      9366 {
      9367  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
      9368  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
      9369 }
      9370 
      9371 void vmaGetMemoryTypeProperties(
      9372  VmaAllocator allocator,
      9373  uint32_t memoryTypeIndex,
      9374  VkMemoryPropertyFlags* pFlags)
      9375 {
      9376  VMA_ASSERT(allocator && pFlags);
      9377  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
      9378  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
      9379 }
      9380 
      9381 void vmaSetCurrentFrameIndex(
      9382  VmaAllocator allocator,
      9383  uint32_t frameIndex)
      9384 {
      9385  VMA_ASSERT(allocator);
      9386  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
      9387 
      9388  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9389 
      9390  allocator->SetCurrentFrameIndex(frameIndex);
      9391 }
      9392 
      9393 void vmaCalculateStats(
      9394  VmaAllocator allocator,
      9395  VmaStats* pStats)
      9396 {
      9397  VMA_ASSERT(allocator && pStats);
      9398  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9399  allocator->CalculateStats(pStats);
      9400 }
      9401 
      9402 #if VMA_STATS_STRING_ENABLED
      9403 
      9404 void vmaBuildStatsString(
      9405  VmaAllocator allocator,
      9406  char** ppStatsString,
      9407  VkBool32 detailedMap)
      9408 {
      9409  VMA_ASSERT(allocator && ppStatsString);
      9410  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9411 
      9412  VmaStringBuilder sb(allocator);
      9413  {
      9414  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
      9415  json.BeginObject();
      9416 
      9417  VmaStats stats;
      9418  allocator->CalculateStats(&stats);
      9419 
      9420  json.WriteString("Total");
      9421  VmaPrintStatInfo(json, stats.total);
      9422 
      9423  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
      9424  {
      9425  json.BeginString("Heap ");
      9426  json.ContinueString(heapIndex);
      9427  json.EndString();
      9428  json.BeginObject();
      9429 
      9430  json.WriteString("Size");
      9431  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
      9432 
      9433  json.WriteString("Flags");
      9434  json.BeginArray(true);
      9435  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
      9436  {
      9437  json.WriteString("DEVICE_LOCAL");
      9438  }
      9439  json.EndArray();
      9440 
      9441  if(stats.memoryHeap[heapIndex].blockCount > 0)
      9442  {
      9443  json.WriteString("Stats");
      9444  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
      9445  }
      9446 
      9447  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
      9448  {
      9449  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
      9450  {
      9451  json.BeginString("Type ");
      9452  json.ContinueString(typeIndex);
      9453  json.EndString();
      9454 
      9455  json.BeginObject();
      9456 
      9457  json.WriteString("Flags");
      9458  json.BeginArray(true);
      9459  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
      9460  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
      9461  {
      9462  json.WriteString("DEVICE_LOCAL");
      9463  }
      9464  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      9465  {
      9466  json.WriteString("HOST_VISIBLE");
      9467  }
      9468  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
      9469  {
      9470  json.WriteString("HOST_COHERENT");
      9471  }
      9472  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
      9473  {
      9474  json.WriteString("HOST_CACHED");
      9475  }
      9476  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
      9477  {
      9478  json.WriteString("LAZILY_ALLOCATED");
      9479  }
      9480  json.EndArray();
      9481 
      9482  if(stats.memoryType[typeIndex].blockCount > 0)
      9483  {
      9484  json.WriteString("Stats");
      9485  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
      9486  }
      9487 
      9488  json.EndObject();
      9489  }
      9490  }
      9491 
      9492  json.EndObject();
      9493  }
      9494  if(detailedMap == VK_TRUE)
      9495  {
      9496  allocator->PrintDetailedMap(json);
      9497  }
      9498 
      9499  json.EndObject();
      9500  }
      9501 
      9502  const size_t len = sb.GetLength();
      9503  char* const pChars = vma_new_array(allocator, char, len + 1);
      9504  if(len > 0)
      9505  {
      9506  memcpy(pChars, sb.GetData(), len);
      9507  }
      9508  pChars[len] = '\0';
      9509  *ppStatsString = pChars;
      9510 }
      9511 
      9512 void vmaFreeStatsString(
      9513  VmaAllocator allocator,
      9514  char* pStatsString)
      9515 {
      9516  if(pStatsString != VMA_NULL)
      9517  {
      9518  VMA_ASSERT(allocator);
      9519  size_t len = strlen(pStatsString);
      9520  vma_delete_array(allocator, pStatsString, len + 1);
      9521  }
      9522 }
      9523 
      9524 #endif // #if VMA_STATS_STRING_ENABLED
      9525 
      9526 /*
      9527 This function is not protected by any mutex because it just reads immutable data.
      9528 */
      9529 VkResult vmaFindMemoryTypeIndex(
      9530  VmaAllocator allocator,
      9531  uint32_t memoryTypeBits,
      9532  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      9533  uint32_t* pMemoryTypeIndex)
      9534 {
      9535  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      9536  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      9537  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      9538 
      9539  if(pAllocationCreateInfo->memoryTypeBits != 0)
      9540  {
      9541  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
      9542  }
      9543 
      9544  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
      9545  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
      9546 
      9547  const bool mapped = (pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      9548  if(mapped)
      9549  {
      9550  preferredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      9551  }
      9552 
      9553  // Convert usage to requiredFlags and preferredFlags.
      9554  switch(pAllocationCreateInfo->usage)
      9555  {
      9556  case VMA_MEMORY_USAGE_UNKNOWN:
      9557  break;
      9558  case VMA_MEMORY_USAGE_GPU_ONLY:
      9559  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      9560  {
      9561  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      9562  }
      9563  break;
      9564  case VMA_MEMORY_USAGE_CPU_ONLY:
      9565  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      9566  break;
      9567  case VMA_MEMORY_USAGE_CPU_TO_GPU:
      9568  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      9569  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      9570  {
      9571  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      9572  }
      9573  break;
      9574  case VMA_MEMORY_USAGE_GPU_TO_CPU:
      9575  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      9576  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
      9577  break;
      9578  default:
      9579  break;
      9580  }
      9581 
      9582  *pMemoryTypeIndex = UINT32_MAX;
      9583  uint32_t minCost = UINT32_MAX;
      9584  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
      9585  memTypeIndex < allocator->GetMemoryTypeCount();
      9586  ++memTypeIndex, memTypeBit <<= 1)
      9587  {
      9588  // This memory type is acceptable according to memoryTypeBits bitmask.
      9589  if((memTypeBit & memoryTypeBits) != 0)
      9590  {
      9591  const VkMemoryPropertyFlags currFlags =
      9592  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
      9593  // This memory type contains requiredFlags.
      9594  if((requiredFlags & ~currFlags) == 0)
      9595  {
      9596  // Calculate cost as number of bits from preferredFlags not present in this memory type.
      9597  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
      9598  // Remember memory type with lowest cost.
      9599  if(currCost < minCost)
      9600  {
      9601  *pMemoryTypeIndex = memTypeIndex;
      9602  if(currCost == 0)
      9603  {
      9604  return VK_SUCCESS;
      9605  }
      9606  minCost = currCost;
      9607  }
      9608  }
      9609  }
      9610  }
      9611  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
      9612 }
      9613 
      9614 VkResult vmaFindMemoryTypeIndexForBufferInfo(
      9615  VmaAllocator allocator,
      9616  const VkBufferCreateInfo* pBufferCreateInfo,
      9617  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      9618  uint32_t* pMemoryTypeIndex)
      9619 {
      9620  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      9621  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
      9622  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      9623  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      9624 
      9625  const VkDevice hDev = allocator->m_hDevice;
      9626  VkBuffer hBuffer = VK_NULL_HANDLE;
      9627  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
      9628  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
      9629  if(res == VK_SUCCESS)
      9630  {
      9631  VkMemoryRequirements memReq = {};
      9632  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
      9633  hDev, hBuffer, &memReq);
      9634 
      9635  res = vmaFindMemoryTypeIndex(
      9636  allocator,
      9637  memReq.memoryTypeBits,
      9638  pAllocationCreateInfo,
      9639  pMemoryTypeIndex);
      9640 
      9641  allocator->GetVulkanFunctions().vkDestroyBuffer(
      9642  hDev, hBuffer, allocator->GetAllocationCallbacks());
      9643  }
      9644  return res;
      9645 }
      9646 
      9647 VkResult vmaFindMemoryTypeIndexForImageInfo(
      9648  VmaAllocator allocator,
      9649  const VkImageCreateInfo* pImageCreateInfo,
      9650  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      9651  uint32_t* pMemoryTypeIndex)
      9652 {
      9653  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      9654  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
      9655  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      9656  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      9657 
      9658  const VkDevice hDev = allocator->m_hDevice;
      9659  VkImage hImage = VK_NULL_HANDLE;
      9660  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
      9661  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
      9662  if(res == VK_SUCCESS)
      9663  {
      9664  VkMemoryRequirements memReq = {};
      9665  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
      9666  hDev, hImage, &memReq);
      9667 
      9668  res = vmaFindMemoryTypeIndex(
      9669  allocator,
      9670  memReq.memoryTypeBits,
      9671  pAllocationCreateInfo,
      9672  pMemoryTypeIndex);
      9673 
      9674  allocator->GetVulkanFunctions().vkDestroyImage(
      9675  hDev, hImage, allocator->GetAllocationCallbacks());
      9676  }
      9677  return res;
      9678 }
      9679 
      9680 VkResult vmaCreatePool(
      9681  VmaAllocator allocator,
      9682  const VmaPoolCreateInfo* pCreateInfo,
      9683  VmaPool* pPool)
      9684 {
      9685  VMA_ASSERT(allocator && pCreateInfo && pPool);
      9686 
      9687  VMA_DEBUG_LOG("vmaCreatePool");
      9688 
      9689  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9690 
      9691  return allocator->CreatePool(pCreateInfo, pPool);
      9692 }
      9693 
      9694 void vmaDestroyPool(
      9695  VmaAllocator allocator,
      9696  VmaPool pool)
      9697 {
      9698  VMA_ASSERT(allocator);
      9699 
      9700  if(pool == VK_NULL_HANDLE)
      9701  {
      9702  return;
      9703  }
      9704 
      9705  VMA_DEBUG_LOG("vmaDestroyPool");
      9706 
      9707  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9708 
      9709  allocator->DestroyPool(pool);
      9710 }
      9711 
      9712 void vmaGetPoolStats(
      9713  VmaAllocator allocator,
      9714  VmaPool pool,
      9715  VmaPoolStats* pPoolStats)
      9716 {
      9717  VMA_ASSERT(allocator && pool && pPoolStats);
      9718 
      9719  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9720 
      9721  allocator->GetPoolStats(pool, pPoolStats);
      9722 }
      9723 
      9724 void vmaMakePoolAllocationsLost(
      9725  VmaAllocator allocator,
      9726  VmaPool pool,
      9727  size_t* pLostAllocationCount)
      9728 {
      9729  VMA_ASSERT(allocator && pool);
      9730 
      9731  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9732 
      9733  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
      9734 }
      9735 
      9736 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
      9737 {
      9738  VMA_ASSERT(allocator && pool);
      9739 
      9740  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9741 
      9742  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
      9743 
      9744  return allocator->CheckPoolCorruption(pool);
      9745 }
      9746 
      9747 VkResult vmaAllocateMemory(
      9748  VmaAllocator allocator,
      9749  const VkMemoryRequirements* pVkMemoryRequirements,
      9750  const VmaAllocationCreateInfo* pCreateInfo,
      9751  VmaAllocation* pAllocation,
      9752  VmaAllocationInfo* pAllocationInfo)
      9753 {
      9754  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
      9755 
      9756  VMA_DEBUG_LOG("vmaAllocateMemory");
      9757 
      9758  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9759 
      9760  VkResult result = allocator->AllocateMemory(
      9761  *pVkMemoryRequirements,
      9762  false, // requiresDedicatedAllocation
      9763  false, // prefersDedicatedAllocation
      9764  VK_NULL_HANDLE, // dedicatedBuffer
      9765  VK_NULL_HANDLE, // dedicatedImage
      9766  *pCreateInfo,
      9767  VMA_SUBALLOCATION_TYPE_UNKNOWN,
      9768  pAllocation);
      9769 
      9770  if(pAllocationInfo && result == VK_SUCCESS)
      9771  {
      9772  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      9773  }
      9774 
      9775  return result;
      9776 }
      9777 
      9778 VkResult vmaAllocateMemoryForBuffer(
      9779  VmaAllocator allocator,
      9780  VkBuffer buffer,
      9781  const VmaAllocationCreateInfo* pCreateInfo,
      9782  VmaAllocation* pAllocation,
      9783  VmaAllocationInfo* pAllocationInfo)
      9784 {
      9785  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      9786 
      9787  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
      9788 
      9789  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9790 
      9791  VkMemoryRequirements vkMemReq = {};
      9792  bool requiresDedicatedAllocation = false;
      9793  bool prefersDedicatedAllocation = false;
      9794  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
      9795  requiresDedicatedAllocation,
      9796  prefersDedicatedAllocation);
      9797 
      9798  VkResult result = allocator->AllocateMemory(
      9799  vkMemReq,
      9800  requiresDedicatedAllocation,
      9801  prefersDedicatedAllocation,
      9802  buffer, // dedicatedBuffer
      9803  VK_NULL_HANDLE, // dedicatedImage
      9804  *pCreateInfo,
      9805  VMA_SUBALLOCATION_TYPE_BUFFER,
      9806  pAllocation);
      9807 
      9808  if(pAllocationInfo && result == VK_SUCCESS)
      9809  {
      9810  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      9811  }
      9812 
      9813  return result;
      9814 }
      9815 
      9816 VkResult vmaAllocateMemoryForImage(
      9817  VmaAllocator allocator,
      9818  VkImage image,
      9819  const VmaAllocationCreateInfo* pCreateInfo,
      9820  VmaAllocation* pAllocation,
      9821  VmaAllocationInfo* pAllocationInfo)
      9822 {
      9823  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      9824 
      9825  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
      9826 
      9827  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9828 
      9829  VkResult result = AllocateMemoryForImage(
      9830  allocator,
      9831  image,
      9832  pCreateInfo,
      9833  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
      9834  pAllocation);
      9835 
      9836  if(pAllocationInfo && result == VK_SUCCESS)
      9837  {
      9838  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      9839  }
      9840 
      9841  return result;
      9842 }
      9843 
      9844 void vmaFreeMemory(
      9845  VmaAllocator allocator,
      9846  VmaAllocation allocation)
      9847 {
      9848  VMA_ASSERT(allocator);
      9849  VMA_DEBUG_LOG("vmaFreeMemory");
      9850  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9851  if(allocation != VK_NULL_HANDLE)
      9852  {
      9853  allocator->FreeMemory(allocation);
      9854  }
      9855 }
      9856 
      9857 void vmaGetAllocationInfo(
      9858  VmaAllocator allocator,
      9859  VmaAllocation allocation,
      9860  VmaAllocationInfo* pAllocationInfo)
      9861 {
      9862  VMA_ASSERT(allocator && allocation && pAllocationInfo);
      9863 
      9864  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9865 
      9866  allocator->GetAllocationInfo(allocation, pAllocationInfo);
      9867 }
      9868 
      9869 VkBool32 vmaTouchAllocation(
      9870  VmaAllocator allocator,
      9871  VmaAllocation allocation)
      9872 {
      9873  VMA_ASSERT(allocator && allocation);
      9874 
      9875  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9876 
      9877  return allocator->TouchAllocation(allocation);
      9878 }
      9879 
      9880 void vmaSetAllocationUserData(
      9881  VmaAllocator allocator,
      9882  VmaAllocation allocation,
      9883  void* pUserData)
      9884 {
      9885  VMA_ASSERT(allocator && allocation);
      9886 
      9887  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9888 
      9889  allocation->SetUserData(allocator, pUserData);
      9890 }
      9891 
      9892 void vmaCreateLostAllocation(
      9893  VmaAllocator allocator,
      9894  VmaAllocation* pAllocation)
      9895 {
      9896  VMA_ASSERT(allocator && pAllocation);
      9897 
      9898  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
      9899 
      9900  allocator->CreateLostAllocation(pAllocation);
      9901 }
      9902 
      9903 VkResult vmaMapMemory(
      9904  VmaAllocator allocator,
      9905  VmaAllocation allocation,
      9906  void** ppData)
      9907 {
      9908  VMA_ASSERT(allocator && allocation && ppData);
      9909 
      9910  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9911 
      9912  return allocator->Map(allocation, ppData);
      9913 }
      9914 
      9915 void vmaUnmapMemory(
      9916  VmaAllocator allocator,
      9917  VmaAllocation allocation)
      9918 {
      9919  VMA_ASSERT(allocator && allocation);
      9920 
      9921  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9922 
      9923  allocator->Unmap(allocation);
      9924 }
      9925 
      9926 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      9927 {
      9928  VMA_ASSERT(allocator && allocation);
      9929 
      9930  VMA_DEBUG_LOG("vmaFlushAllocation");
      9931 
      9932  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9933 
      9934  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
      9935 }
      9936 
      9937 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      9938 {
      9939  VMA_ASSERT(allocator && allocation);
      9940 
      9941  VMA_DEBUG_LOG("vmaInvalidateAllocation");
      9942 
      9943  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9944 
      9945  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
      9946 }
      9947 
      9948 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
      9949 {
      9950  VMA_ASSERT(allocator);
      9951 
      9952  VMA_DEBUG_LOG("vmaCheckCorruption");
      9953 
      9954  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9955 
      9956  return allocator->CheckCorruption(memoryTypeBits);
      9957 }
      9958 
      9959 VkResult vmaDefragment(
      9960  VmaAllocator allocator,
      9961  VmaAllocation* pAllocations,
      9962  size_t allocationCount,
      9963  VkBool32* pAllocationsChanged,
      9964  const VmaDefragmentationInfo *pDefragmentationInfo,
      9965  VmaDefragmentationStats* pDefragmentationStats)
      9966 {
      9967  VMA_ASSERT(allocator && pAllocations);
      9968 
      9969  VMA_DEBUG_LOG("vmaDefragment");
      9970 
      9971  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9972 
      9973  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
      9974 }
      9975 
      9976 VkResult vmaBindBufferMemory(
      9977  VmaAllocator allocator,
      9978  VmaAllocation allocation,
      9979  VkBuffer buffer)
      9980 {
      9981  VMA_ASSERT(allocator && allocation && buffer);
      9982 
      9983  VMA_DEBUG_LOG("vmaBindBufferMemory");
      9984 
      9985  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      9986 
      9987  return allocator->BindBufferMemory(allocation, buffer);
      9988 }
      9989 
      9990 VkResult vmaBindImageMemory(
      9991  VmaAllocator allocator,
      9992  VmaAllocation allocation,
      9993  VkImage image)
      9994 {
      9995  VMA_ASSERT(allocator && allocation && image);
      9996 
      9997  VMA_DEBUG_LOG("vmaBindImageMemory");
      9998 
      9999  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10000 
      10001  return allocator->BindImageMemory(allocation, image);
      10002 }
      10003 
      10004 VkResult vmaCreateBuffer(
      10005  VmaAllocator allocator,
      10006  const VkBufferCreateInfo* pBufferCreateInfo,
      10007  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      10008  VkBuffer* pBuffer,
      10009  VmaAllocation* pAllocation,
      10010  VmaAllocationInfo* pAllocationInfo)
      10011 {
      10012  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
      10013 
      10014  VMA_DEBUG_LOG("vmaCreateBuffer");
      10015 
      10016  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10017 
      10018  *pBuffer = VK_NULL_HANDLE;
      10019  *pAllocation = VK_NULL_HANDLE;
      10020 
      10021  // 1. Create VkBuffer.
      10022  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
      10023  allocator->m_hDevice,
      10024  pBufferCreateInfo,
      10025  allocator->GetAllocationCallbacks(),
      10026  pBuffer);
      10027  if(res >= 0)
      10028  {
      10029  // 2. vkGetBufferMemoryRequirements.
      10030  VkMemoryRequirements vkMemReq = {};
      10031  bool requiresDedicatedAllocation = false;
      10032  bool prefersDedicatedAllocation = false;
      10033  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
      10034  requiresDedicatedAllocation, prefersDedicatedAllocation);
      10035 
      10036  // Make sure alignment requirements for specific buffer usages reported
      10037  // in Physical Device Properties are included in alignment reported by memory requirements.
      10038  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
      10039  {
      10040  VMA_ASSERT(vkMemReq.alignment %
      10041  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
      10042  }
      10043  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
      10044  {
      10045  VMA_ASSERT(vkMemReq.alignment %
      10046  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
      10047  }
      10048  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
      10049  {
      10050  VMA_ASSERT(vkMemReq.alignment %
      10051  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
      10052  }
      10053 
      10054  // 3. Allocate memory using allocator.
      10055  res = allocator->AllocateMemory(
      10056  vkMemReq,
      10057  requiresDedicatedAllocation,
      10058  prefersDedicatedAllocation,
      10059  *pBuffer, // dedicatedBuffer
      10060  VK_NULL_HANDLE, // dedicatedImage
      10061  *pAllocationCreateInfo,
      10062  VMA_SUBALLOCATION_TYPE_BUFFER,
      10063  pAllocation);
      10064  if(res >= 0)
      10065  {
      10066  // 3. Bind buffer with memory.
      10067  res = allocator->BindBufferMemory(*pAllocation, *pBuffer);
      10068  if(res >= 0)
      10069  {
      10070  // All steps succeeded.
      10071  #if VMA_STATS_STRING_ENABLED
      10072  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
      10073  #endif
      10074  if(pAllocationInfo != VMA_NULL)
      10075  {
      10076  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      10077  }
      10078  return VK_SUCCESS;
      10079  }
      10080  allocator->FreeMemory(*pAllocation);
      10081  *pAllocation = VK_NULL_HANDLE;
      10082  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      10083  *pBuffer = VK_NULL_HANDLE;
      10084  return res;
      10085  }
      10086  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      10087  *pBuffer = VK_NULL_HANDLE;
      10088  return res;
      10089  }
      10090  return res;
      10091 }
      10092 
      10093 void vmaDestroyBuffer(
      10094  VmaAllocator allocator,
      10095  VkBuffer buffer,
      10096  VmaAllocation allocation)
      10097 {
      10098  VMA_ASSERT(allocator);
      10099  VMA_DEBUG_LOG("vmaDestroyBuffer");
      10100  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10101  if(buffer != VK_NULL_HANDLE)
      10102  {
      10103  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
      10104  }
      10105  if(allocation != VK_NULL_HANDLE)
      10106  {
      10107  allocator->FreeMemory(allocation);
      10108  }
      10109 }
      10110 
      10111 VkResult vmaCreateImage(
      10112  VmaAllocator allocator,
      10113  const VkImageCreateInfo* pImageCreateInfo,
      10114  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      10115  VkImage* pImage,
      10116  VmaAllocation* pAllocation,
      10117  VmaAllocationInfo* pAllocationInfo)
      10118 {
      10119  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
      10120 
      10121  VMA_DEBUG_LOG("vmaCreateImage");
      10122 
      10123  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10124 
      10125  *pImage = VK_NULL_HANDLE;
      10126  *pAllocation = VK_NULL_HANDLE;
      10127 
      10128  // 1. Create VkImage.
      10129  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
      10130  allocator->m_hDevice,
      10131  pImageCreateInfo,
      10132  allocator->GetAllocationCallbacks(),
      10133  pImage);
      10134  if(res >= 0)
      10135  {
      10136  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
      10137  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
      10138  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
      10139 
      10140  // 2. Allocate memory using allocator.
      10141  res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation);
      10142  if(res >= 0)
      10143  {
      10144  // 3. Bind image with memory.
      10145  res = allocator->BindImageMemory(*pAllocation, *pImage);
      10146  if(res >= 0)
      10147  {
      10148  // All steps succeeded.
      10149  #if VMA_STATS_STRING_ENABLED
      10150  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
      10151  #endif
      10152  if(pAllocationInfo != VMA_NULL)
      10153  {
      10154  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      10155  }
      10156  return VK_SUCCESS;
      10157  }
      10158  allocator->FreeMemory(*pAllocation);
      10159  *pAllocation = VK_NULL_HANDLE;
      10160  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      10161  *pImage = VK_NULL_HANDLE;
      10162  return res;
      10163  }
      10164  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      10165  *pImage = VK_NULL_HANDLE;
      10166  return res;
      10167  }
      10168  return res;
      10169 }
      10170 
      10171 void vmaDestroyImage(
      10172  VmaAllocator allocator,
      10173  VkImage image,
      10174  VmaAllocation allocation)
      10175 {
      10176  VMA_ASSERT(allocator);
      10177  VMA_DEBUG_LOG("vmaDestroyImage");
      10178  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10179  if(image != VK_NULL_HANDLE)
      10180  {
      10181  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
      10182  }
      10183  if(allocation != VK_NULL_HANDLE)
      10184  {
      10185  allocator->FreeMemory(allocation);
      10186  }
      10187 }
      10188 
      10189 #endif // #ifdef VMA_IMPLEMENTATION
      VmaVulkanFunctions::vkGetPhysicalDeviceProperties
      PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
      Definition: vk_mem_alloc.h:1271
      -
      VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
      Set this flag if the allocation should have its own memory block.
      Definition: vk_mem_alloc.h:1537
      +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 
      1258 #include <vulkan/vulkan.h>
      1259 
      1260 #if !defined(VMA_DEDICATED_ALLOCATION)
      1261  #if VK_KHR_get_memory_requirements2 && VK_KHR_dedicated_allocation
      1262  #define VMA_DEDICATED_ALLOCATION 1
      1263  #else
      1264  #define VMA_DEDICATED_ALLOCATION 0
      1265  #endif
      1266 #endif
      1267 
      1277 VK_DEFINE_HANDLE(VmaAllocator)
      1278 
      1279 typedef void (VKAPI_PTR *PFN_vmaAllocateDeviceMemoryFunction)(
      1281  VmaAllocator allocator,
      1282  uint32_t memoryType,
      1283  VkDeviceMemory memory,
      1284  VkDeviceSize size);
      1286 typedef void (VKAPI_PTR *PFN_vmaFreeDeviceMemoryFunction)(
      1287  VmaAllocator allocator,
      1288  uint32_t memoryType,
      1289  VkDeviceMemory memory,
      1290  VkDeviceSize size);
      1291 
      1299 typedef struct VmaDeviceMemoryCallbacks {
      1301  PFN_vmaAllocateDeviceMemoryFunction pfnAllocate;
      1303  PFN_vmaFreeDeviceMemoryFunction pfnFree;
      1304 } VmaDeviceMemoryCallbacks;
      1305 
      1307 typedef enum VmaAllocatorCreateFlagBits {
      1312  VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,
      1334  VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT = 0x00000002,
      1335 
      1336  VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1337 } VmaAllocatorCreateFlagBits;
      1338 typedef VkFlags VmaAllocatorCreateFlags;
      1339 
      1344 typedef struct VmaVulkanFunctions {
      1345  PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
      1346  PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
      1347  PFN_vkAllocateMemory vkAllocateMemory;
      1348  PFN_vkFreeMemory vkFreeMemory;
      1349  PFN_vkMapMemory vkMapMemory;
      1350  PFN_vkUnmapMemory vkUnmapMemory;
      1351  PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
      1352  PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
      1353  PFN_vkBindBufferMemory vkBindBufferMemory;
      1354  PFN_vkBindImageMemory vkBindImageMemory;
      1355  PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
      1356  PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
      1357  PFN_vkCreateBuffer vkCreateBuffer;
      1358  PFN_vkDestroyBuffer vkDestroyBuffer;
      1359  PFN_vkCreateImage vkCreateImage;
      1360  PFN_vkDestroyImage vkDestroyImage;
      1361 #if VMA_DEDICATED_ALLOCATION
      1362  PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
      1363  PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
      1364 #endif
      1365 } VmaVulkanFunctions;
      1366 
      1368 typedef enum VmaRecordFlagBits {
      1374  VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001,
      1375 
      1376  VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1377 } VmaRecordFlagBits;
      1378 typedef VkFlags VmaRecordFlags;
      1379 
      1380 /*
      1381 Define this macro to 0/1 to disable/enable support for recording functionality,
      1382 available through VmaAllocatorCreateInfo::pRecordSettings.
      1383 */
      1384 #ifndef VMA_RECORDING_ENABLED
      1385  #ifdef _WIN32
      1386  #define VMA_RECORDING_ENABLED 1
      1387  #else
      1388  #define VMA_RECORDING_ENABLED 0
      1389  #endif
      1390 #endif
      1391 
      1393 typedef struct VmaRecordSettings
      1394 {
      1396  VmaRecordFlags flags;
      1404  const char* pFilePath;
      1405 } VmaRecordSettings;
      1406 
      1408 typedef struct VmaAllocatorCreateInfo
      1409 {
      1411  VmaAllocatorCreateFlags flags;
      1413 
      1414  VkPhysicalDevice physicalDevice;
      1416 
      1417  VkDevice device;
      1419 
      1420  VkDeviceSize preferredLargeHeapBlockSize;
      1422 
      1423  const VkAllocationCallbacks* pAllocationCallbacks;
      1425 
      1426  const VmaDeviceMemoryCallbacks* pDeviceMemoryCallbacks;
      1440  uint32_t frameInUseCount;
      1464  const VkDeviceSize* pHeapSizeLimit;
      1476  const VmaVulkanFunctions* pVulkanFunctions;
      1483  const VmaRecordSettings* pRecordSettings;
      1484 } VmaAllocatorCreateInfo;
      1485 
      1487 VkResult vmaCreateAllocator(
      1488  const VmaAllocatorCreateInfo* pCreateInfo,
      1489  VmaAllocator* pAllocator);
      1490 
      1492 void vmaDestroyAllocator(
      1493  VmaAllocator allocator);
      1494 
      1499 void vmaGetPhysicalDeviceProperties(
      1500  VmaAllocator allocator,
      1501  const VkPhysicalDeviceProperties** ppPhysicalDeviceProperties);
      1502 
      1507 void vmaGetMemoryProperties(
      1508  VmaAllocator allocator,
      1509  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties);
      1510 
      1517 void vmaGetMemoryTypeProperties(
      1518  VmaAllocator allocator,
      1519  uint32_t memoryTypeIndex,
      1520  VkMemoryPropertyFlags* pFlags);
      1521 
      1530 void vmaSetCurrentFrameIndex(
      1531  VmaAllocator allocator,
      1532  uint32_t frameIndex);
      1533 
      1536 typedef struct VmaStatInfo
      1537 {
      1539  uint32_t blockCount;
      1541  uint32_t allocationCount;
      1543  uint32_t unusedRangeCount;
      1545  VkDeviceSize usedBytes;
      1547  VkDeviceSize unusedBytes;
      1548  VkDeviceSize allocationSizeMin, allocationSizeAvg, allocationSizeMax;
      1549  VkDeviceSize unusedRangeSizeMin, unusedRangeSizeAvg, unusedRangeSizeMax;
      1550 } VmaStatInfo;
      1551 
      1553 typedef struct VmaStats
      1554 {
      1555  VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES];
      1556  VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS];
      1557  VmaStatInfo total;
      1558 } VmaStats;
      1559 
      1561 void vmaCalculateStats(
      1562  VmaAllocator allocator,
      1563  VmaStats* pStats);
      1564 
      1565 #define VMA_STATS_STRING_ENABLED 1
      1566 
      1567 #if VMA_STATS_STRING_ENABLED
      1568 
      1570 
      1572 void vmaBuildStatsString(
      1573  VmaAllocator allocator,
      1574  char** ppStatsString,
      1575  VkBool32 detailedMap);
      1576 
      1577 void vmaFreeStatsString(
      1578  VmaAllocator allocator,
      1579  char* pStatsString);
      1580 
      1581 #endif // #if VMA_STATS_STRING_ENABLED
      1582 
      1591 VK_DEFINE_HANDLE(VmaPool)
      1592 
      1593 typedef enum VmaMemoryUsage
      1594 {
      1598  VMA_MEMORY_USAGE_UNKNOWN = 0,
      1615  VMA_MEMORY_USAGE_GPU_ONLY = 1,
      1625  VMA_MEMORY_USAGE_CPU_ONLY = 2,
      1632  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
      1641  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
      1642  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
      1643 } VmaMemoryUsage;
      1644 
      1646 typedef enum VmaAllocationCreateFlagBits {
      1658  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
      1659 
      1669  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
      1682  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
      1695  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
      1702  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
      1708  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
      1709 
      1710  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1711 } VmaAllocationCreateFlagBits;
      1712 typedef VkFlags VmaAllocationCreateFlags;
      1713 
      1714 typedef struct VmaAllocationCreateInfo
      1715 {
      1717  VmaAllocationCreateFlags flags;
      1723  VmaMemoryUsage usage;
      1728  VkMemoryPropertyFlags requiredFlags;
      1733  VkMemoryPropertyFlags preferredFlags;
      1741  uint32_t memoryTypeBits;
      1747  VmaPool pool;
      1754  void* pUserData;
      1755 } VmaAllocationCreateInfo;
      1756 
      1773 VkResult vmaFindMemoryTypeIndex(
      1774  VmaAllocator allocator,
      1775  uint32_t memoryTypeBits,
      1776  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      1777  uint32_t* pMemoryTypeIndex);
      1778 
      1791 VkResult vmaFindMemoryTypeIndexForBufferInfo(
      1792  VmaAllocator allocator,
      1793  const VkBufferCreateInfo* pBufferCreateInfo,
      1794  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      1795  uint32_t* pMemoryTypeIndex);
      1796 
      1809 VkResult vmaFindMemoryTypeIndexForImageInfo(
      1810  VmaAllocator allocator,
      1811  const VkImageCreateInfo* pImageCreateInfo,
      1812  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      1813  uint32_t* pMemoryTypeIndex);
      1814 
      1816 typedef enum VmaPoolCreateFlagBits {
      1834  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
      1835 
      1836  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      1837 } VmaPoolCreateFlagBits;
      1838 typedef VkFlags VmaPoolCreateFlags;
      1839 
      1842 typedef struct VmaPoolCreateInfo {
      1845  uint32_t memoryTypeIndex;
      1848  VmaPoolCreateFlags flags;
      1853  VkDeviceSize blockSize;
      1858  size_t minBlockCount;
      1866  size_t maxBlockCount;
      1880  uint32_t frameInUseCount;
      1881 } VmaPoolCreateInfo;
      1882 
      1885 typedef struct VmaPoolStats {
      1888  VkDeviceSize size;
      1891  VkDeviceSize unusedSize;
      1894  size_t allocationCount;
      1897  size_t unusedRangeCount;
      1904  VkDeviceSize unusedRangeSizeMax;
      1905 } VmaPoolStats;
      1906 
      1913 VkResult vmaCreatePool(
      1914  VmaAllocator allocator,
      1915  const VmaPoolCreateInfo* pCreateInfo,
      1916  VmaPool* pPool);
      1917 
      1920 void vmaDestroyPool(
      1921  VmaAllocator allocator,
      1922  VmaPool pool);
      1923 
      1930 void vmaGetPoolStats(
      1931  VmaAllocator allocator,
      1932  VmaPool pool,
      1933  VmaPoolStats* pPoolStats);
      1934 
      1941 void vmaMakePoolAllocationsLost(
      1942  VmaAllocator allocator,
      1943  VmaPool pool,
      1944  size_t* pLostAllocationCount);
      1945 
      1960 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
      1961 
      1986 VK_DEFINE_HANDLE(VmaAllocation)
      1987 
      1988 
      1990 typedef struct VmaAllocationInfo {
      1995  uint32_t memoryType;
      2004  VkDeviceMemory deviceMemory;
      2009  VkDeviceSize offset;
      2014  VkDeviceSize size;
      2023  void* pMappedData;
      2028  void* pUserData;
      2029 } VmaAllocationInfo;
      2030 
      2041 VkResult vmaAllocateMemory(
      2042  VmaAllocator allocator,
      2043  const VkMemoryRequirements* pVkMemoryRequirements,
      2044  const VmaAllocationCreateInfo* pCreateInfo,
      2045  VmaAllocation* pAllocation,
      2046  VmaAllocationInfo* pAllocationInfo);
      2047 
      2054 VkResult vmaAllocateMemoryForBuffer(
      2055  VmaAllocator allocator,
      2056  VkBuffer buffer,
      2057  const VmaAllocationCreateInfo* pCreateInfo,
      2058  VmaAllocation* pAllocation,
      2059  VmaAllocationInfo* pAllocationInfo);
      2060 
      2062 VkResult vmaAllocateMemoryForImage(
      2063  VmaAllocator allocator,
      2064  VkImage image,
      2065  const VmaAllocationCreateInfo* pCreateInfo,
      2066  VmaAllocation* pAllocation,
      2067  VmaAllocationInfo* pAllocationInfo);
      2068 
      2070 void vmaFreeMemory(
      2071  VmaAllocator allocator,
      2072  VmaAllocation allocation);
      2073 
      2090 void vmaGetAllocationInfo(
      2091  VmaAllocator allocator,
      2092  VmaAllocation allocation,
      2093  VmaAllocationInfo* pAllocationInfo);
      2094 
      2109 VkBool32 vmaTouchAllocation(
      2110  VmaAllocator allocator,
      2111  VmaAllocation allocation);
      2112 
      2126 void vmaSetAllocationUserData(
      2127  VmaAllocator allocator,
      2128  VmaAllocation allocation,
      2129  void* pUserData);
      2130 
      2141 void vmaCreateLostAllocation(
      2142  VmaAllocator allocator,
      2143  VmaAllocation* pAllocation);
      2144 
      2179 VkResult vmaMapMemory(
      2180  VmaAllocator allocator,
      2181  VmaAllocation allocation,
      2182  void** ppData);
      2183 
      2188 void vmaUnmapMemory(
      2189  VmaAllocator allocator,
      2190  VmaAllocation allocation);
      2191 
      2204 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      2205 
      2218 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      2219 
      2236 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
      2237 
      2239 typedef struct VmaDefragmentationInfo {
      2244  VkDeviceSize maxBytesToMove;
      2249  uint32_t maxAllocationsToMove;
      2250 } VmaDefragmentationInfo;
      2251 
      2253 typedef struct VmaDefragmentationStats {
      2255  VkDeviceSize bytesMoved;
      2257  VkDeviceSize bytesFreed;
      2259  uint32_t allocationsMoved;
      2261  uint32_t deviceMemoryBlocksFreed;
      2262 } VmaDefragmentationStats;
      2263 
      2346 VkResult vmaDefragment(
      2347  VmaAllocator allocator,
      2348  VmaAllocation* pAllocations,
      2349  size_t allocationCount,
      2350  VkBool32* pAllocationsChanged,
      2351  const VmaDefragmentationInfo *pDefragmentationInfo,
      2352  VmaDefragmentationStats* pDefragmentationStats);
      2353 
      2366 VkResult vmaBindBufferMemory(
      2367  VmaAllocator allocator,
      2368  VmaAllocation allocation,
      2369  VkBuffer buffer);
      2370 
      2383 VkResult vmaBindImageMemory(
      2384  VmaAllocator allocator,
      2385  VmaAllocation allocation,
      2386  VkImage image);
      2387 
      2414 VkResult vmaCreateBuffer(
      2415  VmaAllocator allocator,
      2416  const VkBufferCreateInfo* pBufferCreateInfo,
      2417  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      2418  VkBuffer* pBuffer,
      2419  VmaAllocation* pAllocation,
      2420  VmaAllocationInfo* pAllocationInfo);
      2421 
      2433 void vmaDestroyBuffer(
      2434  VmaAllocator allocator,
      2435  VkBuffer buffer,
      2436  VmaAllocation allocation);
      2437 
      2439 VkResult vmaCreateImage(
      2440  VmaAllocator allocator,
      2441  const VkImageCreateInfo* pImageCreateInfo,
      2442  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      2443  VkImage* pImage,
      2444  VmaAllocation* pAllocation,
      2445  VmaAllocationInfo* pAllocationInfo);
      2446 
      2458 void vmaDestroyImage(
      2459  VmaAllocator allocator,
      2460  VkImage image,
      2461  VmaAllocation allocation);
      2462 
      2463 #ifdef __cplusplus
      2464 }
      2465 #endif
      2466 
      2467 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
      2468 
      2469 // For Visual Studio IntelliSense.
      2470 #if defined(__cplusplus) && defined(__INTELLISENSE__)
      2471 #define VMA_IMPLEMENTATION
      2472 #endif
      2473 
      2474 #ifdef VMA_IMPLEMENTATION
      2475 #undef VMA_IMPLEMENTATION
      2476 
      2477 #include <cstdint>
      2478 #include <cstdlib>
      2479 #include <cstring>
      2480 
      2481 /*******************************************************************************
      2482 CONFIGURATION SECTION
      2483 
      2484 Define some of these macros before each #include of this header or change them
      2485 here if you need other then default behavior depending on your environment.
      2486 */
      2487 
      2488 /*
      2489 Define this macro to 1 to make the library fetch pointers to Vulkan functions
      2490 internally, like:
      2491 
      2492  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
      2493 
      2494 Define to 0 if you are going to provide you own pointers to Vulkan functions via
      2495 VmaAllocatorCreateInfo::pVulkanFunctions.
      2496 */
      2497 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
      2498 #define VMA_STATIC_VULKAN_FUNCTIONS 1
      2499 #endif
      2500 
      2501 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
      2502 //#define VMA_USE_STL_CONTAINERS 1
      2503 
      2504 /* Set this macro to 1 to make the library including and using STL containers:
      2505 std::pair, std::vector, std::list, std::unordered_map.
      2506 
      2507 Set it to 0 or undefined to make the library using its own implementation of
      2508 the containers.
      2509 */
      2510 #if VMA_USE_STL_CONTAINERS
      2511  #define VMA_USE_STL_VECTOR 1
      2512  #define VMA_USE_STL_UNORDERED_MAP 1
      2513  #define VMA_USE_STL_LIST 1
      2514 #endif
      2515 
      2516 #if VMA_USE_STL_VECTOR
      2517  #include <vector>
      2518 #endif
      2519 
      2520 #if VMA_USE_STL_UNORDERED_MAP
      2521  #include <unordered_map>
      2522 #endif
      2523 
      2524 #if VMA_USE_STL_LIST
      2525  #include <list>
      2526 #endif
      2527 
      2528 /*
      2529 Following headers are used in this CONFIGURATION section only, so feel free to
      2530 remove them if not needed.
      2531 */
      2532 #include <cassert> // for assert
      2533 #include <algorithm> // for min, max
      2534 #include <mutex> // for std::mutex
      2535 #include <atomic> // for std::atomic
      2536 
      2537 #ifndef VMA_NULL
      2538  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
      2539  #define VMA_NULL nullptr
      2540 #endif
      2541 
      2542 #if defined(__APPLE__) || defined(__ANDROID__)
      2543 #include <cstdlib>
      2544 void *aligned_alloc(size_t alignment, size_t size)
      2545 {
      2546  // alignment must be >= sizeof(void*)
      2547  if(alignment < sizeof(void*))
      2548  {
      2549  alignment = sizeof(void*);
      2550  }
      2551 
      2552  void *pointer;
      2553  if(posix_memalign(&pointer, alignment, size) == 0)
      2554  return pointer;
      2555  return VMA_NULL;
      2556 }
      2557 #endif
      2558 
      2559 // If your compiler is not compatible with C++11 and definition of
      2560 // aligned_alloc() function is missing, uncommeting following line may help:
      2561 
      2562 //#include <malloc.h>
      2563 
      2564 // Normal assert to check for programmer's errors, especially in Debug configuration.
      2565 #ifndef VMA_ASSERT
      2566  #ifdef _DEBUG
      2567  #define VMA_ASSERT(expr) assert(expr)
      2568  #else
      2569  #define VMA_ASSERT(expr)
      2570  #endif
      2571 #endif
      2572 
      2573 // Assert that will be called very often, like inside data structures e.g. operator[].
      2574 // Making it non-empty can make program slow.
      2575 #ifndef VMA_HEAVY_ASSERT
      2576  #ifdef _DEBUG
      2577  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
      2578  #else
      2579  #define VMA_HEAVY_ASSERT(expr)
      2580  #endif
      2581 #endif
      2582 
      2583 #ifndef VMA_ALIGN_OF
      2584  #define VMA_ALIGN_OF(type) (__alignof(type))
      2585 #endif
      2586 
      2587 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
      2588  #if defined(_WIN32)
      2589  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
      2590  #else
      2591  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
      2592  #endif
      2593 #endif
      2594 
      2595 #ifndef VMA_SYSTEM_FREE
      2596  #if defined(_WIN32)
      2597  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
      2598  #else
      2599  #define VMA_SYSTEM_FREE(ptr) free(ptr)
      2600  #endif
      2601 #endif
      2602 
      2603 #ifndef VMA_MIN
      2604  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
      2605 #endif
      2606 
      2607 #ifndef VMA_MAX
      2608  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
      2609 #endif
      2610 
      2611 #ifndef VMA_SWAP
      2612  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
      2613 #endif
      2614 
      2615 #ifndef VMA_SORT
      2616  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
      2617 #endif
      2618 
      2619 #ifndef VMA_DEBUG_LOG
      2620  #define VMA_DEBUG_LOG(format, ...)
      2621  /*
      2622  #define VMA_DEBUG_LOG(format, ...) do { \
      2623  printf(format, __VA_ARGS__); \
      2624  printf("\n"); \
      2625  } while(false)
      2626  */
      2627 #endif
      2628 
      2629 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
      2630 #if VMA_STATS_STRING_ENABLED
      2631  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
      2632  {
      2633  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
      2634  }
      2635  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
      2636  {
      2637  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
      2638  }
      2639  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
      2640  {
      2641  snprintf(outStr, strLen, "%p", ptr);
      2642  }
      2643 #endif
      2644 
      2645 #ifndef VMA_MUTEX
      2646  class VmaMutex
      2647  {
      2648  public:
      2649  VmaMutex() { }
      2650  ~VmaMutex() { }
      2651  void Lock() { m_Mutex.lock(); }
      2652  void Unlock() { m_Mutex.unlock(); }
      2653  private:
      2654  std::mutex m_Mutex;
      2655  };
      2656  #define VMA_MUTEX VmaMutex
      2657 #endif
      2658 
      2659 /*
      2660 If providing your own implementation, you need to implement a subset of std::atomic:
      2661 
      2662 - Constructor(uint32_t desired)
      2663 - uint32_t load() const
      2664 - void store(uint32_t desired)
      2665 - bool compare_exchange_weak(uint32_t& expected, uint32_t desired)
      2666 */
      2667 #ifndef VMA_ATOMIC_UINT32
      2668  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
      2669 #endif
      2670 
      2671 #ifndef VMA_BEST_FIT
      2672 
      2684  #define VMA_BEST_FIT (1)
      2685 #endif
      2686 
      2687 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
      2688 
      2692  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
      2693 #endif
      2694 
      2695 #ifndef VMA_DEBUG_ALIGNMENT
      2696 
      2700  #define VMA_DEBUG_ALIGNMENT (1)
      2701 #endif
      2702 
      2703 #ifndef VMA_DEBUG_MARGIN
      2704 
      2708  #define VMA_DEBUG_MARGIN (0)
      2709 #endif
      2710 
      2711 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
      2712 
      2716  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
      2717 #endif
      2718 
      2719 #ifndef VMA_DEBUG_DETECT_CORRUPTION
      2720 
      2725  #define VMA_DEBUG_DETECT_CORRUPTION (0)
      2726 #endif
      2727 
      2728 #ifndef VMA_DEBUG_GLOBAL_MUTEX
      2729 
      2733  #define VMA_DEBUG_GLOBAL_MUTEX (0)
      2734 #endif
      2735 
      2736 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
      2737 
      2741  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
      2742 #endif
      2743 
      2744 #ifndef VMA_SMALL_HEAP_MAX_SIZE
      2745  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
      2747 #endif
      2748 
      2749 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
      2750  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
      2752 #endif
      2753 
      2754 #ifndef VMA_CLASS_NO_COPY
      2755  #define VMA_CLASS_NO_COPY(className) \
      2756  private: \
      2757  className(const className&) = delete; \
      2758  className& operator=(const className&) = delete;
      2759 #endif
      2760 
      2761 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
      2762 
      2763 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
      2764 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
      2765 
      2766 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
      2767 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
      2768 
      2769 /*******************************************************************************
      2770 END OF CONFIGURATION
      2771 */
      2772 
      2773 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
      2774  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
      2775 
      2776 // Returns number of bits set to 1 in (v).
      2777 static inline uint32_t VmaCountBitsSet(uint32_t v)
      2778 {
      2779  uint32_t c = v - ((v >> 1) & 0x55555555);
      2780  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
      2781  c = ((c >> 4) + c) & 0x0F0F0F0F;
      2782  c = ((c >> 8) + c) & 0x00FF00FF;
      2783  c = ((c >> 16) + c) & 0x0000FFFF;
      2784  return c;
      2785 }
      2786 
      2787 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
      2788 // Use types like uint32_t, uint64_t as T.
      2789 template <typename T>
      2790 static inline T VmaAlignUp(T val, T align)
      2791 {
      2792  return (val + align - 1) / align * align;
      2793 }
      2794 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
      2795 // Use types like uint32_t, uint64_t as T.
      2796 template <typename T>
      2797 static inline T VmaAlignDown(T val, T align)
      2798 {
      2799  return val / align * align;
      2800 }
      2801 
      2802 // Division with mathematical rounding to nearest number.
      2803 template <typename T>
      2804 inline T VmaRoundDiv(T x, T y)
      2805 {
      2806  return (x + (y / (T)2)) / y;
      2807 }
      2808 
      2809 static inline bool VmaStrIsEmpty(const char* pStr)
      2810 {
      2811  return pStr == VMA_NULL || *pStr == '\0';
      2812 }
      2813 
      2814 #ifndef VMA_SORT
      2815 
      2816 template<typename Iterator, typename Compare>
      2817 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
      2818 {
      2819  Iterator centerValue = end; --centerValue;
      2820  Iterator insertIndex = beg;
      2821  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
      2822  {
      2823  if(cmp(*memTypeIndex, *centerValue))
      2824  {
      2825  if(insertIndex != memTypeIndex)
      2826  {
      2827  VMA_SWAP(*memTypeIndex, *insertIndex);
      2828  }
      2829  ++insertIndex;
      2830  }
      2831  }
      2832  if(insertIndex != centerValue)
      2833  {
      2834  VMA_SWAP(*insertIndex, *centerValue);
      2835  }
      2836  return insertIndex;
      2837 }
      2838 
      2839 template<typename Iterator, typename Compare>
      2840 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
      2841 {
      2842  if(beg < end)
      2843  {
      2844  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
      2845  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
      2846  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
      2847  }
      2848 }
      2849 
      2850 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
      2851 
      2852 #endif // #ifndef VMA_SORT
      2853 
      2854 /*
      2855 Returns true if two memory blocks occupy overlapping pages.
      2856 ResourceA must be in less memory offset than ResourceB.
      2857 
      2858 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
      2859 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
      2860 */
      2861 static inline bool VmaBlocksOnSamePage(
      2862  VkDeviceSize resourceAOffset,
      2863  VkDeviceSize resourceASize,
      2864  VkDeviceSize resourceBOffset,
      2865  VkDeviceSize pageSize)
      2866 {
      2867  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
      2868  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
      2869  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
      2870  VkDeviceSize resourceBStart = resourceBOffset;
      2871  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
      2872  return resourceAEndPage == resourceBStartPage;
      2873 }
      2874 
      2875 enum VmaSuballocationType
      2876 {
      2877  VMA_SUBALLOCATION_TYPE_FREE = 0,
      2878  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
      2879  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
      2880  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
      2881  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
      2882  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
      2883  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
      2884 };
      2885 
      2886 /*
      2887 Returns true if given suballocation types could conflict and must respect
      2888 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
      2889 or linear image and another one is optimal image. If type is unknown, behave
      2890 conservatively.
      2891 */
      2892 static inline bool VmaIsBufferImageGranularityConflict(
      2893  VmaSuballocationType suballocType1,
      2894  VmaSuballocationType suballocType2)
      2895 {
      2896  if(suballocType1 > suballocType2)
      2897  {
      2898  VMA_SWAP(suballocType1, suballocType2);
      2899  }
      2900 
      2901  switch(suballocType1)
      2902  {
      2903  case VMA_SUBALLOCATION_TYPE_FREE:
      2904  return false;
      2905  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
      2906  return true;
      2907  case VMA_SUBALLOCATION_TYPE_BUFFER:
      2908  return
      2909  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      2910  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      2911  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
      2912  return
      2913  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      2914  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
      2915  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      2916  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
      2917  return
      2918  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      2919  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
      2920  return false;
      2921  default:
      2922  VMA_ASSERT(0);
      2923  return true;
      2924  }
      2925 }
      2926 
      2927 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
      2928 {
      2929  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
      2930  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      2931  for(size_t i = 0; i < numberCount; ++i, ++pDst)
      2932  {
      2933  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
      2934  }
      2935 }
      2936 
      2937 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
      2938 {
      2939  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
      2940  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      2941  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
      2942  {
      2943  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
      2944  {
      2945  return false;
      2946  }
      2947  }
      2948  return true;
      2949 }
      2950 
      2951 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
      2952 struct VmaMutexLock
      2953 {
      2954  VMA_CLASS_NO_COPY(VmaMutexLock)
      2955 public:
      2956  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex) :
      2957  m_pMutex(useMutex ? &mutex : VMA_NULL)
      2958  {
      2959  if(m_pMutex)
      2960  {
      2961  m_pMutex->Lock();
      2962  }
      2963  }
      2964 
      2965  ~VmaMutexLock()
      2966  {
      2967  if(m_pMutex)
      2968  {
      2969  m_pMutex->Unlock();
      2970  }
      2971  }
      2972 
      2973 private:
      2974  VMA_MUTEX* m_pMutex;
      2975 };
      2976 
      2977 #if VMA_DEBUG_GLOBAL_MUTEX
      2978  static VMA_MUTEX gDebugGlobalMutex;
      2979  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
      2980 #else
      2981  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
      2982 #endif
      2983 
      2984 // Minimum size of a free suballocation to register it in the free suballocation collection.
      2985 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
      2986 
      2987 /*
      2988 Performs binary search and returns iterator to first element that is greater or
      2989 equal to (key), according to comparison (cmp).
      2990 
      2991 Cmp should return true if first argument is less than second argument.
      2992 
      2993 Returned value is the found element, if present in the collection or place where
      2994 new element with value (key) should be inserted.
      2995 */
      2996 template <typename IterT, typename KeyT, typename CmpT>
      2997 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, CmpT cmp)
      2998 {
      2999  size_t down = 0, up = (end - beg);
      3000  while(down < up)
      3001  {
      3002  const size_t mid = (down + up) / 2;
      3003  if(cmp(*(beg+mid), key))
      3004  {
      3005  down = mid + 1;
      3006  }
      3007  else
      3008  {
      3009  up = mid;
      3010  }
      3011  }
      3012  return beg + down;
      3013 }
      3014 
      3016 // Memory allocation
      3017 
      3018 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
      3019 {
      3020  if((pAllocationCallbacks != VMA_NULL) &&
      3021  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
      3022  {
      3023  return (*pAllocationCallbacks->pfnAllocation)(
      3024  pAllocationCallbacks->pUserData,
      3025  size,
      3026  alignment,
      3027  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
      3028  }
      3029  else
      3030  {
      3031  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
      3032  }
      3033 }
      3034 
      3035 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
      3036 {
      3037  if((pAllocationCallbacks != VMA_NULL) &&
      3038  (pAllocationCallbacks->pfnFree != VMA_NULL))
      3039  {
      3040  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
      3041  }
      3042  else
      3043  {
      3044  VMA_SYSTEM_FREE(ptr);
      3045  }
      3046 }
      3047 
      3048 template<typename T>
      3049 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
      3050 {
      3051  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
      3052 }
      3053 
      3054 template<typename T>
      3055 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
      3056 {
      3057  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
      3058 }
      3059 
      3060 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
      3061 
      3062 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
      3063 
      3064 template<typename T>
      3065 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
      3066 {
      3067  ptr->~T();
      3068  VmaFree(pAllocationCallbacks, ptr);
      3069 }
      3070 
      3071 template<typename T>
      3072 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
      3073 {
      3074  if(ptr != VMA_NULL)
      3075  {
      3076  for(size_t i = count; i--; )
      3077  {
      3078  ptr[i].~T();
      3079  }
      3080  VmaFree(pAllocationCallbacks, ptr);
      3081  }
      3082 }
      3083 
      3084 // STL-compatible allocator.
      3085 template<typename T>
      3086 class VmaStlAllocator
      3087 {
      3088 public:
      3089  const VkAllocationCallbacks* const m_pCallbacks;
      3090  typedef T value_type;
      3091 
      3092  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
      3093  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
      3094 
      3095  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
      3096  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
      3097 
      3098  template<typename U>
      3099  bool operator==(const VmaStlAllocator<U>& rhs) const
      3100  {
      3101  return m_pCallbacks == rhs.m_pCallbacks;
      3102  }
      3103  template<typename U>
      3104  bool operator!=(const VmaStlAllocator<U>& rhs) const
      3105  {
      3106  return m_pCallbacks != rhs.m_pCallbacks;
      3107  }
      3108 
      3109  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
      3110 };
      3111 
      3112 #if VMA_USE_STL_VECTOR
      3113 
      3114 #define VmaVector std::vector
      3115 
      3116 template<typename T, typename allocatorT>
      3117 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
      3118 {
      3119  vec.insert(vec.begin() + index, item);
      3120 }
      3121 
      3122 template<typename T, typename allocatorT>
      3123 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
      3124 {
      3125  vec.erase(vec.begin() + index);
      3126 }
      3127 
      3128 #else // #if VMA_USE_STL_VECTOR
      3129 
      3130 /* Class with interface compatible with subset of std::vector.
      3131 T must be POD because constructors and destructors are not called and memcpy is
      3132 used for these objects. */
      3133 template<typename T, typename AllocatorT>
      3134 class VmaVector
      3135 {
      3136 public:
      3137  typedef T value_type;
      3138 
      3139  VmaVector(const AllocatorT& allocator) :
      3140  m_Allocator(allocator),
      3141  m_pArray(VMA_NULL),
      3142  m_Count(0),
      3143  m_Capacity(0)
      3144  {
      3145  }
      3146 
      3147  VmaVector(size_t count, const AllocatorT& allocator) :
      3148  m_Allocator(allocator),
      3149  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
      3150  m_Count(count),
      3151  m_Capacity(count)
      3152  {
      3153  }
      3154 
      3155  VmaVector(const VmaVector<T, AllocatorT>& src) :
      3156  m_Allocator(src.m_Allocator),
      3157  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
      3158  m_Count(src.m_Count),
      3159  m_Capacity(src.m_Count)
      3160  {
      3161  if(m_Count != 0)
      3162  {
      3163  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
      3164  }
      3165  }
      3166 
      3167  ~VmaVector()
      3168  {
      3169  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      3170  }
      3171 
      3172  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
      3173  {
      3174  if(&rhs != this)
      3175  {
      3176  resize(rhs.m_Count);
      3177  if(m_Count != 0)
      3178  {
      3179  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
      3180  }
      3181  }
      3182  return *this;
      3183  }
      3184 
      3185  bool empty() const { return m_Count == 0; }
      3186  size_t size() const { return m_Count; }
      3187  T* data() { return m_pArray; }
      3188  const T* data() const { return m_pArray; }
      3189 
      3190  T& operator[](size_t index)
      3191  {
      3192  VMA_HEAVY_ASSERT(index < m_Count);
      3193  return m_pArray[index];
      3194  }
      3195  const T& operator[](size_t index) const
      3196  {
      3197  VMA_HEAVY_ASSERT(index < m_Count);
      3198  return m_pArray[index];
      3199  }
      3200 
      3201  T& front()
      3202  {
      3203  VMA_HEAVY_ASSERT(m_Count > 0);
      3204  return m_pArray[0];
      3205  }
      3206  const T& front() const
      3207  {
      3208  VMA_HEAVY_ASSERT(m_Count > 0);
      3209  return m_pArray[0];
      3210  }
      3211  T& back()
      3212  {
      3213  VMA_HEAVY_ASSERT(m_Count > 0);
      3214  return m_pArray[m_Count - 1];
      3215  }
      3216  const T& back() const
      3217  {
      3218  VMA_HEAVY_ASSERT(m_Count > 0);
      3219  return m_pArray[m_Count - 1];
      3220  }
      3221 
      3222  void reserve(size_t newCapacity, bool freeMemory = false)
      3223  {
      3224  newCapacity = VMA_MAX(newCapacity, m_Count);
      3225 
      3226  if((newCapacity < m_Capacity) && !freeMemory)
      3227  {
      3228  newCapacity = m_Capacity;
      3229  }
      3230 
      3231  if(newCapacity != m_Capacity)
      3232  {
      3233  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
      3234  if(m_Count != 0)
      3235  {
      3236  memcpy(newArray, m_pArray, m_Count * sizeof(T));
      3237  }
      3238  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      3239  m_Capacity = newCapacity;
      3240  m_pArray = newArray;
      3241  }
      3242  }
      3243 
      3244  void resize(size_t newCount, bool freeMemory = false)
      3245  {
      3246  size_t newCapacity = m_Capacity;
      3247  if(newCount > m_Capacity)
      3248  {
      3249  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
      3250  }
      3251  else if(freeMemory)
      3252  {
      3253  newCapacity = newCount;
      3254  }
      3255 
      3256  if(newCapacity != m_Capacity)
      3257  {
      3258  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
      3259  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
      3260  if(elementsToCopy != 0)
      3261  {
      3262  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
      3263  }
      3264  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      3265  m_Capacity = newCapacity;
      3266  m_pArray = newArray;
      3267  }
      3268 
      3269  m_Count = newCount;
      3270  }
      3271 
      3272  void clear(bool freeMemory = false)
      3273  {
      3274  resize(0, freeMemory);
      3275  }
      3276 
      3277  void insert(size_t index, const T& src)
      3278  {
      3279  VMA_HEAVY_ASSERT(index <= m_Count);
      3280  const size_t oldCount = size();
      3281  resize(oldCount + 1);
      3282  if(index < oldCount)
      3283  {
      3284  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
      3285  }
      3286  m_pArray[index] = src;
      3287  }
      3288 
      3289  void remove(size_t index)
      3290  {
      3291  VMA_HEAVY_ASSERT(index < m_Count);
      3292  const size_t oldCount = size();
      3293  if(index < oldCount - 1)
      3294  {
      3295  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
      3296  }
      3297  resize(oldCount - 1);
      3298  }
      3299 
      3300  void push_back(const T& src)
      3301  {
      3302  const size_t newIndex = size();
      3303  resize(newIndex + 1);
      3304  m_pArray[newIndex] = src;
      3305  }
      3306 
      3307  void pop_back()
      3308  {
      3309  VMA_HEAVY_ASSERT(m_Count > 0);
      3310  resize(size() - 1);
      3311  }
      3312 
      3313  void push_front(const T& src)
      3314  {
      3315  insert(0, src);
      3316  }
      3317 
      3318  void pop_front()
      3319  {
      3320  VMA_HEAVY_ASSERT(m_Count > 0);
      3321  remove(0);
      3322  }
      3323 
      3324  typedef T* iterator;
      3325 
      3326  iterator begin() { return m_pArray; }
      3327  iterator end() { return m_pArray + m_Count; }
      3328 
      3329 private:
      3330  AllocatorT m_Allocator;
      3331  T* m_pArray;
      3332  size_t m_Count;
      3333  size_t m_Capacity;
      3334 };
      3335 
      3336 template<typename T, typename allocatorT>
      3337 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
      3338 {
      3339  vec.insert(index, item);
      3340 }
      3341 
      3342 template<typename T, typename allocatorT>
      3343 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
      3344 {
      3345  vec.remove(index);
      3346 }
      3347 
      3348 #endif // #if VMA_USE_STL_VECTOR
      3349 
      3350 template<typename CmpLess, typename VectorT>
      3351 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
      3352 {
      3353  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      3354  vector.data(),
      3355  vector.data() + vector.size(),
      3356  value,
      3357  CmpLess()) - vector.data();
      3358  VmaVectorInsert(vector, indexToInsert, value);
      3359  return indexToInsert;
      3360 }
      3361 
      3362 template<typename CmpLess, typename VectorT>
      3363 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
      3364 {
      3365  CmpLess comparator;
      3366  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
      3367  vector.begin(),
      3368  vector.end(),
      3369  value,
      3370  comparator);
      3371  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
      3372  {
      3373  size_t indexToRemove = it - vector.begin();
      3374  VmaVectorRemove(vector, indexToRemove);
      3375  return true;
      3376  }
      3377  return false;
      3378 }
      3379 
      3380 template<typename CmpLess, typename VectorT>
      3381 size_t VmaVectorFindSorted(const VectorT& vector, const typename VectorT::value_type& value)
      3382 {
      3383  CmpLess comparator;
      3384  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
      3385  vector.data(),
      3386  vector.data() + vector.size(),
      3387  value,
      3388  comparator);
      3389  if(it != vector.size() && !comparator(*it, value) && !comparator(value, *it))
      3390  {
      3391  return it - vector.begin();
      3392  }
      3393  else
      3394  {
      3395  return vector.size();
      3396  }
      3397 }
      3398 
      3400 // class VmaPoolAllocator
      3401 
      3402 /*
      3403 Allocator for objects of type T using a list of arrays (pools) to speed up
      3404 allocation. Number of elements that can be allocated is not bounded because
      3405 allocator can create multiple blocks.
      3406 */
      3407 template<typename T>
      3408 class VmaPoolAllocator
      3409 {
      3410  VMA_CLASS_NO_COPY(VmaPoolAllocator)
      3411 public:
      3412  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock);
      3413  ~VmaPoolAllocator();
      3414  void Clear();
      3415  T* Alloc();
      3416  void Free(T* ptr);
      3417 
      3418 private:
      3419  union Item
      3420  {
      3421  uint32_t NextFreeIndex;
      3422  T Value;
      3423  };
      3424 
      3425  struct ItemBlock
      3426  {
      3427  Item* pItems;
      3428  uint32_t FirstFreeIndex;
      3429  };
      3430 
      3431  const VkAllocationCallbacks* m_pAllocationCallbacks;
      3432  size_t m_ItemsPerBlock;
      3433  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
      3434 
      3435  ItemBlock& CreateNewBlock();
      3436 };
      3437 
      3438 template<typename T>
      3439 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, size_t itemsPerBlock) :
      3440  m_pAllocationCallbacks(pAllocationCallbacks),
      3441  m_ItemsPerBlock(itemsPerBlock),
      3442  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
      3443 {
      3444  VMA_ASSERT(itemsPerBlock > 0);
      3445 }
      3446 
      3447 template<typename T>
      3448 VmaPoolAllocator<T>::~VmaPoolAllocator()
      3449 {
      3450  Clear();
      3451 }
      3452 
      3453 template<typename T>
      3454 void VmaPoolAllocator<T>::Clear()
      3455 {
      3456  for(size_t i = m_ItemBlocks.size(); i--; )
      3457  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemsPerBlock);
      3458  m_ItemBlocks.clear();
      3459 }
      3460 
      3461 template<typename T>
      3462 T* VmaPoolAllocator<T>::Alloc()
      3463 {
      3464  for(size_t i = m_ItemBlocks.size(); i--; )
      3465  {
      3466  ItemBlock& block = m_ItemBlocks[i];
      3467  // This block has some free items: Use first one.
      3468  if(block.FirstFreeIndex != UINT32_MAX)
      3469  {
      3470  Item* const pItem = &block.pItems[block.FirstFreeIndex];
      3471  block.FirstFreeIndex = pItem->NextFreeIndex;
      3472  return &pItem->Value;
      3473  }
      3474  }
      3475 
      3476  // No block has free item: Create new one and use it.
      3477  ItemBlock& newBlock = CreateNewBlock();
      3478  Item* const pItem = &newBlock.pItems[0];
      3479  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
      3480  return &pItem->Value;
      3481 }
      3482 
      3483 template<typename T>
      3484 void VmaPoolAllocator<T>::Free(T* ptr)
      3485 {
      3486  // Search all memory blocks to find ptr.
      3487  for(size_t i = 0; i < m_ItemBlocks.size(); ++i)
      3488  {
      3489  ItemBlock& block = m_ItemBlocks[i];
      3490 
      3491  // Casting to union.
      3492  Item* pItemPtr;
      3493  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
      3494 
      3495  // Check if pItemPtr is in address range of this block.
      3496  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + m_ItemsPerBlock))
      3497  {
      3498  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
      3499  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
      3500  block.FirstFreeIndex = index;
      3501  return;
      3502  }
      3503  }
      3504  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
      3505 }
      3506 
      3507 template<typename T>
      3508 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
      3509 {
      3510  ItemBlock newBlock = {
      3511  vma_new_array(m_pAllocationCallbacks, Item, m_ItemsPerBlock), 0 };
      3512 
      3513  m_ItemBlocks.push_back(newBlock);
      3514 
      3515  // Setup singly-linked list of all free items in this block.
      3516  for(uint32_t i = 0; i < m_ItemsPerBlock - 1; ++i)
      3517  newBlock.pItems[i].NextFreeIndex = i + 1;
      3518  newBlock.pItems[m_ItemsPerBlock - 1].NextFreeIndex = UINT32_MAX;
      3519  return m_ItemBlocks.back();
      3520 }
      3521 
      3523 // class VmaRawList, VmaList
      3524 
      3525 #if VMA_USE_STL_LIST
      3526 
      3527 #define VmaList std::list
      3528 
      3529 #else // #if VMA_USE_STL_LIST
      3530 
      3531 template<typename T>
      3532 struct VmaListItem
      3533 {
      3534  VmaListItem* pPrev;
      3535  VmaListItem* pNext;
      3536  T Value;
      3537 };
      3538 
      3539 // Doubly linked list.
      3540 template<typename T>
      3541 class VmaRawList
      3542 {
      3543  VMA_CLASS_NO_COPY(VmaRawList)
      3544 public:
      3545  typedef VmaListItem<T> ItemType;
      3546 
      3547  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
      3548  ~VmaRawList();
      3549  void Clear();
      3550 
      3551  size_t GetCount() const { return m_Count; }
      3552  bool IsEmpty() const { return m_Count == 0; }
      3553 
      3554  ItemType* Front() { return m_pFront; }
      3555  const ItemType* Front() const { return m_pFront; }
      3556  ItemType* Back() { return m_pBack; }
      3557  const ItemType* Back() const { return m_pBack; }
      3558 
      3559  ItemType* PushBack();
      3560  ItemType* PushFront();
      3561  ItemType* PushBack(const T& value);
      3562  ItemType* PushFront(const T& value);
      3563  void PopBack();
      3564  void PopFront();
      3565 
      3566  // Item can be null - it means PushBack.
      3567  ItemType* InsertBefore(ItemType* pItem);
      3568  // Item can be null - it means PushFront.
      3569  ItemType* InsertAfter(ItemType* pItem);
      3570 
      3571  ItemType* InsertBefore(ItemType* pItem, const T& value);
      3572  ItemType* InsertAfter(ItemType* pItem, const T& value);
      3573 
      3574  void Remove(ItemType* pItem);
      3575 
      3576 private:
      3577  const VkAllocationCallbacks* const m_pAllocationCallbacks;
      3578  VmaPoolAllocator<ItemType> m_ItemAllocator;
      3579  ItemType* m_pFront;
      3580  ItemType* m_pBack;
      3581  size_t m_Count;
      3582 };
      3583 
      3584 template<typename T>
      3585 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
      3586  m_pAllocationCallbacks(pAllocationCallbacks),
      3587  m_ItemAllocator(pAllocationCallbacks, 128),
      3588  m_pFront(VMA_NULL),
      3589  m_pBack(VMA_NULL),
      3590  m_Count(0)
      3591 {
      3592 }
      3593 
      3594 template<typename T>
      3595 VmaRawList<T>::~VmaRawList()
      3596 {
      3597  // Intentionally not calling Clear, because that would be unnecessary
      3598  // computations to return all items to m_ItemAllocator as free.
      3599 }
      3600 
      3601 template<typename T>
      3602 void VmaRawList<T>::Clear()
      3603 {
      3604  if(IsEmpty() == false)
      3605  {
      3606  ItemType* pItem = m_pBack;
      3607  while(pItem != VMA_NULL)
      3608  {
      3609  ItemType* const pPrevItem = pItem->pPrev;
      3610  m_ItemAllocator.Free(pItem);
      3611  pItem = pPrevItem;
      3612  }
      3613  m_pFront = VMA_NULL;
      3614  m_pBack = VMA_NULL;
      3615  m_Count = 0;
      3616  }
      3617 }
      3618 
      3619 template<typename T>
      3620 VmaListItem<T>* VmaRawList<T>::PushBack()
      3621 {
      3622  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      3623  pNewItem->pNext = VMA_NULL;
      3624  if(IsEmpty())
      3625  {
      3626  pNewItem->pPrev = VMA_NULL;
      3627  m_pFront = pNewItem;
      3628  m_pBack = pNewItem;
      3629  m_Count = 1;
      3630  }
      3631  else
      3632  {
      3633  pNewItem->pPrev = m_pBack;
      3634  m_pBack->pNext = pNewItem;
      3635  m_pBack = pNewItem;
      3636  ++m_Count;
      3637  }
      3638  return pNewItem;
      3639 }
      3640 
      3641 template<typename T>
      3642 VmaListItem<T>* VmaRawList<T>::PushFront()
      3643 {
      3644  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      3645  pNewItem->pPrev = VMA_NULL;
      3646  if(IsEmpty())
      3647  {
      3648  pNewItem->pNext = VMA_NULL;
      3649  m_pFront = pNewItem;
      3650  m_pBack = pNewItem;
      3651  m_Count = 1;
      3652  }
      3653  else
      3654  {
      3655  pNewItem->pNext = m_pFront;
      3656  m_pFront->pPrev = pNewItem;
      3657  m_pFront = pNewItem;
      3658  ++m_Count;
      3659  }
      3660  return pNewItem;
      3661 }
      3662 
      3663 template<typename T>
      3664 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
      3665 {
      3666  ItemType* const pNewItem = PushBack();
      3667  pNewItem->Value = value;
      3668  return pNewItem;
      3669 }
      3670 
      3671 template<typename T>
      3672 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
      3673 {
      3674  ItemType* const pNewItem = PushFront();
      3675  pNewItem->Value = value;
      3676  return pNewItem;
      3677 }
      3678 
      3679 template<typename T>
      3680 void VmaRawList<T>::PopBack()
      3681 {
      3682  VMA_HEAVY_ASSERT(m_Count > 0);
      3683  ItemType* const pBackItem = m_pBack;
      3684  ItemType* const pPrevItem = pBackItem->pPrev;
      3685  if(pPrevItem != VMA_NULL)
      3686  {
      3687  pPrevItem->pNext = VMA_NULL;
      3688  }
      3689  m_pBack = pPrevItem;
      3690  m_ItemAllocator.Free(pBackItem);
      3691  --m_Count;
      3692 }
      3693 
      3694 template<typename T>
      3695 void VmaRawList<T>::PopFront()
      3696 {
      3697  VMA_HEAVY_ASSERT(m_Count > 0);
      3698  ItemType* const pFrontItem = m_pFront;
      3699  ItemType* const pNextItem = pFrontItem->pNext;
      3700  if(pNextItem != VMA_NULL)
      3701  {
      3702  pNextItem->pPrev = VMA_NULL;
      3703  }
      3704  m_pFront = pNextItem;
      3705  m_ItemAllocator.Free(pFrontItem);
      3706  --m_Count;
      3707 }
      3708 
      3709 template<typename T>
      3710 void VmaRawList<T>::Remove(ItemType* pItem)
      3711 {
      3712  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
      3713  VMA_HEAVY_ASSERT(m_Count > 0);
      3714 
      3715  if(pItem->pPrev != VMA_NULL)
      3716  {
      3717  pItem->pPrev->pNext = pItem->pNext;
      3718  }
      3719  else
      3720  {
      3721  VMA_HEAVY_ASSERT(m_pFront == pItem);
      3722  m_pFront = pItem->pNext;
      3723  }
      3724 
      3725  if(pItem->pNext != VMA_NULL)
      3726  {
      3727  pItem->pNext->pPrev = pItem->pPrev;
      3728  }
      3729  else
      3730  {
      3731  VMA_HEAVY_ASSERT(m_pBack == pItem);
      3732  m_pBack = pItem->pPrev;
      3733  }
      3734 
      3735  m_ItemAllocator.Free(pItem);
      3736  --m_Count;
      3737 }
      3738 
      3739 template<typename T>
      3740 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
      3741 {
      3742  if(pItem != VMA_NULL)
      3743  {
      3744  ItemType* const prevItem = pItem->pPrev;
      3745  ItemType* const newItem = m_ItemAllocator.Alloc();
      3746  newItem->pPrev = prevItem;
      3747  newItem->pNext = pItem;
      3748  pItem->pPrev = newItem;
      3749  if(prevItem != VMA_NULL)
      3750  {
      3751  prevItem->pNext = newItem;
      3752  }
      3753  else
      3754  {
      3755  VMA_HEAVY_ASSERT(m_pFront == pItem);
      3756  m_pFront = newItem;
      3757  }
      3758  ++m_Count;
      3759  return newItem;
      3760  }
      3761  else
      3762  return PushBack();
      3763 }
      3764 
      3765 template<typename T>
      3766 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
      3767 {
      3768  if(pItem != VMA_NULL)
      3769  {
      3770  ItemType* const nextItem = pItem->pNext;
      3771  ItemType* const newItem = m_ItemAllocator.Alloc();
      3772  newItem->pNext = nextItem;
      3773  newItem->pPrev = pItem;
      3774  pItem->pNext = newItem;
      3775  if(nextItem != VMA_NULL)
      3776  {
      3777  nextItem->pPrev = newItem;
      3778  }
      3779  else
      3780  {
      3781  VMA_HEAVY_ASSERT(m_pBack == pItem);
      3782  m_pBack = newItem;
      3783  }
      3784  ++m_Count;
      3785  return newItem;
      3786  }
      3787  else
      3788  return PushFront();
      3789 }
      3790 
      3791 template<typename T>
      3792 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
      3793 {
      3794  ItemType* const newItem = InsertBefore(pItem);
      3795  newItem->Value = value;
      3796  return newItem;
      3797 }
      3798 
      3799 template<typename T>
      3800 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
      3801 {
      3802  ItemType* const newItem = InsertAfter(pItem);
      3803  newItem->Value = value;
      3804  return newItem;
      3805 }
      3806 
      3807 template<typename T, typename AllocatorT>
      3808 class VmaList
      3809 {
      3810  VMA_CLASS_NO_COPY(VmaList)
      3811 public:
      3812  class iterator
      3813  {
      3814  public:
      3815  iterator() :
      3816  m_pList(VMA_NULL),
      3817  m_pItem(VMA_NULL)
      3818  {
      3819  }
      3820 
      3821  T& operator*() const
      3822  {
      3823  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3824  return m_pItem->Value;
      3825  }
      3826  T* operator->() const
      3827  {
      3828  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3829  return &m_pItem->Value;
      3830  }
      3831 
      3832  iterator& operator++()
      3833  {
      3834  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3835  m_pItem = m_pItem->pNext;
      3836  return *this;
      3837  }
      3838  iterator& operator--()
      3839  {
      3840  if(m_pItem != VMA_NULL)
      3841  {
      3842  m_pItem = m_pItem->pPrev;
      3843  }
      3844  else
      3845  {
      3846  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      3847  m_pItem = m_pList->Back();
      3848  }
      3849  return *this;
      3850  }
      3851 
      3852  iterator operator++(int)
      3853  {
      3854  iterator result = *this;
      3855  ++*this;
      3856  return result;
      3857  }
      3858  iterator operator--(int)
      3859  {
      3860  iterator result = *this;
      3861  --*this;
      3862  return result;
      3863  }
      3864 
      3865  bool operator==(const iterator& rhs) const
      3866  {
      3867  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3868  return m_pItem == rhs.m_pItem;
      3869  }
      3870  bool operator!=(const iterator& rhs) const
      3871  {
      3872  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3873  return m_pItem != rhs.m_pItem;
      3874  }
      3875 
      3876  private:
      3877  VmaRawList<T>* m_pList;
      3878  VmaListItem<T>* m_pItem;
      3879 
      3880  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
      3881  m_pList(pList),
      3882  m_pItem(pItem)
      3883  {
      3884  }
      3885 
      3886  friend class VmaList<T, AllocatorT>;
      3887  };
      3888 
      3889  class const_iterator
      3890  {
      3891  public:
      3892  const_iterator() :
      3893  m_pList(VMA_NULL),
      3894  m_pItem(VMA_NULL)
      3895  {
      3896  }
      3897 
      3898  const_iterator(const iterator& src) :
      3899  m_pList(src.m_pList),
      3900  m_pItem(src.m_pItem)
      3901  {
      3902  }
      3903 
      3904  const T& operator*() const
      3905  {
      3906  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3907  return m_pItem->Value;
      3908  }
      3909  const T* operator->() const
      3910  {
      3911  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3912  return &m_pItem->Value;
      3913  }
      3914 
      3915  const_iterator& operator++()
      3916  {
      3917  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      3918  m_pItem = m_pItem->pNext;
      3919  return *this;
      3920  }
      3921  const_iterator& operator--()
      3922  {
      3923  if(m_pItem != VMA_NULL)
      3924  {
      3925  m_pItem = m_pItem->pPrev;
      3926  }
      3927  else
      3928  {
      3929  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      3930  m_pItem = m_pList->Back();
      3931  }
      3932  return *this;
      3933  }
      3934 
      3935  const_iterator operator++(int)
      3936  {
      3937  const_iterator result = *this;
      3938  ++*this;
      3939  return result;
      3940  }
      3941  const_iterator operator--(int)
      3942  {
      3943  const_iterator result = *this;
      3944  --*this;
      3945  return result;
      3946  }
      3947 
      3948  bool operator==(const const_iterator& rhs) const
      3949  {
      3950  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3951  return m_pItem == rhs.m_pItem;
      3952  }
      3953  bool operator!=(const const_iterator& rhs) const
      3954  {
      3955  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      3956  return m_pItem != rhs.m_pItem;
      3957  }
      3958 
      3959  private:
      3960  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
      3961  m_pList(pList),
      3962  m_pItem(pItem)
      3963  {
      3964  }
      3965 
      3966  const VmaRawList<T>* m_pList;
      3967  const VmaListItem<T>* m_pItem;
      3968 
      3969  friend class VmaList<T, AllocatorT>;
      3970  };
      3971 
      3972  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
      3973 
      3974  bool empty() const { return m_RawList.IsEmpty(); }
      3975  size_t size() const { return m_RawList.GetCount(); }
      3976 
      3977  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
      3978  iterator end() { return iterator(&m_RawList, VMA_NULL); }
      3979 
      3980  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
      3981  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
      3982 
      3983  void clear() { m_RawList.Clear(); }
      3984  void push_back(const T& value) { m_RawList.PushBack(value); }
      3985  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
      3986  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
      3987 
      3988 private:
      3989  VmaRawList<T> m_RawList;
      3990 };
      3991 
      3992 #endif // #if VMA_USE_STL_LIST
      3993 
      3995 // class VmaMap
      3996 
      3997 // Unused in this version.
      3998 #if 0
      3999 
      4000 #if VMA_USE_STL_UNORDERED_MAP
      4001 
      4002 #define VmaPair std::pair
      4003 
      4004 #define VMA_MAP_TYPE(KeyT, ValueT) \
      4005  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
      4006 
      4007 #else // #if VMA_USE_STL_UNORDERED_MAP
      4008 
      4009 template<typename T1, typename T2>
      4010 struct VmaPair
      4011 {
      4012  T1 first;
      4013  T2 second;
      4014 
      4015  VmaPair() : first(), second() { }
      4016  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
      4017 };
      4018 
      4019 /* Class compatible with subset of interface of std::unordered_map.
      4020 KeyT, ValueT must be POD because they will be stored in VmaVector.
      4021 */
      4022 template<typename KeyT, typename ValueT>
      4023 class VmaMap
      4024 {
      4025 public:
      4026  typedef VmaPair<KeyT, ValueT> PairType;
      4027  typedef PairType* iterator;
      4028 
      4029  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
      4030 
      4031  iterator begin() { return m_Vector.begin(); }
      4032  iterator end() { return m_Vector.end(); }
      4033 
      4034  void insert(const PairType& pair);
      4035  iterator find(const KeyT& key);
      4036  void erase(iterator it);
      4037 
      4038 private:
      4039  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
      4040 };
      4041 
      4042 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
      4043 
      4044 template<typename FirstT, typename SecondT>
      4045 struct VmaPairFirstLess
      4046 {
      4047  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
      4048  {
      4049  return lhs.first < rhs.first;
      4050  }
      4051  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
      4052  {
      4053  return lhs.first < rhsFirst;
      4054  }
      4055 };
      4056 
      4057 template<typename KeyT, typename ValueT>
      4058 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
      4059 {
      4060  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      4061  m_Vector.data(),
      4062  m_Vector.data() + m_Vector.size(),
      4063  pair,
      4064  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
      4065  VmaVectorInsert(m_Vector, indexToInsert, pair);
      4066 }
      4067 
      4068 template<typename KeyT, typename ValueT>
      4069 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
      4070 {
      4071  PairType* it = VmaBinaryFindFirstNotLess(
      4072  m_Vector.data(),
      4073  m_Vector.data() + m_Vector.size(),
      4074  key,
      4075  VmaPairFirstLess<KeyT, ValueT>());
      4076  if((it != m_Vector.end()) && (it->first == key))
      4077  {
      4078  return it;
      4079  }
      4080  else
      4081  {
      4082  return m_Vector.end();
      4083  }
      4084 }
      4085 
      4086 template<typename KeyT, typename ValueT>
      4087 void VmaMap<KeyT, ValueT>::erase(iterator it)
      4088 {
      4089  VmaVectorRemove(m_Vector, it - m_Vector.begin());
      4090 }
      4091 
      4092 #endif // #if VMA_USE_STL_UNORDERED_MAP
      4093 
      4094 #endif // #if 0
      4095 
      4097 
      4098 class VmaDeviceMemoryBlock;
      4099 
      4100 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
      4101 
      4102 struct VmaAllocation_T
      4103 {
      4104  VMA_CLASS_NO_COPY(VmaAllocation_T)
      4105 private:
      4106  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
      4107 
      4108  enum FLAGS
      4109  {
      4110  FLAG_USER_DATA_STRING = 0x01,
      4111  };
      4112 
      4113 public:
      4114  enum ALLOCATION_TYPE
      4115  {
      4116  ALLOCATION_TYPE_NONE,
      4117  ALLOCATION_TYPE_BLOCK,
      4118  ALLOCATION_TYPE_DEDICATED,
      4119  };
      4120 
      4121  VmaAllocation_T(uint32_t currentFrameIndex, bool userDataString) :
      4122  m_Alignment(1),
      4123  m_Size(0),
      4124  m_pUserData(VMA_NULL),
      4125  m_LastUseFrameIndex(currentFrameIndex),
      4126  m_Type((uint8_t)ALLOCATION_TYPE_NONE),
      4127  m_SuballocationType((uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN),
      4128  m_MapCount(0),
      4129  m_Flags(userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0)
      4130  {
      4131 #if VMA_STATS_STRING_ENABLED
      4132  m_CreationFrameIndex = currentFrameIndex;
      4133  m_BufferImageUsage = 0;
      4134 #endif
      4135  }
      4136 
      4137  ~VmaAllocation_T()
      4138  {
      4139  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
      4140 
      4141  // Check if owned string was freed.
      4142  VMA_ASSERT(m_pUserData == VMA_NULL);
      4143  }
      4144 
      4145  void InitBlockAllocation(
      4146  VmaPool hPool,
      4147  VmaDeviceMemoryBlock* block,
      4148  VkDeviceSize offset,
      4149  VkDeviceSize alignment,
      4150  VkDeviceSize size,
      4151  VmaSuballocationType suballocationType,
      4152  bool mapped,
      4153  bool canBecomeLost)
      4154  {
      4155  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      4156  VMA_ASSERT(block != VMA_NULL);
      4157  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      4158  m_Alignment = alignment;
      4159  m_Size = size;
      4160  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      4161  m_SuballocationType = (uint8_t)suballocationType;
      4162  m_BlockAllocation.m_hPool = hPool;
      4163  m_BlockAllocation.m_Block = block;
      4164  m_BlockAllocation.m_Offset = offset;
      4165  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
      4166  }
      4167 
      4168  void InitLost()
      4169  {
      4170  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      4171  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
      4172  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      4173  m_BlockAllocation.m_hPool = VK_NULL_HANDLE;
      4174  m_BlockAllocation.m_Block = VMA_NULL;
      4175  m_BlockAllocation.m_Offset = 0;
      4176  m_BlockAllocation.m_CanBecomeLost = true;
      4177  }
      4178 
      4179  void ChangeBlockAllocation(
      4180  VmaAllocator hAllocator,
      4181  VmaDeviceMemoryBlock* block,
      4182  VkDeviceSize offset);
      4183 
      4184  // pMappedData not null means allocation is created with MAPPED flag.
      4185  void InitDedicatedAllocation(
      4186  uint32_t memoryTypeIndex,
      4187  VkDeviceMemory hMemory,
      4188  VmaSuballocationType suballocationType,
      4189  void* pMappedData,
      4190  VkDeviceSize size)
      4191  {
      4192  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      4193  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
      4194  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
      4195  m_Alignment = 0;
      4196  m_Size = size;
      4197  m_SuballocationType = (uint8_t)suballocationType;
      4198  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      4199  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
      4200  m_DedicatedAllocation.m_hMemory = hMemory;
      4201  m_DedicatedAllocation.m_pMappedData = pMappedData;
      4202  }
      4203 
      4204  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
      4205  VkDeviceSize GetAlignment() const { return m_Alignment; }
      4206  VkDeviceSize GetSize() const { return m_Size; }
      4207  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
      4208  void* GetUserData() const { return m_pUserData; }
      4209  void SetUserData(VmaAllocator hAllocator, void* pUserData);
      4210  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
      4211 
      4212  VmaDeviceMemoryBlock* GetBlock() const
      4213  {
      4214  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      4215  return m_BlockAllocation.m_Block;
      4216  }
      4217  VkDeviceSize GetOffset() const;
      4218  VkDeviceMemory GetMemory() const;
      4219  uint32_t GetMemoryTypeIndex() const;
      4220  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
      4221  void* GetMappedData() const;
      4222  bool CanBecomeLost() const;
      4223  VmaPool GetPool() const;
      4224 
      4225  uint32_t GetLastUseFrameIndex() const
      4226  {
      4227  return m_LastUseFrameIndex.load();
      4228  }
      4229  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
      4230  {
      4231  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
      4232  }
      4233  /*
      4234  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
      4235  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
      4236  - Else, returns false.
      4237 
      4238  If hAllocation is already lost, assert - you should not call it then.
      4239  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
      4240  */
      4241  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      4242 
      4243  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
      4244  {
      4245  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
      4246  outInfo.blockCount = 1;
      4247  outInfo.allocationCount = 1;
      4248  outInfo.unusedRangeCount = 0;
      4249  outInfo.usedBytes = m_Size;
      4250  outInfo.unusedBytes = 0;
      4251  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
      4252  outInfo.unusedRangeSizeMin = UINT64_MAX;
      4253  outInfo.unusedRangeSizeMax = 0;
      4254  }
      4255 
      4256  void BlockAllocMap();
      4257  void BlockAllocUnmap();
      4258  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
      4259  void DedicatedAllocUnmap(VmaAllocator hAllocator);
      4260 
      4261 #if VMA_STATS_STRING_ENABLED
      4262  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
      4263  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
      4264 
      4265  void InitBufferImageUsage(uint32_t bufferImageUsage)
      4266  {
      4267  VMA_ASSERT(m_BufferImageUsage == 0);
      4268  m_BufferImageUsage = bufferImageUsage;
      4269  }
      4270 
      4271  void PrintParameters(class VmaJsonWriter& json) const;
      4272 #endif
      4273 
      4274 private:
      4275  VkDeviceSize m_Alignment;
      4276  VkDeviceSize m_Size;
      4277  void* m_pUserData;
      4278  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
      4279  uint8_t m_Type; // ALLOCATION_TYPE
      4280  uint8_t m_SuballocationType; // VmaSuballocationType
      4281  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
      4282  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
      4283  uint8_t m_MapCount;
      4284  uint8_t m_Flags; // enum FLAGS
      4285 
      4286  // Allocation out of VmaDeviceMemoryBlock.
      4287  struct BlockAllocation
      4288  {
      4289  VmaPool m_hPool; // Null if belongs to general memory.
      4290  VmaDeviceMemoryBlock* m_Block;
      4291  VkDeviceSize m_Offset;
      4292  bool m_CanBecomeLost;
      4293  };
      4294 
      4295  // Allocation for an object that has its own private VkDeviceMemory.
      4296  struct DedicatedAllocation
      4297  {
      4298  uint32_t m_MemoryTypeIndex;
      4299  VkDeviceMemory m_hMemory;
      4300  void* m_pMappedData; // Not null means memory is mapped.
      4301  };
      4302 
      4303  union
      4304  {
      4305  // Allocation out of VmaDeviceMemoryBlock.
      4306  BlockAllocation m_BlockAllocation;
      4307  // Allocation for an object that has its own private VkDeviceMemory.
      4308  DedicatedAllocation m_DedicatedAllocation;
      4309  };
      4310 
      4311 #if VMA_STATS_STRING_ENABLED
      4312  uint32_t m_CreationFrameIndex;
      4313  uint32_t m_BufferImageUsage; // 0 if unknown.
      4314 #endif
      4315 
      4316  void FreeUserDataString(VmaAllocator hAllocator);
      4317 };
      4318 
      4319 /*
      4320 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
      4321 allocated memory block or free.
      4322 */
      4323 struct VmaSuballocation
      4324 {
      4325  VkDeviceSize offset;
      4326  VkDeviceSize size;
      4327  VmaAllocation hAllocation;
      4328  VmaSuballocationType type;
      4329 };
      4330 
      4331 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
      4332 
      4333 // Cost of one additional allocation lost, as equivalent in bytes.
      4334 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
      4335 
      4336 /*
      4337 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
      4338 
      4339 If canMakeOtherLost was false:
      4340 - item points to a FREE suballocation.
      4341 - itemsToMakeLostCount is 0.
      4342 
      4343 If canMakeOtherLost was true:
      4344 - item points to first of sequence of suballocations, which are either FREE,
      4345  or point to VmaAllocations that can become lost.
      4346 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
      4347  the requested allocation to succeed.
      4348 */
      4349 struct VmaAllocationRequest
      4350 {
      4351  VkDeviceSize offset;
      4352  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
      4353  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
      4354  VmaSuballocationList::iterator item;
      4355  size_t itemsToMakeLostCount;
      4356 
      4357  VkDeviceSize CalcCost() const
      4358  {
      4359  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
      4360  }
      4361 };
      4362 
      4363 /*
      4364 Data structure used for bookkeeping of allocations and unused ranges of memory
      4365 in a single VkDeviceMemory block.
      4366 */
      4367 class VmaBlockMetadata
      4368 {
      4369  VMA_CLASS_NO_COPY(VmaBlockMetadata)
      4370 public:
      4371  VmaBlockMetadata(VmaAllocator hAllocator);
      4372  ~VmaBlockMetadata();
      4373  void Init(VkDeviceSize size);
      4374 
      4375  // Validates all data structures inside this object. If not valid, returns false.
      4376  bool Validate() const;
      4377  VkDeviceSize GetSize() const { return m_Size; }
      4378  size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
      4379  VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
      4380  VkDeviceSize GetUnusedRangeSizeMax() const;
      4381  // Returns true if this block is empty - contains only single free suballocation.
      4382  bool IsEmpty() const;
      4383 
      4384  void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      4385  void AddPoolStats(VmaPoolStats& inoutStats) const;
      4386 
      4387 #if VMA_STATS_STRING_ENABLED
      4388  void PrintDetailedMap(class VmaJsonWriter& json) const;
      4389 #endif
      4390 
      4391  // Tries to find a place for suballocation with given parameters inside this block.
      4392  // If succeeded, fills pAllocationRequest and returns true.
      4393  // If failed, returns false.
      4394  bool CreateAllocationRequest(
      4395  uint32_t currentFrameIndex,
      4396  uint32_t frameInUseCount,
      4397  VkDeviceSize bufferImageGranularity,
      4398  VkDeviceSize allocSize,
      4399  VkDeviceSize allocAlignment,
      4400  VmaSuballocationType allocType,
      4401  bool canMakeOtherLost,
      4402  VmaAllocationRequest* pAllocationRequest);
      4403 
      4404  bool MakeRequestedAllocationsLost(
      4405  uint32_t currentFrameIndex,
      4406  uint32_t frameInUseCount,
      4407  VmaAllocationRequest* pAllocationRequest);
      4408 
      4409  uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      4410 
      4411  VkResult CheckCorruption(const void* pBlockData);
      4412 
      4413  // Makes actual allocation based on request. Request must already be checked and valid.
      4414  void Alloc(
      4415  const VmaAllocationRequest& request,
      4416  VmaSuballocationType type,
      4417  VkDeviceSize allocSize,
      4418  VmaAllocation hAllocation);
      4419 
      4420  // Frees suballocation assigned to given memory region.
      4421  void Free(const VmaAllocation allocation);
      4422  void FreeAtOffset(VkDeviceSize offset);
      4423 
      4424 private:
      4425  VkDeviceSize m_Size;
      4426  uint32_t m_FreeCount;
      4427  VkDeviceSize m_SumFreeSize;
      4428  VmaSuballocationList m_Suballocations;
      4429  // Suballocations that are free and have size greater than certain threshold.
      4430  // Sorted by size, ascending.
      4431  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
      4432 
      4433  bool ValidateFreeSuballocationList() const;
      4434 
      4435  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
      4436  // If yes, fills pOffset and returns true. If no, returns false.
      4437  bool CheckAllocation(
      4438  uint32_t currentFrameIndex,
      4439  uint32_t frameInUseCount,
      4440  VkDeviceSize bufferImageGranularity,
      4441  VkDeviceSize allocSize,
      4442  VkDeviceSize allocAlignment,
      4443  VmaSuballocationType allocType,
      4444  VmaSuballocationList::const_iterator suballocItem,
      4445  bool canMakeOtherLost,
      4446  VkDeviceSize* pOffset,
      4447  size_t* itemsToMakeLostCount,
      4448  VkDeviceSize* pSumFreeSize,
      4449  VkDeviceSize* pSumItemSize) const;
      4450  // Given free suballocation, it merges it with following one, which must also be free.
      4451  void MergeFreeWithNext(VmaSuballocationList::iterator item);
      4452  // Releases given suballocation, making it free.
      4453  // Merges it with adjacent free suballocations if applicable.
      4454  // Returns iterator to new free suballocation at this place.
      4455  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
      4456  // Given free suballocation, it inserts it into sorted list of
      4457  // m_FreeSuballocationsBySize if it's suitable.
      4458  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
      4459  // Given free suballocation, it removes it from sorted list of
      4460  // m_FreeSuballocationsBySize if it's suitable.
      4461  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
      4462 };
      4463 
      4464 /*
      4465 Represents a single block of device memory (`VkDeviceMemory`) with all the
      4466 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
      4467 
      4468 Thread-safety: This class must be externally synchronized.
      4469 */
      4470 class VmaDeviceMemoryBlock
      4471 {
      4472  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
      4473 public:
      4474  VmaBlockMetadata m_Metadata;
      4475 
      4476  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
      4477 
      4478  ~VmaDeviceMemoryBlock()
      4479  {
      4480  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
      4481  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      4482  }
      4483 
      4484  // Always call after construction.
      4485  void Init(
      4486  uint32_t newMemoryTypeIndex,
      4487  VkDeviceMemory newMemory,
      4488  VkDeviceSize newSize,
      4489  uint32_t id);
      4490  // Always call before destruction.
      4491  void Destroy(VmaAllocator allocator);
      4492 
      4493  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
      4494  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      4495  uint32_t GetId() const { return m_Id; }
      4496  void* GetMappedData() const { return m_pMappedData; }
      4497 
      4498  // Validates all data structures inside this object. If not valid, returns false.
      4499  bool Validate() const;
      4500 
      4501  VkResult CheckCorruption(VmaAllocator hAllocator);
      4502 
      4503  // ppData can be null.
      4504  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
      4505  void Unmap(VmaAllocator hAllocator, uint32_t count);
      4506 
      4507  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      4508  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      4509 
      4510  VkResult BindBufferMemory(
      4511  const VmaAllocator hAllocator,
      4512  const VmaAllocation hAllocation,
      4513  VkBuffer hBuffer);
      4514  VkResult BindImageMemory(
      4515  const VmaAllocator hAllocator,
      4516  const VmaAllocation hAllocation,
      4517  VkImage hImage);
      4518 
      4519 private:
      4520  uint32_t m_MemoryTypeIndex;
      4521  uint32_t m_Id;
      4522  VkDeviceMemory m_hMemory;
      4523 
      4524  // Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
      4525  // Also protects m_MapCount, m_pMappedData.
      4526  VMA_MUTEX m_Mutex;
      4527  uint32_t m_MapCount;
      4528  void* m_pMappedData;
      4529 };
      4530 
      4531 struct VmaPointerLess
      4532 {
      4533  bool operator()(const void* lhs, const void* rhs) const
      4534  {
      4535  return lhs < rhs;
      4536  }
      4537 };
      4538 
      4539 class VmaDefragmentator;
      4540 
      4541 /*
      4542 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
      4543 Vulkan memory type.
      4544 
      4545 Synchronized internally with a mutex.
      4546 */
      4547 struct VmaBlockVector
      4548 {
      4549  VMA_CLASS_NO_COPY(VmaBlockVector)
      4550 public:
      4551  VmaBlockVector(
      4552  VmaAllocator hAllocator,
      4553  uint32_t memoryTypeIndex,
      4554  VkDeviceSize preferredBlockSize,
      4555  size_t minBlockCount,
      4556  size_t maxBlockCount,
      4557  VkDeviceSize bufferImageGranularity,
      4558  uint32_t frameInUseCount,
      4559  bool isCustomPool);
      4560  ~VmaBlockVector();
      4561 
      4562  VkResult CreateMinBlocks();
      4563 
      4564  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      4565  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
      4566  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
      4567  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
      4568 
      4569  void GetPoolStats(VmaPoolStats* pStats);
      4570 
      4571  bool IsEmpty() const { return m_Blocks.empty(); }
      4572  bool IsCorruptionDetectionEnabled() const;
      4573 
      4574  VkResult Allocate(
      4575  VmaPool hCurrentPool,
      4576  uint32_t currentFrameIndex,
      4577  VkDeviceSize size,
      4578  VkDeviceSize alignment,
      4579  const VmaAllocationCreateInfo& createInfo,
      4580  VmaSuballocationType suballocType,
      4581  VmaAllocation* pAllocation);
      4582 
      4583  void Free(
      4584  VmaAllocation hAllocation);
      4585 
      4586  // Adds statistics of this BlockVector to pStats.
      4587  void AddStats(VmaStats* pStats);
      4588 
      4589 #if VMA_STATS_STRING_ENABLED
      4590  void PrintDetailedMap(class VmaJsonWriter& json);
      4591 #endif
      4592 
      4593  void MakePoolAllocationsLost(
      4594  uint32_t currentFrameIndex,
      4595  size_t* pLostAllocationCount);
      4596  VkResult CheckCorruption();
      4597 
      4598  VmaDefragmentator* EnsureDefragmentator(
      4599  VmaAllocator hAllocator,
      4600  uint32_t currentFrameIndex);
      4601 
      4602  VkResult Defragment(
      4603  VmaDefragmentationStats* pDefragmentationStats,
      4604  VkDeviceSize& maxBytesToMove,
      4605  uint32_t& maxAllocationsToMove);
      4606 
      4607  void DestroyDefragmentator();
      4608 
      4609 private:
      4610  friend class VmaDefragmentator;
      4611 
      4612  const VmaAllocator m_hAllocator;
      4613  const uint32_t m_MemoryTypeIndex;
      4614  const VkDeviceSize m_PreferredBlockSize;
      4615  const size_t m_MinBlockCount;
      4616  const size_t m_MaxBlockCount;
      4617  const VkDeviceSize m_BufferImageGranularity;
      4618  const uint32_t m_FrameInUseCount;
      4619  const bool m_IsCustomPool;
      4620  VMA_MUTEX m_Mutex;
      4621  // Incrementally sorted by sumFreeSize, ascending.
      4622  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
      4623  /* There can be at most one allocation that is completely empty - a
      4624  hysteresis to avoid pessimistic case of alternating creation and destruction
      4625  of a VkDeviceMemory. */
      4626  bool m_HasEmptyBlock;
      4627  VmaDefragmentator* m_pDefragmentator;
      4628  uint32_t m_NextBlockId;
      4629 
      4630  VkDeviceSize CalcMaxBlockSize() const;
      4631 
      4632  // Finds and removes given block from vector.
      4633  void Remove(VmaDeviceMemoryBlock* pBlock);
      4634 
      4635  // Performs single step in sorting m_Blocks. They may not be fully sorted
      4636  // after this call.
      4637  void IncrementallySortBlocks();
      4638 
      4639  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
      4640 };
      4641 
      4642 struct VmaPool_T
      4643 {
      4644  VMA_CLASS_NO_COPY(VmaPool_T)
      4645 public:
      4646  VmaBlockVector m_BlockVector;
      4647 
      4648  VmaPool_T(
      4649  VmaAllocator hAllocator,
      4650  const VmaPoolCreateInfo& createInfo);
      4651  ~VmaPool_T();
      4652 
      4653  VmaBlockVector& GetBlockVector() { return m_BlockVector; }
      4654  uint32_t GetId() const { return m_Id; }
      4655  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
      4656 
      4657 #if VMA_STATS_STRING_ENABLED
      4658  //void PrintDetailedMap(class VmaStringBuilder& sb);
      4659 #endif
      4660 
      4661 private:
      4662  uint32_t m_Id;
      4663 };
      4664 
      4665 class VmaDefragmentator
      4666 {
      4667  VMA_CLASS_NO_COPY(VmaDefragmentator)
      4668 private:
      4669  const VmaAllocator m_hAllocator;
      4670  VmaBlockVector* const m_pBlockVector;
      4671  uint32_t m_CurrentFrameIndex;
      4672  VkDeviceSize m_BytesMoved;
      4673  uint32_t m_AllocationsMoved;
      4674 
      4675  struct AllocationInfo
      4676  {
      4677  VmaAllocation m_hAllocation;
      4678  VkBool32* m_pChanged;
      4679 
      4680  AllocationInfo() :
      4681  m_hAllocation(VK_NULL_HANDLE),
      4682  m_pChanged(VMA_NULL)
      4683  {
      4684  }
      4685  };
      4686 
      4687  struct AllocationInfoSizeGreater
      4688  {
      4689  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
      4690  {
      4691  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
      4692  }
      4693  };
      4694 
      4695  // Used between AddAllocation and Defragment.
      4696  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
      4697 
      4698  struct BlockInfo
      4699  {
      4700  VmaDeviceMemoryBlock* m_pBlock;
      4701  bool m_HasNonMovableAllocations;
      4702  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
      4703 
      4704  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
      4705  m_pBlock(VMA_NULL),
      4706  m_HasNonMovableAllocations(true),
      4707  m_Allocations(pAllocationCallbacks),
      4708  m_pMappedDataForDefragmentation(VMA_NULL)
      4709  {
      4710  }
      4711 
      4712  void CalcHasNonMovableAllocations()
      4713  {
      4714  const size_t blockAllocCount = m_pBlock->m_Metadata.GetAllocationCount();
      4715  const size_t defragmentAllocCount = m_Allocations.size();
      4716  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
      4717  }
      4718 
      4719  void SortAllocationsBySizeDescecnding()
      4720  {
      4721  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
      4722  }
      4723 
      4724  VkResult EnsureMapping(VmaAllocator hAllocator, void** ppMappedData);
      4725  void Unmap(VmaAllocator hAllocator);
      4726 
      4727  private:
      4728  // Not null if mapped for defragmentation only, not originally mapped.
      4729  void* m_pMappedDataForDefragmentation;
      4730  };
      4731 
      4732  struct BlockPointerLess
      4733  {
      4734  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
      4735  {
      4736  return pLhsBlockInfo->m_pBlock < pRhsBlock;
      4737  }
      4738  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      4739  {
      4740  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
      4741  }
      4742  };
      4743 
      4744  // 1. Blocks with some non-movable allocations go first.
      4745  // 2. Blocks with smaller sumFreeSize go first.
      4746  struct BlockInfoCompareMoveDestination
      4747  {
      4748  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      4749  {
      4750  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
      4751  {
      4752  return true;
      4753  }
      4754  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
      4755  {
      4756  return false;
      4757  }
      4758  if(pLhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_Metadata.GetSumFreeSize())
      4759  {
      4760  return true;
      4761  }
      4762  return false;
      4763  }
      4764  };
      4765 
      4766  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
      4767  BlockInfoVector m_Blocks;
      4768 
      4769  VkResult DefragmentRound(
      4770  VkDeviceSize maxBytesToMove,
      4771  uint32_t maxAllocationsToMove);
      4772 
      4773  static bool MoveMakesSense(
      4774  size_t dstBlockIndex, VkDeviceSize dstOffset,
      4775  size_t srcBlockIndex, VkDeviceSize srcOffset);
      4776 
      4777 public:
      4778  VmaDefragmentator(
      4779  VmaAllocator hAllocator,
      4780  VmaBlockVector* pBlockVector,
      4781  uint32_t currentFrameIndex);
      4782 
      4783  ~VmaDefragmentator();
      4784 
      4785  VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
      4786  uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
      4787 
      4788  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
      4789 
      4790  VkResult Defragment(
      4791  VkDeviceSize maxBytesToMove,
      4792  uint32_t maxAllocationsToMove);
      4793 };
      4794 
      4795 #if VMA_RECORDING_ENABLED
      4796 
      4797 class VmaRecorder
      4798 {
      4799 public:
      4800  VmaRecorder();
      4801  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
      4802  void WriteConfiguration(
      4803  const VkPhysicalDeviceProperties& devProps,
      4804  const VkPhysicalDeviceMemoryProperties& memProps,
      4805  bool dedicatedAllocationExtensionEnabled);
      4806  ~VmaRecorder();
      4807 
      4808  void RecordCreateAllocator(uint32_t frameIndex);
      4809  void RecordDestroyAllocator(uint32_t frameIndex);
      4810  void RecordCreatePool(uint32_t frameIndex,
      4811  const VmaPoolCreateInfo& createInfo,
      4812  VmaPool pool);
      4813  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
      4814  void RecordAllocateMemory(uint32_t frameIndex,
      4815  const VkMemoryRequirements& vkMemReq,
      4816  const VmaAllocationCreateInfo& createInfo,
      4817  VmaAllocation allocation);
      4818  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
      4819  const VkMemoryRequirements& vkMemReq,
      4820  bool requiresDedicatedAllocation,
      4821  bool prefersDedicatedAllocation,
      4822  const VmaAllocationCreateInfo& createInfo,
      4823  VmaAllocation allocation);
      4824  void RecordAllocateMemoryForImage(uint32_t frameIndex,
      4825  const VkMemoryRequirements& vkMemReq,
      4826  bool requiresDedicatedAllocation,
      4827  bool prefersDedicatedAllocation,
      4828  const VmaAllocationCreateInfo& createInfo,
      4829  VmaAllocation allocation);
      4830  void RecordFreeMemory(uint32_t frameIndex,
      4831  VmaAllocation allocation);
      4832  void RecordSetAllocationUserData(uint32_t frameIndex,
      4833  VmaAllocation allocation,
      4834  const void* pUserData);
      4835  void RecordCreateLostAllocation(uint32_t frameIndex,
      4836  VmaAllocation allocation);
      4837  void RecordMapMemory(uint32_t frameIndex,
      4838  VmaAllocation allocation);
      4839  void RecordUnmapMemory(uint32_t frameIndex,
      4840  VmaAllocation allocation);
      4841  void RecordFlushAllocation(uint32_t frameIndex,
      4842  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      4843  void RecordInvalidateAllocation(uint32_t frameIndex,
      4844  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      4845  void RecordCreateBuffer(uint32_t frameIndex,
      4846  const VkBufferCreateInfo& bufCreateInfo,
      4847  const VmaAllocationCreateInfo& allocCreateInfo,
      4848  VmaAllocation allocation);
      4849  void RecordCreateImage(uint32_t frameIndex,
      4850  const VkImageCreateInfo& imageCreateInfo,
      4851  const VmaAllocationCreateInfo& allocCreateInfo,
      4852  VmaAllocation allocation);
      4853  void RecordDestroyBuffer(uint32_t frameIndex,
      4854  VmaAllocation allocation);
      4855  void RecordDestroyImage(uint32_t frameIndex,
      4856  VmaAllocation allocation);
      4857  void RecordTouchAllocation(uint32_t frameIndex,
      4858  VmaAllocation allocation);
      4859  void RecordGetAllocationInfo(uint32_t frameIndex,
      4860  VmaAllocation allocation);
      4861  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
      4862  VmaPool pool);
      4863 
      4864 private:
      4865  struct CallParams
      4866  {
      4867  uint32_t threadId;
      4868  double time;
      4869  };
      4870 
      4871  class UserDataString
      4872  {
      4873  public:
      4874  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
      4875  const char* GetString() const { return m_Str; }
      4876 
      4877  private:
      4878  char m_PtrStr[17];
      4879  const char* m_Str;
      4880  };
      4881 
      4882  bool m_UseMutex;
      4883  VmaRecordFlags m_Flags;
      4884  FILE* m_File;
      4885  VMA_MUTEX m_FileMutex;
      4886  int64_t m_Freq;
      4887  int64_t m_StartCounter;
      4888 
      4889  void GetBasicParams(CallParams& outParams);
      4890  void Flush();
      4891 };
      4892 
      4893 #endif // #if VMA_RECORDING_ENABLED
      4894 
      4895 // Main allocator object.
      4896 struct VmaAllocator_T
      4897 {
      4898  VMA_CLASS_NO_COPY(VmaAllocator_T)
      4899 public:
      4900  bool m_UseMutex;
      4901  bool m_UseKhrDedicatedAllocation;
      4902  VkDevice m_hDevice;
      4903  bool m_AllocationCallbacksSpecified;
      4904  VkAllocationCallbacks m_AllocationCallbacks;
      4905  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
      4906 
      4907  // Number of bytes free out of limit, or VK_WHOLE_SIZE if not limit for that heap.
      4908  VkDeviceSize m_HeapSizeLimit[VK_MAX_MEMORY_HEAPS];
      4909  VMA_MUTEX m_HeapSizeLimitMutex;
      4910 
      4911  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
      4912  VkPhysicalDeviceMemoryProperties m_MemProps;
      4913 
      4914  // Default pools.
      4915  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
      4916 
      4917  // Each vector is sorted by memory (handle value).
      4918  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
      4919  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
      4920  VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
      4921 
      4922  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
      4923  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
      4924  ~VmaAllocator_T();
      4925 
      4926  const VkAllocationCallbacks* GetAllocationCallbacks() const
      4927  {
      4928  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
      4929  }
      4930  const VmaVulkanFunctions& GetVulkanFunctions() const
      4931  {
      4932  return m_VulkanFunctions;
      4933  }
      4934 
      4935  VkDeviceSize GetBufferImageGranularity() const
      4936  {
      4937  return VMA_MAX(
      4938  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
      4939  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
      4940  }
      4941 
      4942  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
      4943  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
      4944 
      4945  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
      4946  {
      4947  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
      4948  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
      4949  }
      4950  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
      4951  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
      4952  {
      4953  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
      4954  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      4955  }
      4956  // Minimum alignment for all allocations in specific memory type.
      4957  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
      4958  {
      4959  return IsMemoryTypeNonCoherent(memTypeIndex) ?
      4960  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
      4961  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
      4962  }
      4963 
      4964  bool IsIntegratedGpu() const
      4965  {
      4966  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
      4967  }
      4968 
      4969 #if VMA_RECORDING_ENABLED
      4970  VmaRecorder* GetRecorder() const { return m_pRecorder; }
      4971 #endif
      4972 
      4973  void GetBufferMemoryRequirements(
      4974  VkBuffer hBuffer,
      4975  VkMemoryRequirements& memReq,
      4976  bool& requiresDedicatedAllocation,
      4977  bool& prefersDedicatedAllocation) const;
      4978  void GetImageMemoryRequirements(
      4979  VkImage hImage,
      4980  VkMemoryRequirements& memReq,
      4981  bool& requiresDedicatedAllocation,
      4982  bool& prefersDedicatedAllocation) const;
      4983 
      4984  // Main allocation function.
      4985  VkResult AllocateMemory(
      4986  const VkMemoryRequirements& vkMemReq,
      4987  bool requiresDedicatedAllocation,
      4988  bool prefersDedicatedAllocation,
      4989  VkBuffer dedicatedBuffer,
      4990  VkImage dedicatedImage,
      4991  const VmaAllocationCreateInfo& createInfo,
      4992  VmaSuballocationType suballocType,
      4993  VmaAllocation* pAllocation);
      4994 
      4995  // Main deallocation function.
      4996  void FreeMemory(const VmaAllocation allocation);
      4997 
      4998  void CalculateStats(VmaStats* pStats);
      4999 
      5000 #if VMA_STATS_STRING_ENABLED
      5001  void PrintDetailedMap(class VmaJsonWriter& json);
      5002 #endif
      5003 
      5004  VkResult Defragment(
      5005  VmaAllocation* pAllocations,
      5006  size_t allocationCount,
      5007  VkBool32* pAllocationsChanged,
      5008  const VmaDefragmentationInfo* pDefragmentationInfo,
      5009  VmaDefragmentationStats* pDefragmentationStats);
      5010 
      5011  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
      5012  bool TouchAllocation(VmaAllocation hAllocation);
      5013 
      5014  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
      5015  void DestroyPool(VmaPool pool);
      5016  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
      5017 
      5018  void SetCurrentFrameIndex(uint32_t frameIndex);
      5019  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
      5020 
      5021  void MakePoolAllocationsLost(
      5022  VmaPool hPool,
      5023  size_t* pLostAllocationCount);
      5024  VkResult CheckPoolCorruption(VmaPool hPool);
      5025  VkResult CheckCorruption(uint32_t memoryTypeBits);
      5026 
      5027  void CreateLostAllocation(VmaAllocation* pAllocation);
      5028 
      5029  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
      5030  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
      5031 
      5032  VkResult Map(VmaAllocation hAllocation, void** ppData);
      5033  void Unmap(VmaAllocation hAllocation);
      5034 
      5035  VkResult BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer);
      5036  VkResult BindImageMemory(VmaAllocation hAllocation, VkImage hImage);
      5037 
      5038  void FlushOrInvalidateAllocation(
      5039  VmaAllocation hAllocation,
      5040  VkDeviceSize offset, VkDeviceSize size,
      5041  VMA_CACHE_OPERATION op);
      5042 
      5043  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
      5044 
      5045 private:
      5046  VkDeviceSize m_PreferredLargeHeapBlockSize;
      5047 
      5048  VkPhysicalDevice m_PhysicalDevice;
      5049  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
      5050 
      5051  VMA_MUTEX m_PoolsMutex;
      5052  // Protected by m_PoolsMutex. Sorted by pointer value.
      5053  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
      5054  uint32_t m_NextPoolId;
      5055 
      5056  VmaVulkanFunctions m_VulkanFunctions;
      5057 
      5058 #if VMA_RECORDING_ENABLED
      5059  VmaRecorder* m_pRecorder;
      5060 #endif
      5061 
      5062  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
      5063 
      5064  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
      5065 
      5066  VkResult AllocateMemoryOfType(
      5067  VkDeviceSize size,
      5068  VkDeviceSize alignment,
      5069  bool dedicatedAllocation,
      5070  VkBuffer dedicatedBuffer,
      5071  VkImage dedicatedImage,
      5072  const VmaAllocationCreateInfo& createInfo,
      5073  uint32_t memTypeIndex,
      5074  VmaSuballocationType suballocType,
      5075  VmaAllocation* pAllocation);
      5076 
      5077  // Allocates and registers new VkDeviceMemory specifically for single allocation.
      5078  VkResult AllocateDedicatedMemory(
      5079  VkDeviceSize size,
      5080  VmaSuballocationType suballocType,
      5081  uint32_t memTypeIndex,
      5082  bool map,
      5083  bool isUserDataString,
      5084  void* pUserData,
      5085  VkBuffer dedicatedBuffer,
      5086  VkImage dedicatedImage,
      5087  VmaAllocation* pAllocation);
      5088 
      5089  // Tries to free pMemory as Dedicated Memory. Returns true if found and freed.
      5090  void FreeDedicatedMemory(VmaAllocation allocation);
      5091 };
      5092 
      5094 // Memory allocation #2 after VmaAllocator_T definition
      5095 
      5096 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
      5097 {
      5098  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
      5099 }
      5100 
      5101 static void VmaFree(VmaAllocator hAllocator, void* ptr)
      5102 {
      5103  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
      5104 }
      5105 
      5106 template<typename T>
      5107 static T* VmaAllocate(VmaAllocator hAllocator)
      5108 {
      5109  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
      5110 }
      5111 
      5112 template<typename T>
      5113 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
      5114 {
      5115  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
      5116 }
      5117 
      5118 template<typename T>
      5119 static void vma_delete(VmaAllocator hAllocator, T* ptr)
      5120 {
      5121  if(ptr != VMA_NULL)
      5122  {
      5123  ptr->~T();
      5124  VmaFree(hAllocator, ptr);
      5125  }
      5126 }
      5127 
      5128 template<typename T>
      5129 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
      5130 {
      5131  if(ptr != VMA_NULL)
      5132  {
      5133  for(size_t i = count; i--; )
      5134  ptr[i].~T();
      5135  VmaFree(hAllocator, ptr);
      5136  }
      5137 }
      5138 
      5140 // VmaStringBuilder
      5141 
      5142 #if VMA_STATS_STRING_ENABLED
      5143 
      5144 class VmaStringBuilder
      5145 {
      5146 public:
      5147  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
      5148  size_t GetLength() const { return m_Data.size(); }
      5149  const char* GetData() const { return m_Data.data(); }
      5150 
      5151  void Add(char ch) { m_Data.push_back(ch); }
      5152  void Add(const char* pStr);
      5153  void AddNewLine() { Add('\n'); }
      5154  void AddNumber(uint32_t num);
      5155  void AddNumber(uint64_t num);
      5156  void AddPointer(const void* ptr);
      5157 
      5158 private:
      5159  VmaVector< char, VmaStlAllocator<char> > m_Data;
      5160 };
      5161 
      5162 void VmaStringBuilder::Add(const char* pStr)
      5163 {
      5164  const size_t strLen = strlen(pStr);
      5165  if(strLen > 0)
      5166  {
      5167  const size_t oldCount = m_Data.size();
      5168  m_Data.resize(oldCount + strLen);
      5169  memcpy(m_Data.data() + oldCount, pStr, strLen);
      5170  }
      5171 }
      5172 
      5173 void VmaStringBuilder::AddNumber(uint32_t num)
      5174 {
      5175  char buf[11];
      5176  VmaUint32ToStr(buf, sizeof(buf), num);
      5177  Add(buf);
      5178 }
      5179 
      5180 void VmaStringBuilder::AddNumber(uint64_t num)
      5181 {
      5182  char buf[21];
      5183  VmaUint64ToStr(buf, sizeof(buf), num);
      5184  Add(buf);
      5185 }
      5186 
      5187 void VmaStringBuilder::AddPointer(const void* ptr)
      5188 {
      5189  char buf[21];
      5190  VmaPtrToStr(buf, sizeof(buf), ptr);
      5191  Add(buf);
      5192 }
      5193 
      5194 #endif // #if VMA_STATS_STRING_ENABLED
      5195 
      5197 // VmaJsonWriter
      5198 
      5199 #if VMA_STATS_STRING_ENABLED
      5200 
      5201 class VmaJsonWriter
      5202 {
      5203  VMA_CLASS_NO_COPY(VmaJsonWriter)
      5204 public:
      5205  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
      5206  ~VmaJsonWriter();
      5207 
      5208  void BeginObject(bool singleLine = false);
      5209  void EndObject();
      5210 
      5211  void BeginArray(bool singleLine = false);
      5212  void EndArray();
      5213 
      5214  void WriteString(const char* pStr);
      5215  void BeginString(const char* pStr = VMA_NULL);
      5216  void ContinueString(const char* pStr);
      5217  void ContinueString(uint32_t n);
      5218  void ContinueString(uint64_t n);
      5219  void ContinueString_Pointer(const void* ptr);
      5220  void EndString(const char* pStr = VMA_NULL);
      5221 
      5222  void WriteNumber(uint32_t n);
      5223  void WriteNumber(uint64_t n);
      5224  void WriteBool(bool b);
      5225  void WriteNull();
      5226 
      5227 private:
      5228  static const char* const INDENT;
      5229 
      5230  enum COLLECTION_TYPE
      5231  {
      5232  COLLECTION_TYPE_OBJECT,
      5233  COLLECTION_TYPE_ARRAY,
      5234  };
      5235  struct StackItem
      5236  {
      5237  COLLECTION_TYPE type;
      5238  uint32_t valueCount;
      5239  bool singleLineMode;
      5240  };
      5241 
      5242  VmaStringBuilder& m_SB;
      5243  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
      5244  bool m_InsideString;
      5245 
      5246  void BeginValue(bool isString);
      5247  void WriteIndent(bool oneLess = false);
      5248 };
      5249 
      5250 const char* const VmaJsonWriter::INDENT = " ";
      5251 
      5252 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
      5253  m_SB(sb),
      5254  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
      5255  m_InsideString(false)
      5256 {
      5257 }
      5258 
      5259 VmaJsonWriter::~VmaJsonWriter()
      5260 {
      5261  VMA_ASSERT(!m_InsideString);
      5262  VMA_ASSERT(m_Stack.empty());
      5263 }
      5264 
      5265 void VmaJsonWriter::BeginObject(bool singleLine)
      5266 {
      5267  VMA_ASSERT(!m_InsideString);
      5268 
      5269  BeginValue(false);
      5270  m_SB.Add('{');
      5271 
      5272  StackItem item;
      5273  item.type = COLLECTION_TYPE_OBJECT;
      5274  item.valueCount = 0;
      5275  item.singleLineMode = singleLine;
      5276  m_Stack.push_back(item);
      5277 }
      5278 
      5279 void VmaJsonWriter::EndObject()
      5280 {
      5281  VMA_ASSERT(!m_InsideString);
      5282 
      5283  WriteIndent(true);
      5284  m_SB.Add('}');
      5285 
      5286  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
      5287  m_Stack.pop_back();
      5288 }
      5289 
      5290 void VmaJsonWriter::BeginArray(bool singleLine)
      5291 {
      5292  VMA_ASSERT(!m_InsideString);
      5293 
      5294  BeginValue(false);
      5295  m_SB.Add('[');
      5296 
      5297  StackItem item;
      5298  item.type = COLLECTION_TYPE_ARRAY;
      5299  item.valueCount = 0;
      5300  item.singleLineMode = singleLine;
      5301  m_Stack.push_back(item);
      5302 }
      5303 
      5304 void VmaJsonWriter::EndArray()
      5305 {
      5306  VMA_ASSERT(!m_InsideString);
      5307 
      5308  WriteIndent(true);
      5309  m_SB.Add(']');
      5310 
      5311  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
      5312  m_Stack.pop_back();
      5313 }
      5314 
      5315 void VmaJsonWriter::WriteString(const char* pStr)
      5316 {
      5317  BeginString(pStr);
      5318  EndString();
      5319 }
      5320 
      5321 void VmaJsonWriter::BeginString(const char* pStr)
      5322 {
      5323  VMA_ASSERT(!m_InsideString);
      5324 
      5325  BeginValue(true);
      5326  m_SB.Add('"');
      5327  m_InsideString = true;
      5328  if(pStr != VMA_NULL && pStr[0] != '\0')
      5329  {
      5330  ContinueString(pStr);
      5331  }
      5332 }
      5333 
      5334 void VmaJsonWriter::ContinueString(const char* pStr)
      5335 {
      5336  VMA_ASSERT(m_InsideString);
      5337 
      5338  const size_t strLen = strlen(pStr);
      5339  for(size_t i = 0; i < strLen; ++i)
      5340  {
      5341  char ch = pStr[i];
      5342  if(ch == '\\')
      5343  {
      5344  m_SB.Add("\\\\");
      5345  }
      5346  else if(ch == '"')
      5347  {
      5348  m_SB.Add("\\\"");
      5349  }
      5350  else if(ch >= 32)
      5351  {
      5352  m_SB.Add(ch);
      5353  }
      5354  else switch(ch)
      5355  {
      5356  case '\b':
      5357  m_SB.Add("\\b");
      5358  break;
      5359  case '\f':
      5360  m_SB.Add("\\f");
      5361  break;
      5362  case '\n':
      5363  m_SB.Add("\\n");
      5364  break;
      5365  case '\r':
      5366  m_SB.Add("\\r");
      5367  break;
      5368  case '\t':
      5369  m_SB.Add("\\t");
      5370  break;
      5371  default:
      5372  VMA_ASSERT(0 && "Character not currently supported.");
      5373  break;
      5374  }
      5375  }
      5376 }
      5377 
      5378 void VmaJsonWriter::ContinueString(uint32_t n)
      5379 {
      5380  VMA_ASSERT(m_InsideString);
      5381  m_SB.AddNumber(n);
      5382 }
      5383 
      5384 void VmaJsonWriter::ContinueString(uint64_t n)
      5385 {
      5386  VMA_ASSERT(m_InsideString);
      5387  m_SB.AddNumber(n);
      5388 }
      5389 
      5390 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
      5391 {
      5392  VMA_ASSERT(m_InsideString);
      5393  m_SB.AddPointer(ptr);
      5394 }
      5395 
      5396 void VmaJsonWriter::EndString(const char* pStr)
      5397 {
      5398  VMA_ASSERT(m_InsideString);
      5399  if(pStr != VMA_NULL && pStr[0] != '\0')
      5400  {
      5401  ContinueString(pStr);
      5402  }
      5403  m_SB.Add('"');
      5404  m_InsideString = false;
      5405 }
      5406 
      5407 void VmaJsonWriter::WriteNumber(uint32_t n)
      5408 {
      5409  VMA_ASSERT(!m_InsideString);
      5410  BeginValue(false);
      5411  m_SB.AddNumber(n);
      5412 }
      5413 
      5414 void VmaJsonWriter::WriteNumber(uint64_t n)
      5415 {
      5416  VMA_ASSERT(!m_InsideString);
      5417  BeginValue(false);
      5418  m_SB.AddNumber(n);
      5419 }
      5420 
      5421 void VmaJsonWriter::WriteBool(bool b)
      5422 {
      5423  VMA_ASSERT(!m_InsideString);
      5424  BeginValue(false);
      5425  m_SB.Add(b ? "true" : "false");
      5426 }
      5427 
      5428 void VmaJsonWriter::WriteNull()
      5429 {
      5430  VMA_ASSERT(!m_InsideString);
      5431  BeginValue(false);
      5432  m_SB.Add("null");
      5433 }
      5434 
      5435 void VmaJsonWriter::BeginValue(bool isString)
      5436 {
      5437  if(!m_Stack.empty())
      5438  {
      5439  StackItem& currItem = m_Stack.back();
      5440  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      5441  currItem.valueCount % 2 == 0)
      5442  {
      5443  VMA_ASSERT(isString);
      5444  }
      5445 
      5446  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      5447  currItem.valueCount % 2 != 0)
      5448  {
      5449  m_SB.Add(": ");
      5450  }
      5451  else if(currItem.valueCount > 0)
      5452  {
      5453  m_SB.Add(", ");
      5454  WriteIndent();
      5455  }
      5456  else
      5457  {
      5458  WriteIndent();
      5459  }
      5460  ++currItem.valueCount;
      5461  }
      5462 }
      5463 
      5464 void VmaJsonWriter::WriteIndent(bool oneLess)
      5465 {
      5466  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
      5467  {
      5468  m_SB.AddNewLine();
      5469 
      5470  size_t count = m_Stack.size();
      5471  if(count > 0 && oneLess)
      5472  {
      5473  --count;
      5474  }
      5475  for(size_t i = 0; i < count; ++i)
      5476  {
      5477  m_SB.Add(INDENT);
      5478  }
      5479  }
      5480 }
      5481 
      5482 #endif // #if VMA_STATS_STRING_ENABLED
      5483 
      5485 
      5486 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
      5487 {
      5488  if(IsUserDataString())
      5489  {
      5490  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
      5491 
      5492  FreeUserDataString(hAllocator);
      5493 
      5494  if(pUserData != VMA_NULL)
      5495  {
      5496  const char* const newStrSrc = (char*)pUserData;
      5497  const size_t newStrLen = strlen(newStrSrc);
      5498  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
      5499  memcpy(newStrDst, newStrSrc, newStrLen + 1);
      5500  m_pUserData = newStrDst;
      5501  }
      5502  }
      5503  else
      5504  {
      5505  m_pUserData = pUserData;
      5506  }
      5507 }
      5508 
      5509 void VmaAllocation_T::ChangeBlockAllocation(
      5510  VmaAllocator hAllocator,
      5511  VmaDeviceMemoryBlock* block,
      5512  VkDeviceSize offset)
      5513 {
      5514  VMA_ASSERT(block != VMA_NULL);
      5515  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      5516 
      5517  // Move mapping reference counter from old block to new block.
      5518  if(block != m_BlockAllocation.m_Block)
      5519  {
      5520  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
      5521  if(IsPersistentMap())
      5522  ++mapRefCount;
      5523  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
      5524  block->Map(hAllocator, mapRefCount, VMA_NULL);
      5525  }
      5526 
      5527  m_BlockAllocation.m_Block = block;
      5528  m_BlockAllocation.m_Offset = offset;
      5529 }
      5530 
      5531 VkDeviceSize VmaAllocation_T::GetOffset() const
      5532 {
      5533  switch(m_Type)
      5534  {
      5535  case ALLOCATION_TYPE_BLOCK:
      5536  return m_BlockAllocation.m_Offset;
      5537  case ALLOCATION_TYPE_DEDICATED:
      5538  return 0;
      5539  default:
      5540  VMA_ASSERT(0);
      5541  return 0;
      5542  }
      5543 }
      5544 
      5545 VkDeviceMemory VmaAllocation_T::GetMemory() const
      5546 {
      5547  switch(m_Type)
      5548  {
      5549  case ALLOCATION_TYPE_BLOCK:
      5550  return m_BlockAllocation.m_Block->GetDeviceMemory();
      5551  case ALLOCATION_TYPE_DEDICATED:
      5552  return m_DedicatedAllocation.m_hMemory;
      5553  default:
      5554  VMA_ASSERT(0);
      5555  return VK_NULL_HANDLE;
      5556  }
      5557 }
      5558 
      5559 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
      5560 {
      5561  switch(m_Type)
      5562  {
      5563  case ALLOCATION_TYPE_BLOCK:
      5564  return m_BlockAllocation.m_Block->GetMemoryTypeIndex();
      5565  case ALLOCATION_TYPE_DEDICATED:
      5566  return m_DedicatedAllocation.m_MemoryTypeIndex;
      5567  default:
      5568  VMA_ASSERT(0);
      5569  return UINT32_MAX;
      5570  }
      5571 }
      5572 
      5573 void* VmaAllocation_T::GetMappedData() const
      5574 {
      5575  switch(m_Type)
      5576  {
      5577  case ALLOCATION_TYPE_BLOCK:
      5578  if(m_MapCount != 0)
      5579  {
      5580  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
      5581  VMA_ASSERT(pBlockData != VMA_NULL);
      5582  return (char*)pBlockData + m_BlockAllocation.m_Offset;
      5583  }
      5584  else
      5585  {
      5586  return VMA_NULL;
      5587  }
      5588  break;
      5589  case ALLOCATION_TYPE_DEDICATED:
      5590  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
      5591  return m_DedicatedAllocation.m_pMappedData;
      5592  default:
      5593  VMA_ASSERT(0);
      5594  return VMA_NULL;
      5595  }
      5596 }
      5597 
      5598 bool VmaAllocation_T::CanBecomeLost() const
      5599 {
      5600  switch(m_Type)
      5601  {
      5602  case ALLOCATION_TYPE_BLOCK:
      5603  return m_BlockAllocation.m_CanBecomeLost;
      5604  case ALLOCATION_TYPE_DEDICATED:
      5605  return false;
      5606  default:
      5607  VMA_ASSERT(0);
      5608  return false;
      5609  }
      5610 }
      5611 
      5612 VmaPool VmaAllocation_T::GetPool() const
      5613 {
      5614  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      5615  return m_BlockAllocation.m_hPool;
      5616 }
      5617 
      5618 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      5619 {
      5620  VMA_ASSERT(CanBecomeLost());
      5621 
      5622  /*
      5623  Warning: This is a carefully designed algorithm.
      5624  Do not modify unless you really know what you're doing :)
      5625  */
      5626  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
      5627  for(;;)
      5628  {
      5629  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      5630  {
      5631  VMA_ASSERT(0);
      5632  return false;
      5633  }
      5634  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
      5635  {
      5636  return false;
      5637  }
      5638  else // Last use time earlier than current time.
      5639  {
      5640  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
      5641  {
      5642  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
      5643  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
      5644  return true;
      5645  }
      5646  }
      5647  }
      5648 }
      5649 
      5650 #if VMA_STATS_STRING_ENABLED
      5651 
      5652 // Correspond to values of enum VmaSuballocationType.
      5653 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
      5654  "FREE",
      5655  "UNKNOWN",
      5656  "BUFFER",
      5657  "IMAGE_UNKNOWN",
      5658  "IMAGE_LINEAR",
      5659  "IMAGE_OPTIMAL",
      5660 };
      5661 
      5662 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
      5663 {
      5664  json.WriteString("Type");
      5665  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
      5666 
      5667  json.WriteString("Size");
      5668  json.WriteNumber(m_Size);
      5669 
      5670  if(m_pUserData != VMA_NULL)
      5671  {
      5672  json.WriteString("UserData");
      5673  if(IsUserDataString())
      5674  {
      5675  json.WriteString((const char*)m_pUserData);
      5676  }
      5677  else
      5678  {
      5679  json.BeginString();
      5680  json.ContinueString_Pointer(m_pUserData);
      5681  json.EndString();
      5682  }
      5683  }
      5684 
      5685  json.WriteString("CreationFrameIndex");
      5686  json.WriteNumber(m_CreationFrameIndex);
      5687 
      5688  json.WriteString("LastUseFrameIndex");
      5689  json.WriteNumber(GetLastUseFrameIndex());
      5690 
      5691  if(m_BufferImageUsage != 0)
      5692  {
      5693  json.WriteString("Usage");
      5694  json.WriteNumber(m_BufferImageUsage);
      5695  }
      5696 }
      5697 
      5698 #endif
      5699 
      5700 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
      5701 {
      5702  VMA_ASSERT(IsUserDataString());
      5703  if(m_pUserData != VMA_NULL)
      5704  {
      5705  char* const oldStr = (char*)m_pUserData;
      5706  const size_t oldStrLen = strlen(oldStr);
      5707  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
      5708  m_pUserData = VMA_NULL;
      5709  }
      5710 }
      5711 
      5712 void VmaAllocation_T::BlockAllocMap()
      5713 {
      5714  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      5715 
      5716  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      5717  {
      5718  ++m_MapCount;
      5719  }
      5720  else
      5721  {
      5722  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
      5723  }
      5724 }
      5725 
      5726 void VmaAllocation_T::BlockAllocUnmap()
      5727 {
      5728  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      5729 
      5730  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      5731  {
      5732  --m_MapCount;
      5733  }
      5734  else
      5735  {
      5736  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
      5737  }
      5738 }
      5739 
      5740 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
      5741 {
      5742  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      5743 
      5744  if(m_MapCount != 0)
      5745  {
      5746  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      5747  {
      5748  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
      5749  *ppData = m_DedicatedAllocation.m_pMappedData;
      5750  ++m_MapCount;
      5751  return VK_SUCCESS;
      5752  }
      5753  else
      5754  {
      5755  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
      5756  return VK_ERROR_MEMORY_MAP_FAILED;
      5757  }
      5758  }
      5759  else
      5760  {
      5761  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      5762  hAllocator->m_hDevice,
      5763  m_DedicatedAllocation.m_hMemory,
      5764  0, // offset
      5765  VK_WHOLE_SIZE,
      5766  0, // flags
      5767  ppData);
      5768  if(result == VK_SUCCESS)
      5769  {
      5770  m_DedicatedAllocation.m_pMappedData = *ppData;
      5771  m_MapCount = 1;
      5772  }
      5773  return result;
      5774  }
      5775 }
      5776 
      5777 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
      5778 {
      5779  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      5780 
      5781  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      5782  {
      5783  --m_MapCount;
      5784  if(m_MapCount == 0)
      5785  {
      5786  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
      5787  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
      5788  hAllocator->m_hDevice,
      5789  m_DedicatedAllocation.m_hMemory);
      5790  }
      5791  }
      5792  else
      5793  {
      5794  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
      5795  }
      5796 }
      5797 
      5798 #if VMA_STATS_STRING_ENABLED
      5799 
      5800 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
      5801 {
      5802  json.BeginObject();
      5803 
      5804  json.WriteString("Blocks");
      5805  json.WriteNumber(stat.blockCount);
      5806 
      5807  json.WriteString("Allocations");
      5808  json.WriteNumber(stat.allocationCount);
      5809 
      5810  json.WriteString("UnusedRanges");
      5811  json.WriteNumber(stat.unusedRangeCount);
      5812 
      5813  json.WriteString("UsedBytes");
      5814  json.WriteNumber(stat.usedBytes);
      5815 
      5816  json.WriteString("UnusedBytes");
      5817  json.WriteNumber(stat.unusedBytes);
      5818 
      5819  if(stat.allocationCount > 1)
      5820  {
      5821  json.WriteString("AllocationSize");
      5822  json.BeginObject(true);
      5823  json.WriteString("Min");
      5824  json.WriteNumber(stat.allocationSizeMin);
      5825  json.WriteString("Avg");
      5826  json.WriteNumber(stat.allocationSizeAvg);
      5827  json.WriteString("Max");
      5828  json.WriteNumber(stat.allocationSizeMax);
      5829  json.EndObject();
      5830  }
      5831 
      5832  if(stat.unusedRangeCount > 1)
      5833  {
      5834  json.WriteString("UnusedRangeSize");
      5835  json.BeginObject(true);
      5836  json.WriteString("Min");
      5837  json.WriteNumber(stat.unusedRangeSizeMin);
      5838  json.WriteString("Avg");
      5839  json.WriteNumber(stat.unusedRangeSizeAvg);
      5840  json.WriteString("Max");
      5841  json.WriteNumber(stat.unusedRangeSizeMax);
      5842  json.EndObject();
      5843  }
      5844 
      5845  json.EndObject();
      5846 }
      5847 
      5848 #endif // #if VMA_STATS_STRING_ENABLED
      5849 
      5850 struct VmaSuballocationItemSizeLess
      5851 {
      5852  bool operator()(
      5853  const VmaSuballocationList::iterator lhs,
      5854  const VmaSuballocationList::iterator rhs) const
      5855  {
      5856  return lhs->size < rhs->size;
      5857  }
      5858  bool operator()(
      5859  const VmaSuballocationList::iterator lhs,
      5860  VkDeviceSize rhsSize) const
      5861  {
      5862  return lhs->size < rhsSize;
      5863  }
      5864 };
      5865 
      5867 // class VmaBlockMetadata
      5868 
      5869 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
      5870  m_Size(0),
      5871  m_FreeCount(0),
      5872  m_SumFreeSize(0),
      5873  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      5874  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
      5875 {
      5876 }
      5877 
      5878 VmaBlockMetadata::~VmaBlockMetadata()
      5879 {
      5880 }
      5881 
      5882 void VmaBlockMetadata::Init(VkDeviceSize size)
      5883 {
      5884  m_Size = size;
      5885  m_FreeCount = 1;
      5886  m_SumFreeSize = size;
      5887 
      5888  VmaSuballocation suballoc = {};
      5889  suballoc.offset = 0;
      5890  suballoc.size = size;
      5891  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      5892  suballoc.hAllocation = VK_NULL_HANDLE;
      5893 
      5894  m_Suballocations.push_back(suballoc);
      5895  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
      5896  --suballocItem;
      5897  m_FreeSuballocationsBySize.push_back(suballocItem);
      5898 }
      5899 
      5900 bool VmaBlockMetadata::Validate() const
      5901 {
      5902  if(m_Suballocations.empty())
      5903  {
      5904  return false;
      5905  }
      5906 
      5907  // Expected offset of new suballocation as calculates from previous ones.
      5908  VkDeviceSize calculatedOffset = 0;
      5909  // Expected number of free suballocations as calculated from traversing their list.
      5910  uint32_t calculatedFreeCount = 0;
      5911  // Expected sum size of free suballocations as calculated from traversing their list.
      5912  VkDeviceSize calculatedSumFreeSize = 0;
      5913  // Expected number of free suballocations that should be registered in
      5914  // m_FreeSuballocationsBySize calculated from traversing their list.
      5915  size_t freeSuballocationsToRegister = 0;
      5916  // True if previous visited suballocation was free.
      5917  bool prevFree = false;
      5918 
      5919  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      5920  suballocItem != m_Suballocations.cend();
      5921  ++suballocItem)
      5922  {
      5923  const VmaSuballocation& subAlloc = *suballocItem;
      5924 
      5925  // Actual offset of this suballocation doesn't match expected one.
      5926  if(subAlloc.offset != calculatedOffset)
      5927  {
      5928  return false;
      5929  }
      5930 
      5931  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
      5932  // Two adjacent free suballocations are invalid. They should be merged.
      5933  if(prevFree && currFree)
      5934  {
      5935  return false;
      5936  }
      5937 
      5938  if(currFree != (subAlloc.hAllocation == VK_NULL_HANDLE))
      5939  {
      5940  return false;
      5941  }
      5942 
      5943  if(currFree)
      5944  {
      5945  calculatedSumFreeSize += subAlloc.size;
      5946  ++calculatedFreeCount;
      5947  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      5948  {
      5949  ++freeSuballocationsToRegister;
      5950  }
      5951 
      5952  // Margin required between allocations - every free space must be at least that large.
      5953  if(subAlloc.size < VMA_DEBUG_MARGIN)
      5954  {
      5955  return false;
      5956  }
      5957  }
      5958  else
      5959  {
      5960  if(subAlloc.hAllocation->GetOffset() != subAlloc.offset)
      5961  {
      5962  return false;
      5963  }
      5964  if(subAlloc.hAllocation->GetSize() != subAlloc.size)
      5965  {
      5966  return false;
      5967  }
      5968 
      5969  // Margin required between allocations - previous allocation must be free.
      5970  if(VMA_DEBUG_MARGIN > 0 && !prevFree)
      5971  {
      5972  return false;
      5973  }
      5974  }
      5975 
      5976  calculatedOffset += subAlloc.size;
      5977  prevFree = currFree;
      5978  }
      5979 
      5980  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
      5981  // match expected one.
      5982  if(m_FreeSuballocationsBySize.size() != freeSuballocationsToRegister)
      5983  {
      5984  return false;
      5985  }
      5986 
      5987  VkDeviceSize lastSize = 0;
      5988  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
      5989  {
      5990  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
      5991 
      5992  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
      5993  if(suballocItem->type != VMA_SUBALLOCATION_TYPE_FREE)
      5994  {
      5995  return false;
      5996  }
      5997  // They must be sorted by size ascending.
      5998  if(suballocItem->size < lastSize)
      5999  {
      6000  return false;
      6001  }
      6002 
      6003  lastSize = suballocItem->size;
      6004  }
      6005 
      6006  // Check if totals match calculacted values.
      6007  if(!ValidateFreeSuballocationList() ||
      6008  (calculatedOffset != m_Size) ||
      6009  (calculatedSumFreeSize != m_SumFreeSize) ||
      6010  (calculatedFreeCount != m_FreeCount))
      6011  {
      6012  return false;
      6013  }
      6014 
      6015  return true;
      6016 }
      6017 
      6018 VkDeviceSize VmaBlockMetadata::GetUnusedRangeSizeMax() const
      6019 {
      6020  if(!m_FreeSuballocationsBySize.empty())
      6021  {
      6022  return m_FreeSuballocationsBySize.back()->size;
      6023  }
      6024  else
      6025  {
      6026  return 0;
      6027  }
      6028 }
      6029 
      6030 bool VmaBlockMetadata::IsEmpty() const
      6031 {
      6032  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
      6033 }
      6034 
      6035 void VmaBlockMetadata::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      6036 {
      6037  outInfo.blockCount = 1;
      6038 
      6039  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      6040  outInfo.allocationCount = rangeCount - m_FreeCount;
      6041  outInfo.unusedRangeCount = m_FreeCount;
      6042 
      6043  outInfo.unusedBytes = m_SumFreeSize;
      6044  outInfo.usedBytes = m_Size - outInfo.unusedBytes;
      6045 
      6046  outInfo.allocationSizeMin = UINT64_MAX;
      6047  outInfo.allocationSizeMax = 0;
      6048  outInfo.unusedRangeSizeMin = UINT64_MAX;
      6049  outInfo.unusedRangeSizeMax = 0;
      6050 
      6051  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      6052  suballocItem != m_Suballocations.cend();
      6053  ++suballocItem)
      6054  {
      6055  const VmaSuballocation& suballoc = *suballocItem;
      6056  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      6057  {
      6058  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      6059  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
      6060  }
      6061  else
      6062  {
      6063  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
      6064  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
      6065  }
      6066  }
      6067 }
      6068 
      6069 void VmaBlockMetadata::AddPoolStats(VmaPoolStats& inoutStats) const
      6070 {
      6071  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      6072 
      6073  inoutStats.size += m_Size;
      6074  inoutStats.unusedSize += m_SumFreeSize;
      6075  inoutStats.allocationCount += rangeCount - m_FreeCount;
      6076  inoutStats.unusedRangeCount += m_FreeCount;
      6077  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
      6078 }
      6079 
      6080 #if VMA_STATS_STRING_ENABLED
      6081 
      6082 void VmaBlockMetadata::PrintDetailedMap(class VmaJsonWriter& json) const
      6083 {
      6084  json.BeginObject();
      6085 
      6086  json.WriteString("TotalBytes");
      6087  json.WriteNumber(m_Size);
      6088 
      6089  json.WriteString("UnusedBytes");
      6090  json.WriteNumber(m_SumFreeSize);
      6091 
      6092  json.WriteString("Allocations");
      6093  json.WriteNumber((uint64_t)m_Suballocations.size() - m_FreeCount);
      6094 
      6095  json.WriteString("UnusedRanges");
      6096  json.WriteNumber(m_FreeCount);
      6097 
      6098  json.WriteString("Suballocations");
      6099  json.BeginArray();
      6100  size_t i = 0;
      6101  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      6102  suballocItem != m_Suballocations.cend();
      6103  ++suballocItem, ++i)
      6104  {
      6105  json.BeginObject(true);
      6106 
      6107  json.WriteString("Offset");
      6108  json.WriteNumber(suballocItem->offset);
      6109 
      6110  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6111  {
      6112  json.WriteString("Type");
      6113  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
      6114 
      6115  json.WriteString("Size");
      6116  json.WriteNumber(suballocItem->size);
      6117  }
      6118  else
      6119  {
      6120  suballocItem->hAllocation->PrintParameters(json);
      6121  }
      6122 
      6123  json.EndObject();
      6124  }
      6125  json.EndArray();
      6126 
      6127  json.EndObject();
      6128 }
      6129 
      6130 #endif // #if VMA_STATS_STRING_ENABLED
      6131 
      6132 /*
      6133 How many suitable free suballocations to analyze before choosing best one.
      6134 - Set to 1 to use First-Fit algorithm - first suitable free suballocation will
      6135  be chosen.
      6136 - Set to UINT32_MAX to use Best-Fit/Worst-Fit algorithm - all suitable free
      6137  suballocations will be analized and best one will be chosen.
      6138 - Any other value is also acceptable.
      6139 */
      6140 //static const uint32_t MAX_SUITABLE_SUBALLOCATIONS_TO_CHECK = 8;
      6141 
      6142 bool VmaBlockMetadata::CreateAllocationRequest(
      6143  uint32_t currentFrameIndex,
      6144  uint32_t frameInUseCount,
      6145  VkDeviceSize bufferImageGranularity,
      6146  VkDeviceSize allocSize,
      6147  VkDeviceSize allocAlignment,
      6148  VmaSuballocationType allocType,
      6149  bool canMakeOtherLost,
      6150  VmaAllocationRequest* pAllocationRequest)
      6151 {
      6152  VMA_ASSERT(allocSize > 0);
      6153  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      6154  VMA_ASSERT(pAllocationRequest != VMA_NULL);
      6155  VMA_HEAVY_ASSERT(Validate());
      6156 
      6157  // There is not enough total free space in this block to fullfill the request: Early return.
      6158  if(canMakeOtherLost == false && m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
      6159  {
      6160  return false;
      6161  }
      6162 
      6163  // New algorithm, efficiently searching freeSuballocationsBySize.
      6164  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
      6165  if(freeSuballocCount > 0)
      6166  {
      6167  if(VMA_BEST_FIT)
      6168  {
      6169  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
      6170  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      6171  m_FreeSuballocationsBySize.data(),
      6172  m_FreeSuballocationsBySize.data() + freeSuballocCount,
      6173  allocSize + 2 * VMA_DEBUG_MARGIN,
      6174  VmaSuballocationItemSizeLess());
      6175  size_t index = it - m_FreeSuballocationsBySize.data();
      6176  for(; index < freeSuballocCount; ++index)
      6177  {
      6178  if(CheckAllocation(
      6179  currentFrameIndex,
      6180  frameInUseCount,
      6181  bufferImageGranularity,
      6182  allocSize,
      6183  allocAlignment,
      6184  allocType,
      6185  m_FreeSuballocationsBySize[index],
      6186  false, // canMakeOtherLost
      6187  &pAllocationRequest->offset,
      6188  &pAllocationRequest->itemsToMakeLostCount,
      6189  &pAllocationRequest->sumFreeSize,
      6190  &pAllocationRequest->sumItemSize))
      6191  {
      6192  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      6193  return true;
      6194  }
      6195  }
      6196  }
      6197  else
      6198  {
      6199  // Search staring from biggest suballocations.
      6200  for(size_t index = freeSuballocCount; index--; )
      6201  {
      6202  if(CheckAllocation(
      6203  currentFrameIndex,
      6204  frameInUseCount,
      6205  bufferImageGranularity,
      6206  allocSize,
      6207  allocAlignment,
      6208  allocType,
      6209  m_FreeSuballocationsBySize[index],
      6210  false, // canMakeOtherLost
      6211  &pAllocationRequest->offset,
      6212  &pAllocationRequest->itemsToMakeLostCount,
      6213  &pAllocationRequest->sumFreeSize,
      6214  &pAllocationRequest->sumItemSize))
      6215  {
      6216  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      6217  return true;
      6218  }
      6219  }
      6220  }
      6221  }
      6222 
      6223  if(canMakeOtherLost)
      6224  {
      6225  // Brute-force algorithm. TODO: Come up with something better.
      6226 
      6227  pAllocationRequest->sumFreeSize = VK_WHOLE_SIZE;
      6228  pAllocationRequest->sumItemSize = VK_WHOLE_SIZE;
      6229 
      6230  VmaAllocationRequest tmpAllocRequest = {};
      6231  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
      6232  suballocIt != m_Suballocations.end();
      6233  ++suballocIt)
      6234  {
      6235  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
      6236  suballocIt->hAllocation->CanBecomeLost())
      6237  {
      6238  if(CheckAllocation(
      6239  currentFrameIndex,
      6240  frameInUseCount,
      6241  bufferImageGranularity,
      6242  allocSize,
      6243  allocAlignment,
      6244  allocType,
      6245  suballocIt,
      6246  canMakeOtherLost,
      6247  &tmpAllocRequest.offset,
      6248  &tmpAllocRequest.itemsToMakeLostCount,
      6249  &tmpAllocRequest.sumFreeSize,
      6250  &tmpAllocRequest.sumItemSize))
      6251  {
      6252  tmpAllocRequest.item = suballocIt;
      6253 
      6254  if(tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
      6255  {
      6256  *pAllocationRequest = tmpAllocRequest;
      6257  }
      6258  }
      6259  }
      6260  }
      6261 
      6262  if(pAllocationRequest->sumItemSize != VK_WHOLE_SIZE)
      6263  {
      6264  return true;
      6265  }
      6266  }
      6267 
      6268  return false;
      6269 }
      6270 
      6271 bool VmaBlockMetadata::MakeRequestedAllocationsLost(
      6272  uint32_t currentFrameIndex,
      6273  uint32_t frameInUseCount,
      6274  VmaAllocationRequest* pAllocationRequest)
      6275 {
      6276  while(pAllocationRequest->itemsToMakeLostCount > 0)
      6277  {
      6278  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
      6279  {
      6280  ++pAllocationRequest->item;
      6281  }
      6282  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      6283  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
      6284  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
      6285  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      6286  {
      6287  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
      6288  --pAllocationRequest->itemsToMakeLostCount;
      6289  }
      6290  else
      6291  {
      6292  return false;
      6293  }
      6294  }
      6295 
      6296  VMA_HEAVY_ASSERT(Validate());
      6297  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      6298  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6299 
      6300  return true;
      6301 }
      6302 
      6303 uint32_t VmaBlockMetadata::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      6304 {
      6305  uint32_t lostAllocationCount = 0;
      6306  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      6307  it != m_Suballocations.end();
      6308  ++it)
      6309  {
      6310  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
      6311  it->hAllocation->CanBecomeLost() &&
      6312  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      6313  {
      6314  it = FreeSuballocation(it);
      6315  ++lostAllocationCount;
      6316  }
      6317  }
      6318  return lostAllocationCount;
      6319 }
      6320 
      6321 VkResult VmaBlockMetadata::CheckCorruption(const void* pBlockData)
      6322 {
      6323  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      6324  it != m_Suballocations.end();
      6325  ++it)
      6326  {
      6327  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      6328  {
      6329  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
      6330  {
      6331  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      6332  return VK_ERROR_VALIDATION_FAILED_EXT;
      6333  }
      6334  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
      6335  {
      6336  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      6337  return VK_ERROR_VALIDATION_FAILED_EXT;
      6338  }
      6339  }
      6340  }
      6341 
      6342  return VK_SUCCESS;
      6343 }
      6344 
      6345 void VmaBlockMetadata::Alloc(
      6346  const VmaAllocationRequest& request,
      6347  VmaSuballocationType type,
      6348  VkDeviceSize allocSize,
      6349  VmaAllocation hAllocation)
      6350 {
      6351  VMA_ASSERT(request.item != m_Suballocations.end());
      6352  VmaSuballocation& suballoc = *request.item;
      6353  // Given suballocation is a free block.
      6354  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      6355  // Given offset is inside this suballocation.
      6356  VMA_ASSERT(request.offset >= suballoc.offset);
      6357  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
      6358  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
      6359  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
      6360 
      6361  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
      6362  // it to become used.
      6363  UnregisterFreeSuballocation(request.item);
      6364 
      6365  suballoc.offset = request.offset;
      6366  suballoc.size = allocSize;
      6367  suballoc.type = type;
      6368  suballoc.hAllocation = hAllocation;
      6369 
      6370  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
      6371  if(paddingEnd)
      6372  {
      6373  VmaSuballocation paddingSuballoc = {};
      6374  paddingSuballoc.offset = request.offset + allocSize;
      6375  paddingSuballoc.size = paddingEnd;
      6376  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      6377  VmaSuballocationList::iterator next = request.item;
      6378  ++next;
      6379  const VmaSuballocationList::iterator paddingEndItem =
      6380  m_Suballocations.insert(next, paddingSuballoc);
      6381  RegisterFreeSuballocation(paddingEndItem);
      6382  }
      6383 
      6384  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
      6385  if(paddingBegin)
      6386  {
      6387  VmaSuballocation paddingSuballoc = {};
      6388  paddingSuballoc.offset = request.offset - paddingBegin;
      6389  paddingSuballoc.size = paddingBegin;
      6390  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      6391  const VmaSuballocationList::iterator paddingBeginItem =
      6392  m_Suballocations.insert(request.item, paddingSuballoc);
      6393  RegisterFreeSuballocation(paddingBeginItem);
      6394  }
      6395 
      6396  // Update totals.
      6397  m_FreeCount = m_FreeCount - 1;
      6398  if(paddingBegin > 0)
      6399  {
      6400  ++m_FreeCount;
      6401  }
      6402  if(paddingEnd > 0)
      6403  {
      6404  ++m_FreeCount;
      6405  }
      6406  m_SumFreeSize -= allocSize;
      6407 }
      6408 
      6409 void VmaBlockMetadata::Free(const VmaAllocation allocation)
      6410 {
      6411  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      6412  suballocItem != m_Suballocations.end();
      6413  ++suballocItem)
      6414  {
      6415  VmaSuballocation& suballoc = *suballocItem;
      6416  if(suballoc.hAllocation == allocation)
      6417  {
      6418  FreeSuballocation(suballocItem);
      6419  VMA_HEAVY_ASSERT(Validate());
      6420  return;
      6421  }
      6422  }
      6423  VMA_ASSERT(0 && "Not found!");
      6424 }
      6425 
      6426 void VmaBlockMetadata::FreeAtOffset(VkDeviceSize offset)
      6427 {
      6428  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      6429  suballocItem != m_Suballocations.end();
      6430  ++suballocItem)
      6431  {
      6432  VmaSuballocation& suballoc = *suballocItem;
      6433  if(suballoc.offset == offset)
      6434  {
      6435  FreeSuballocation(suballocItem);
      6436  return;
      6437  }
      6438  }
      6439  VMA_ASSERT(0 && "Not found!");
      6440 }
      6441 
      6442 bool VmaBlockMetadata::ValidateFreeSuballocationList() const
      6443 {
      6444  VkDeviceSize lastSize = 0;
      6445  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
      6446  {
      6447  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
      6448 
      6449  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      6450  {
      6451  VMA_ASSERT(0);
      6452  return false;
      6453  }
      6454  if(it->size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      6455  {
      6456  VMA_ASSERT(0);
      6457  return false;
      6458  }
      6459  if(it->size < lastSize)
      6460  {
      6461  VMA_ASSERT(0);
      6462  return false;
      6463  }
      6464 
      6465  lastSize = it->size;
      6466  }
      6467  return true;
      6468 }
      6469 
      6470 bool VmaBlockMetadata::CheckAllocation(
      6471  uint32_t currentFrameIndex,
      6472  uint32_t frameInUseCount,
      6473  VkDeviceSize bufferImageGranularity,
      6474  VkDeviceSize allocSize,
      6475  VkDeviceSize allocAlignment,
      6476  VmaSuballocationType allocType,
      6477  VmaSuballocationList::const_iterator suballocItem,
      6478  bool canMakeOtherLost,
      6479  VkDeviceSize* pOffset,
      6480  size_t* itemsToMakeLostCount,
      6481  VkDeviceSize* pSumFreeSize,
      6482  VkDeviceSize* pSumItemSize) const
      6483 {
      6484  VMA_ASSERT(allocSize > 0);
      6485  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      6486  VMA_ASSERT(suballocItem != m_Suballocations.cend());
      6487  VMA_ASSERT(pOffset != VMA_NULL);
      6488 
      6489  *itemsToMakeLostCount = 0;
      6490  *pSumFreeSize = 0;
      6491  *pSumItemSize = 0;
      6492 
      6493  if(canMakeOtherLost)
      6494  {
      6495  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6496  {
      6497  *pSumFreeSize = suballocItem->size;
      6498  }
      6499  else
      6500  {
      6501  if(suballocItem->hAllocation->CanBecomeLost() &&
      6502  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      6503  {
      6504  ++*itemsToMakeLostCount;
      6505  *pSumItemSize = suballocItem->size;
      6506  }
      6507  else
      6508  {
      6509  return false;
      6510  }
      6511  }
      6512 
      6513  // Remaining size is too small for this request: Early return.
      6514  if(m_Size - suballocItem->offset < allocSize)
      6515  {
      6516  return false;
      6517  }
      6518 
      6519  // Start from offset equal to beginning of this suballocation.
      6520  *pOffset = suballocItem->offset;
      6521 
      6522  // Apply VMA_DEBUG_MARGIN at the beginning.
      6523  if(VMA_DEBUG_MARGIN > 0)
      6524  {
      6525  *pOffset += VMA_DEBUG_MARGIN;
      6526  }
      6527 
      6528  // Apply alignment.
      6529  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      6530 
      6531  // Check previous suballocations for BufferImageGranularity conflicts.
      6532  // Make bigger alignment if necessary.
      6533  if(bufferImageGranularity > 1)
      6534  {
      6535  bool bufferImageGranularityConflict = false;
      6536  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      6537  while(prevSuballocItem != m_Suballocations.cbegin())
      6538  {
      6539  --prevSuballocItem;
      6540  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      6541  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      6542  {
      6543  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      6544  {
      6545  bufferImageGranularityConflict = true;
      6546  break;
      6547  }
      6548  }
      6549  else
      6550  // Already on previous page.
      6551  break;
      6552  }
      6553  if(bufferImageGranularityConflict)
      6554  {
      6555  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      6556  }
      6557  }
      6558 
      6559  // Now that we have final *pOffset, check if we are past suballocItem.
      6560  // If yes, return false - this function should be called for another suballocItem as starting point.
      6561  if(*pOffset >= suballocItem->offset + suballocItem->size)
      6562  {
      6563  return false;
      6564  }
      6565 
      6566  // Calculate padding at the beginning based on current offset.
      6567  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
      6568 
      6569  // Calculate required margin at the end.
      6570  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      6571 
      6572  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
      6573  // Another early return check.
      6574  if(suballocItem->offset + totalSize > m_Size)
      6575  {
      6576  return false;
      6577  }
      6578 
      6579  // Advance lastSuballocItem until desired size is reached.
      6580  // Update itemsToMakeLostCount.
      6581  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
      6582  if(totalSize > suballocItem->size)
      6583  {
      6584  VkDeviceSize remainingSize = totalSize - suballocItem->size;
      6585  while(remainingSize > 0)
      6586  {
      6587  ++lastSuballocItem;
      6588  if(lastSuballocItem == m_Suballocations.cend())
      6589  {
      6590  return false;
      6591  }
      6592  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6593  {
      6594  *pSumFreeSize += lastSuballocItem->size;
      6595  }
      6596  else
      6597  {
      6598  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
      6599  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
      6600  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      6601  {
      6602  ++*itemsToMakeLostCount;
      6603  *pSumItemSize += lastSuballocItem->size;
      6604  }
      6605  else
      6606  {
      6607  return false;
      6608  }
      6609  }
      6610  remainingSize = (lastSuballocItem->size < remainingSize) ?
      6611  remainingSize - lastSuballocItem->size : 0;
      6612  }
      6613  }
      6614 
      6615  // Check next suballocations for BufferImageGranularity conflicts.
      6616  // If conflict exists, we must mark more allocations lost or fail.
      6617  if(bufferImageGranularity > 1)
      6618  {
      6619  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
      6620  ++nextSuballocItem;
      6621  while(nextSuballocItem != m_Suballocations.cend())
      6622  {
      6623  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      6624  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      6625  {
      6626  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      6627  {
      6628  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
      6629  if(nextSuballoc.hAllocation->CanBecomeLost() &&
      6630  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      6631  {
      6632  ++*itemsToMakeLostCount;
      6633  }
      6634  else
      6635  {
      6636  return false;
      6637  }
      6638  }
      6639  }
      6640  else
      6641  {
      6642  // Already on next page.
      6643  break;
      6644  }
      6645  ++nextSuballocItem;
      6646  }
      6647  }
      6648  }
      6649  else
      6650  {
      6651  const VmaSuballocation& suballoc = *suballocItem;
      6652  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      6653 
      6654  *pSumFreeSize = suballoc.size;
      6655 
      6656  // Size of this suballocation is too small for this request: Early return.
      6657  if(suballoc.size < allocSize)
      6658  {
      6659  return false;
      6660  }
      6661 
      6662  // Start from offset equal to beginning of this suballocation.
      6663  *pOffset = suballoc.offset;
      6664 
      6665  // Apply VMA_DEBUG_MARGIN at the beginning.
      6666  if(VMA_DEBUG_MARGIN > 0)
      6667  {
      6668  *pOffset += VMA_DEBUG_MARGIN;
      6669  }
      6670 
      6671  // Apply alignment.
      6672  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      6673 
      6674  // Check previous suballocations for BufferImageGranularity conflicts.
      6675  // Make bigger alignment if necessary.
      6676  if(bufferImageGranularity > 1)
      6677  {
      6678  bool bufferImageGranularityConflict = false;
      6679  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      6680  while(prevSuballocItem != m_Suballocations.cbegin())
      6681  {
      6682  --prevSuballocItem;
      6683  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      6684  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      6685  {
      6686  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      6687  {
      6688  bufferImageGranularityConflict = true;
      6689  break;
      6690  }
      6691  }
      6692  else
      6693  // Already on previous page.
      6694  break;
      6695  }
      6696  if(bufferImageGranularityConflict)
      6697  {
      6698  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      6699  }
      6700  }
      6701 
      6702  // Calculate padding at the beginning based on current offset.
      6703  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
      6704 
      6705  // Calculate required margin at the end.
      6706  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      6707 
      6708  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
      6709  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
      6710  {
      6711  return false;
      6712  }
      6713 
      6714  // Check next suballocations for BufferImageGranularity conflicts.
      6715  // If conflict exists, allocation cannot be made here.
      6716  if(bufferImageGranularity > 1)
      6717  {
      6718  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
      6719  ++nextSuballocItem;
      6720  while(nextSuballocItem != m_Suballocations.cend())
      6721  {
      6722  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      6723  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      6724  {
      6725  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      6726  {
      6727  return false;
      6728  }
      6729  }
      6730  else
      6731  {
      6732  // Already on next page.
      6733  break;
      6734  }
      6735  ++nextSuballocItem;
      6736  }
      6737  }
      6738  }
      6739 
      6740  // All tests passed: Success. pOffset is already filled.
      6741  return true;
      6742 }
      6743 
      6744 void VmaBlockMetadata::MergeFreeWithNext(VmaSuballocationList::iterator item)
      6745 {
      6746  VMA_ASSERT(item != m_Suballocations.end());
      6747  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6748 
      6749  VmaSuballocationList::iterator nextItem = item;
      6750  ++nextItem;
      6751  VMA_ASSERT(nextItem != m_Suballocations.end());
      6752  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
      6753 
      6754  item->size += nextItem->size;
      6755  --m_FreeCount;
      6756  m_Suballocations.erase(nextItem);
      6757 }
      6758 
      6759 VmaSuballocationList::iterator VmaBlockMetadata::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
      6760 {
      6761  // Change this suballocation to be marked as free.
      6762  VmaSuballocation& suballoc = *suballocItem;
      6763  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      6764  suballoc.hAllocation = VK_NULL_HANDLE;
      6765 
      6766  // Update totals.
      6767  ++m_FreeCount;
      6768  m_SumFreeSize += suballoc.size;
      6769 
      6770  // Merge with previous and/or next suballocation if it's also free.
      6771  bool mergeWithNext = false;
      6772  bool mergeWithPrev = false;
      6773 
      6774  VmaSuballocationList::iterator nextItem = suballocItem;
      6775  ++nextItem;
      6776  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
      6777  {
      6778  mergeWithNext = true;
      6779  }
      6780 
      6781  VmaSuballocationList::iterator prevItem = suballocItem;
      6782  if(suballocItem != m_Suballocations.begin())
      6783  {
      6784  --prevItem;
      6785  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      6786  {
      6787  mergeWithPrev = true;
      6788  }
      6789  }
      6790 
      6791  if(mergeWithNext)
      6792  {
      6793  UnregisterFreeSuballocation(nextItem);
      6794  MergeFreeWithNext(suballocItem);
      6795  }
      6796 
      6797  if(mergeWithPrev)
      6798  {
      6799  UnregisterFreeSuballocation(prevItem);
      6800  MergeFreeWithNext(prevItem);
      6801  RegisterFreeSuballocation(prevItem);
      6802  return prevItem;
      6803  }
      6804  else
      6805  {
      6806  RegisterFreeSuballocation(suballocItem);
      6807  return suballocItem;
      6808  }
      6809 }
      6810 
      6811 void VmaBlockMetadata::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
      6812 {
      6813  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6814  VMA_ASSERT(item->size > 0);
      6815 
      6816  // You may want to enable this validation at the beginning or at the end of
      6817  // this function, depending on what do you want to check.
      6818  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6819 
      6820  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      6821  {
      6822  if(m_FreeSuballocationsBySize.empty())
      6823  {
      6824  m_FreeSuballocationsBySize.push_back(item);
      6825  }
      6826  else
      6827  {
      6828  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
      6829  }
      6830  }
      6831 
      6832  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6833 }
      6834 
      6835 
      6836 void VmaBlockMetadata::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
      6837 {
      6838  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      6839  VMA_ASSERT(item->size > 0);
      6840 
      6841  // You may want to enable this validation at the beginning or at the end of
      6842  // this function, depending on what do you want to check.
      6843  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6844 
      6845  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      6846  {
      6847  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      6848  m_FreeSuballocationsBySize.data(),
      6849  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
      6850  item,
      6851  VmaSuballocationItemSizeLess());
      6852  for(size_t index = it - m_FreeSuballocationsBySize.data();
      6853  index < m_FreeSuballocationsBySize.size();
      6854  ++index)
      6855  {
      6856  if(m_FreeSuballocationsBySize[index] == item)
      6857  {
      6858  VmaVectorRemove(m_FreeSuballocationsBySize, index);
      6859  return;
      6860  }
      6861  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
      6862  }
      6863  VMA_ASSERT(0 && "Not found.");
      6864  }
      6865 
      6866  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      6867 }
      6868 
      6870 // class VmaDeviceMemoryBlock
      6871 
      6872 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
      6873  m_Metadata(hAllocator),
      6874  m_MemoryTypeIndex(UINT32_MAX),
      6875  m_Id(0),
      6876  m_hMemory(VK_NULL_HANDLE),
      6877  m_MapCount(0),
      6878  m_pMappedData(VMA_NULL)
      6879 {
      6880 }
      6881 
      6882 void VmaDeviceMemoryBlock::Init(
      6883  uint32_t newMemoryTypeIndex,
      6884  VkDeviceMemory newMemory,
      6885  VkDeviceSize newSize,
      6886  uint32_t id)
      6887 {
      6888  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      6889 
      6890  m_MemoryTypeIndex = newMemoryTypeIndex;
      6891  m_Id = id;
      6892  m_hMemory = newMemory;
      6893 
      6894  m_Metadata.Init(newSize);
      6895 }
      6896 
      6897 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
      6898 {
      6899  // This is the most important assert in the entire library.
      6900  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
      6901  VMA_ASSERT(m_Metadata.IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
      6902 
      6903  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
      6904  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_Metadata.GetSize(), m_hMemory);
      6905  m_hMemory = VK_NULL_HANDLE;
      6906 }
      6907 
      6908 bool VmaDeviceMemoryBlock::Validate() const
      6909 {
      6910  if((m_hMemory == VK_NULL_HANDLE) ||
      6911  (m_Metadata.GetSize() == 0))
      6912  {
      6913  return false;
      6914  }
      6915 
      6916  return m_Metadata.Validate();
      6917 }
      6918 
      6919 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
      6920 {
      6921  void* pData = nullptr;
      6922  VkResult res = Map(hAllocator, 1, &pData);
      6923  if(res != VK_SUCCESS)
      6924  {
      6925  return res;
      6926  }
      6927 
      6928  res = m_Metadata.CheckCorruption(pData);
      6929 
      6930  Unmap(hAllocator, 1);
      6931 
      6932  return res;
      6933 }
      6934 
      6935 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
      6936 {
      6937  if(count == 0)
      6938  {
      6939  return VK_SUCCESS;
      6940  }
      6941 
      6942  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      6943  if(m_MapCount != 0)
      6944  {
      6945  m_MapCount += count;
      6946  VMA_ASSERT(m_pMappedData != VMA_NULL);
      6947  if(ppData != VMA_NULL)
      6948  {
      6949  *ppData = m_pMappedData;
      6950  }
      6951  return VK_SUCCESS;
      6952  }
      6953  else
      6954  {
      6955  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      6956  hAllocator->m_hDevice,
      6957  m_hMemory,
      6958  0, // offset
      6959  VK_WHOLE_SIZE,
      6960  0, // flags
      6961  &m_pMappedData);
      6962  if(result == VK_SUCCESS)
      6963  {
      6964  if(ppData != VMA_NULL)
      6965  {
      6966  *ppData = m_pMappedData;
      6967  }
      6968  m_MapCount = count;
      6969  }
      6970  return result;
      6971  }
      6972 }
      6973 
      6974 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
      6975 {
      6976  if(count == 0)
      6977  {
      6978  return;
      6979  }
      6980 
      6981  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      6982  if(m_MapCount >= count)
      6983  {
      6984  m_MapCount -= count;
      6985  if(m_MapCount == 0)
      6986  {
      6987  m_pMappedData = VMA_NULL;
      6988  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
      6989  }
      6990  }
      6991  else
      6992  {
      6993  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
      6994  }
      6995 }
      6996 
      6997 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      6998 {
      6999  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      7000  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      7001 
      7002  void* pData;
      7003  VkResult res = Map(hAllocator, 1, &pData);
      7004  if(res != VK_SUCCESS)
      7005  {
      7006  return res;
      7007  }
      7008 
      7009  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
      7010  VmaWriteMagicValue(pData, allocOffset + allocSize);
      7011 
      7012  Unmap(hAllocator, 1);
      7013 
      7014  return VK_SUCCESS;
      7015 }
      7016 
      7017 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      7018 {
      7019  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      7020  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      7021 
      7022  void* pData;
      7023  VkResult res = Map(hAllocator, 1, &pData);
      7024  if(res != VK_SUCCESS)
      7025  {
      7026  return res;
      7027  }
      7028 
      7029  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
      7030  {
      7031  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
      7032  }
      7033  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
      7034  {
      7035  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
      7036  }
      7037 
      7038  Unmap(hAllocator, 1);
      7039 
      7040  return VK_SUCCESS;
      7041 }
      7042 
      7043 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
      7044  const VmaAllocator hAllocator,
      7045  const VmaAllocation hAllocation,
      7046  VkBuffer hBuffer)
      7047 {
      7048  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      7049  hAllocation->GetBlock() == this);
      7050  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      7051  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      7052  return hAllocator->GetVulkanFunctions().vkBindBufferMemory(
      7053  hAllocator->m_hDevice,
      7054  hBuffer,
      7055  m_hMemory,
      7056  hAllocation->GetOffset());
      7057 }
      7058 
      7059 VkResult VmaDeviceMemoryBlock::BindImageMemory(
      7060  const VmaAllocator hAllocator,
      7061  const VmaAllocation hAllocation,
      7062  VkImage hImage)
      7063 {
      7064  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      7065  hAllocation->GetBlock() == this);
      7066  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      7067  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      7068  return hAllocator->GetVulkanFunctions().vkBindImageMemory(
      7069  hAllocator->m_hDevice,
      7070  hImage,
      7071  m_hMemory,
      7072  hAllocation->GetOffset());
      7073 }
      7074 
      7075 static void InitStatInfo(VmaStatInfo& outInfo)
      7076 {
      7077  memset(&outInfo, 0, sizeof(outInfo));
      7078  outInfo.allocationSizeMin = UINT64_MAX;
      7079  outInfo.unusedRangeSizeMin = UINT64_MAX;
      7080 }
      7081 
      7082 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
      7083 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
      7084 {
      7085  inoutInfo.blockCount += srcInfo.blockCount;
      7086  inoutInfo.allocationCount += srcInfo.allocationCount;
      7087  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
      7088  inoutInfo.usedBytes += srcInfo.usedBytes;
      7089  inoutInfo.unusedBytes += srcInfo.unusedBytes;
      7090  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
      7091  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
      7092  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
      7093  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
      7094 }
      7095 
      7096 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
      7097 {
      7098  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
      7099  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
      7100  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
      7101  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
      7102 }
      7103 
      7104 VmaPool_T::VmaPool_T(
      7105  VmaAllocator hAllocator,
      7106  const VmaPoolCreateInfo& createInfo) :
      7107  m_BlockVector(
      7108  hAllocator,
      7109  createInfo.memoryTypeIndex,
      7110  createInfo.blockSize,
      7111  createInfo.minBlockCount,
      7112  createInfo.maxBlockCount,
      7113  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
      7114  createInfo.frameInUseCount,
      7115  true), // isCustomPool
      7116  m_Id(0)
      7117 {
      7118 }
      7119 
      7120 VmaPool_T::~VmaPool_T()
      7121 {
      7122 }
      7123 
      7124 #if VMA_STATS_STRING_ENABLED
      7125 
      7126 #endif // #if VMA_STATS_STRING_ENABLED
      7127 
      7128 VmaBlockVector::VmaBlockVector(
      7129  VmaAllocator hAllocator,
      7130  uint32_t memoryTypeIndex,
      7131  VkDeviceSize preferredBlockSize,
      7132  size_t minBlockCount,
      7133  size_t maxBlockCount,
      7134  VkDeviceSize bufferImageGranularity,
      7135  uint32_t frameInUseCount,
      7136  bool isCustomPool) :
      7137  m_hAllocator(hAllocator),
      7138  m_MemoryTypeIndex(memoryTypeIndex),
      7139  m_PreferredBlockSize(preferredBlockSize),
      7140  m_MinBlockCount(minBlockCount),
      7141  m_MaxBlockCount(maxBlockCount),
      7142  m_BufferImageGranularity(bufferImageGranularity),
      7143  m_FrameInUseCount(frameInUseCount),
      7144  m_IsCustomPool(isCustomPool),
      7145  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
      7146  m_HasEmptyBlock(false),
      7147  m_pDefragmentator(VMA_NULL),
      7148  m_NextBlockId(0)
      7149 {
      7150 }
      7151 
      7152 VmaBlockVector::~VmaBlockVector()
      7153 {
      7154  VMA_ASSERT(m_pDefragmentator == VMA_NULL);
      7155 
      7156  for(size_t i = m_Blocks.size(); i--; )
      7157  {
      7158  m_Blocks[i]->Destroy(m_hAllocator);
      7159  vma_delete(m_hAllocator, m_Blocks[i]);
      7160  }
      7161 }
      7162 
      7163 VkResult VmaBlockVector::CreateMinBlocks()
      7164 {
      7165  for(size_t i = 0; i < m_MinBlockCount; ++i)
      7166  {
      7167  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
      7168  if(res != VK_SUCCESS)
      7169  {
      7170  return res;
      7171  }
      7172  }
      7173  return VK_SUCCESS;
      7174 }
      7175 
      7176 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
      7177 {
      7178  pStats->size = 0;
      7179  pStats->unusedSize = 0;
      7180  pStats->allocationCount = 0;
      7181  pStats->unusedRangeCount = 0;
      7182  pStats->unusedRangeSizeMax = 0;
      7183 
      7184  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7185 
      7186  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7187  {
      7188  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7189  VMA_ASSERT(pBlock);
      7190  VMA_HEAVY_ASSERT(pBlock->Validate());
      7191  pBlock->m_Metadata.AddPoolStats(*pStats);
      7192  }
      7193 }
      7194 
      7195 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
      7196 {
      7197  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      7198  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
      7199  (VMA_DEBUG_MARGIN > 0) &&
      7200  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
      7201 }
      7202 
      7203 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
      7204 
      7205 VkResult VmaBlockVector::Allocate(
      7206  VmaPool hCurrentPool,
      7207  uint32_t currentFrameIndex,
      7208  VkDeviceSize size,
      7209  VkDeviceSize alignment,
      7210  const VmaAllocationCreateInfo& createInfo,
      7211  VmaSuballocationType suballocType,
      7212  VmaAllocation* pAllocation)
      7213 {
      7214  // Early reject: requested allocation size is larger that maximum block size for this block vector.
      7215  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
      7216  {
      7217  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      7218  }
      7219 
      7220  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      7221  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
      7222 
      7223  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7224 
      7225  // 1. Search existing allocations. Try to allocate without making other allocations lost.
      7226  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      7227  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      7228  {
      7229  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      7230  VMA_ASSERT(pCurrBlock);
      7231  VmaAllocationRequest currRequest = {};
      7232  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
      7233  currentFrameIndex,
      7234  m_FrameInUseCount,
      7235  m_BufferImageGranularity,
      7236  size,
      7237  alignment,
      7238  suballocType,
      7239  false, // canMakeOtherLost
      7240  &currRequest))
      7241  {
      7242  // Allocate from pCurrBlock.
      7243  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
      7244 
      7245  if(mapped)
      7246  {
      7247  VkResult res = pCurrBlock->Map(m_hAllocator, 1, VMA_NULL);
      7248  if(res != VK_SUCCESS)
      7249  {
      7250  return res;
      7251  }
      7252  }
      7253 
      7254  // We no longer have an empty Allocation.
      7255  if(pCurrBlock->m_Metadata.IsEmpty())
      7256  {
      7257  m_HasEmptyBlock = false;
      7258  }
      7259 
      7260  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
      7261  pCurrBlock->m_Metadata.Alloc(currRequest, suballocType, size, *pAllocation);
      7262  (*pAllocation)->InitBlockAllocation(
      7263  hCurrentPool,
      7264  pCurrBlock,
      7265  currRequest.offset,
      7266  alignment,
      7267  size,
      7268  suballocType,
      7269  mapped,
      7270  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      7271  VMA_HEAVY_ASSERT(pCurrBlock->Validate());
      7272  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
      7273  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      7274  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      7275  {
      7276  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      7277  }
      7278  if(IsCorruptionDetectionEnabled())
      7279  {
      7280  VkResult res = pCurrBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
      7281  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      7282  }
      7283  return VK_SUCCESS;
      7284  }
      7285  }
      7286 
      7287  const bool canCreateNewBlock =
      7288  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
      7289  (m_Blocks.size() < m_MaxBlockCount);
      7290 
      7291  // 2. Try to create new block.
      7292  if(canCreateNewBlock)
      7293  {
      7294  // Calculate optimal size for new block.
      7295  VkDeviceSize newBlockSize = m_PreferredBlockSize;
      7296  uint32_t newBlockSizeShift = 0;
      7297  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
      7298 
      7299  // Allocating blocks of other sizes is allowed only in default pools.
      7300  // In custom pools block size is fixed.
      7301  if(m_IsCustomPool == false)
      7302  {
      7303  // Allocate 1/8, 1/4, 1/2 as first blocks.
      7304  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
      7305  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
      7306  {
      7307  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      7308  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
      7309  {
      7310  newBlockSize = smallerNewBlockSize;
      7311  ++newBlockSizeShift;
      7312  }
      7313  else
      7314  {
      7315  break;
      7316  }
      7317  }
      7318  }
      7319 
      7320  size_t newBlockIndex = 0;
      7321  VkResult res = CreateBlock(newBlockSize, &newBlockIndex);
      7322  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
      7323  if(m_IsCustomPool == false)
      7324  {
      7325  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
      7326  {
      7327  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      7328  if(smallerNewBlockSize >= size)
      7329  {
      7330  newBlockSize = smallerNewBlockSize;
      7331  ++newBlockSizeShift;
      7332  res = CreateBlock(newBlockSize, &newBlockIndex);
      7333  }
      7334  else
      7335  {
      7336  break;
      7337  }
      7338  }
      7339  }
      7340 
      7341  if(res == VK_SUCCESS)
      7342  {
      7343  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
      7344  VMA_ASSERT(pBlock->m_Metadata.GetSize() >= size);
      7345 
      7346  if(mapped)
      7347  {
      7348  res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
      7349  if(res != VK_SUCCESS)
      7350  {
      7351  return res;
      7352  }
      7353  }
      7354 
      7355  // Allocate from pBlock. Because it is empty, dstAllocRequest can be trivially filled.
      7356  VmaAllocationRequest allocRequest;
      7357  if(pBlock->m_Metadata.CreateAllocationRequest(
      7358  currentFrameIndex,
      7359  m_FrameInUseCount,
      7360  m_BufferImageGranularity,
      7361  size,
      7362  alignment,
      7363  suballocType,
      7364  false, // canMakeOtherLost
      7365  &allocRequest))
      7366  {
      7367  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
      7368  pBlock->m_Metadata.Alloc(allocRequest, suballocType, size, *pAllocation);
      7369  (*pAllocation)->InitBlockAllocation(
      7370  hCurrentPool,
      7371  pBlock,
      7372  allocRequest.offset,
      7373  alignment,
      7374  size,
      7375  suballocType,
      7376  mapped,
      7377  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      7378  VMA_HEAVY_ASSERT(pBlock->Validate());
      7379  VMA_DEBUG_LOG(" Created new allocation Size=%llu", allocInfo.allocationSize);
      7380  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      7381  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      7382  {
      7383  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      7384  }
      7385  if(IsCorruptionDetectionEnabled())
      7386  {
      7387  res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, allocRequest.offset, size);
      7388  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      7389  }
      7390  return VK_SUCCESS;
      7391  }
      7392  else
      7393  {
      7394  // Allocation from empty block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
      7395  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      7396  }
      7397  }
      7398  }
      7399 
      7400  const bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
      7401 
      7402  // 3. Try to allocate from existing blocks with making other allocations lost.
      7403  if(canMakeOtherLost)
      7404  {
      7405  uint32_t tryIndex = 0;
      7406  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
      7407  {
      7408  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
      7409  VmaAllocationRequest bestRequest = {};
      7410  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
      7411 
      7412  // 1. Search existing allocations.
      7413  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      7414  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      7415  {
      7416  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      7417  VMA_ASSERT(pCurrBlock);
      7418  VmaAllocationRequest currRequest = {};
      7419  if(pCurrBlock->m_Metadata.CreateAllocationRequest(
      7420  currentFrameIndex,
      7421  m_FrameInUseCount,
      7422  m_BufferImageGranularity,
      7423  size,
      7424  alignment,
      7425  suballocType,
      7426  canMakeOtherLost,
      7427  &currRequest))
      7428  {
      7429  const VkDeviceSize currRequestCost = currRequest.CalcCost();
      7430  if(pBestRequestBlock == VMA_NULL ||
      7431  currRequestCost < bestRequestCost)
      7432  {
      7433  pBestRequestBlock = pCurrBlock;
      7434  bestRequest = currRequest;
      7435  bestRequestCost = currRequestCost;
      7436 
      7437  if(bestRequestCost == 0)
      7438  {
      7439  break;
      7440  }
      7441  }
      7442  }
      7443  }
      7444 
      7445  if(pBestRequestBlock != VMA_NULL)
      7446  {
      7447  if(mapped)
      7448  {
      7449  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
      7450  if(res != VK_SUCCESS)
      7451  {
      7452  return res;
      7453  }
      7454  }
      7455 
      7456  if(pBestRequestBlock->m_Metadata.MakeRequestedAllocationsLost(
      7457  currentFrameIndex,
      7458  m_FrameInUseCount,
      7459  &bestRequest))
      7460  {
      7461  // We no longer have an empty Allocation.
      7462  if(pBestRequestBlock->m_Metadata.IsEmpty())
      7463  {
      7464  m_HasEmptyBlock = false;
      7465  }
      7466  // Allocate from this pBlock.
      7467  *pAllocation = vma_new(m_hAllocator, VmaAllocation_T)(currentFrameIndex, isUserDataString);
      7468  pBestRequestBlock->m_Metadata.Alloc(bestRequest, suballocType, size, *pAllocation);
      7469  (*pAllocation)->InitBlockAllocation(
      7470  hCurrentPool,
      7471  pBestRequestBlock,
      7472  bestRequest.offset,
      7473  alignment,
      7474  size,
      7475  suballocType,
      7476  mapped,
      7477  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      7478  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
      7479  VMA_DEBUG_LOG(" Returned from existing allocation #%u", (uint32_t)blockIndex);
      7480  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      7481  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      7482  {
      7483  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      7484  }
      7485  if(IsCorruptionDetectionEnabled())
      7486  {
      7487  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
      7488  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      7489  }
      7490  return VK_SUCCESS;
      7491  }
      7492  // else: Some allocations must have been touched while we are here. Next try.
      7493  }
      7494  else
      7495  {
      7496  // Could not find place in any of the blocks - break outer loop.
      7497  break;
      7498  }
      7499  }
      7500  /* Maximum number of tries exceeded - a very unlike event when many other
      7501  threads are simultaneously touching allocations making it impossible to make
      7502  lost at the same time as we try to allocate. */
      7503  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
      7504  {
      7505  return VK_ERROR_TOO_MANY_OBJECTS;
      7506  }
      7507  }
      7508 
      7509  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      7510 }
      7511 
      7512 void VmaBlockVector::Free(
      7513  VmaAllocation hAllocation)
      7514 {
      7515  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
      7516 
      7517  // Scope for lock.
      7518  {
      7519  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7520 
      7521  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      7522 
      7523  if(IsCorruptionDetectionEnabled())
      7524  {
      7525  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
      7526  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
      7527  }
      7528 
      7529  if(hAllocation->IsPersistentMap())
      7530  {
      7531  pBlock->Unmap(m_hAllocator, 1);
      7532  }
      7533 
      7534  pBlock->m_Metadata.Free(hAllocation);
      7535  VMA_HEAVY_ASSERT(pBlock->Validate());
      7536 
      7537  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", memTypeIndex);
      7538 
      7539  // pBlock became empty after this deallocation.
      7540  if(pBlock->m_Metadata.IsEmpty())
      7541  {
      7542  // Already has empty Allocation. We don't want to have two, so delete this one.
      7543  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
      7544  {
      7545  pBlockToDelete = pBlock;
      7546  Remove(pBlock);
      7547  }
      7548  // We now have first empty block.
      7549  else
      7550  {
      7551  m_HasEmptyBlock = true;
      7552  }
      7553  }
      7554  // pBlock didn't become empty, but we have another empty block - find and free that one.
      7555  // (This is optional, heuristics.)
      7556  else if(m_HasEmptyBlock)
      7557  {
      7558  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
      7559  if(pLastBlock->m_Metadata.IsEmpty() && m_Blocks.size() > m_MinBlockCount)
      7560  {
      7561  pBlockToDelete = pLastBlock;
      7562  m_Blocks.pop_back();
      7563  m_HasEmptyBlock = false;
      7564  }
      7565  }
      7566 
      7567  IncrementallySortBlocks();
      7568  }
      7569 
      7570  // Destruction of a free Allocation. Deferred until this point, outside of mutex
      7571  // lock, for performance reason.
      7572  if(pBlockToDelete != VMA_NULL)
      7573  {
      7574  VMA_DEBUG_LOG(" Deleted empty allocation");
      7575  pBlockToDelete->Destroy(m_hAllocator);
      7576  vma_delete(m_hAllocator, pBlockToDelete);
      7577  }
      7578 }
      7579 
      7580 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
      7581 {
      7582  VkDeviceSize result = 0;
      7583  for(size_t i = m_Blocks.size(); i--; )
      7584  {
      7585  result = VMA_MAX(result, m_Blocks[i]->m_Metadata.GetSize());
      7586  if(result >= m_PreferredBlockSize)
      7587  {
      7588  break;
      7589  }
      7590  }
      7591  return result;
      7592 }
      7593 
      7594 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
      7595 {
      7596  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7597  {
      7598  if(m_Blocks[blockIndex] == pBlock)
      7599  {
      7600  VmaVectorRemove(m_Blocks, blockIndex);
      7601  return;
      7602  }
      7603  }
      7604  VMA_ASSERT(0);
      7605 }
      7606 
      7607 void VmaBlockVector::IncrementallySortBlocks()
      7608 {
      7609  // Bubble sort only until first swap.
      7610  for(size_t i = 1; i < m_Blocks.size(); ++i)
      7611  {
      7612  if(m_Blocks[i - 1]->m_Metadata.GetSumFreeSize() > m_Blocks[i]->m_Metadata.GetSumFreeSize())
      7613  {
      7614  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
      7615  return;
      7616  }
      7617  }
      7618 }
      7619 
      7620 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
      7621 {
      7622  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      7623  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
      7624  allocInfo.allocationSize = blockSize;
      7625  VkDeviceMemory mem = VK_NULL_HANDLE;
      7626  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
      7627  if(res < 0)
      7628  {
      7629  return res;
      7630  }
      7631 
      7632  // New VkDeviceMemory successfully created.
      7633 
      7634  // Create new Allocation for it.
      7635  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
      7636  pBlock->Init(
      7637  m_MemoryTypeIndex,
      7638  mem,
      7639  allocInfo.allocationSize,
      7640  m_NextBlockId++);
      7641 
      7642  m_Blocks.push_back(pBlock);
      7643  if(pNewBlockIndex != VMA_NULL)
      7644  {
      7645  *pNewBlockIndex = m_Blocks.size() - 1;
      7646  }
      7647 
      7648  return VK_SUCCESS;
      7649 }
      7650 
      7651 #if VMA_STATS_STRING_ENABLED
      7652 
      7653 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
      7654 {
      7655  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7656 
      7657  json.BeginObject();
      7658 
      7659  if(m_IsCustomPool)
      7660  {
      7661  json.WriteString("MemoryTypeIndex");
      7662  json.WriteNumber(m_MemoryTypeIndex);
      7663 
      7664  json.WriteString("BlockSize");
      7665  json.WriteNumber(m_PreferredBlockSize);
      7666 
      7667  json.WriteString("BlockCount");
      7668  json.BeginObject(true);
      7669  if(m_MinBlockCount > 0)
      7670  {
      7671  json.WriteString("Min");
      7672  json.WriteNumber((uint64_t)m_MinBlockCount);
      7673  }
      7674  if(m_MaxBlockCount < SIZE_MAX)
      7675  {
      7676  json.WriteString("Max");
      7677  json.WriteNumber((uint64_t)m_MaxBlockCount);
      7678  }
      7679  json.WriteString("Cur");
      7680  json.WriteNumber((uint64_t)m_Blocks.size());
      7681  json.EndObject();
      7682 
      7683  if(m_FrameInUseCount > 0)
      7684  {
      7685  json.WriteString("FrameInUseCount");
      7686  json.WriteNumber(m_FrameInUseCount);
      7687  }
      7688  }
      7689  else
      7690  {
      7691  json.WriteString("PreferredBlockSize");
      7692  json.WriteNumber(m_PreferredBlockSize);
      7693  }
      7694 
      7695  json.WriteString("Blocks");
      7696  json.BeginObject();
      7697  for(size_t i = 0; i < m_Blocks.size(); ++i)
      7698  {
      7699  json.BeginString();
      7700  json.ContinueString(m_Blocks[i]->GetId());
      7701  json.EndString();
      7702 
      7703  m_Blocks[i]->m_Metadata.PrintDetailedMap(json);
      7704  }
      7705  json.EndObject();
      7706 
      7707  json.EndObject();
      7708 }
      7709 
      7710 #endif // #if VMA_STATS_STRING_ENABLED
      7711 
      7712 VmaDefragmentator* VmaBlockVector::EnsureDefragmentator(
      7713  VmaAllocator hAllocator,
      7714  uint32_t currentFrameIndex)
      7715 {
      7716  if(m_pDefragmentator == VMA_NULL)
      7717  {
      7718  m_pDefragmentator = vma_new(m_hAllocator, VmaDefragmentator)(
      7719  hAllocator,
      7720  this,
      7721  currentFrameIndex);
      7722  }
      7723 
      7724  return m_pDefragmentator;
      7725 }
      7726 
      7727 VkResult VmaBlockVector::Defragment(
      7728  VmaDefragmentationStats* pDefragmentationStats,
      7729  VkDeviceSize& maxBytesToMove,
      7730  uint32_t& maxAllocationsToMove)
      7731 {
      7732  if(m_pDefragmentator == VMA_NULL)
      7733  {
      7734  return VK_SUCCESS;
      7735  }
      7736 
      7737  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7738 
      7739  // Defragment.
      7740  VkResult result = m_pDefragmentator->Defragment(maxBytesToMove, maxAllocationsToMove);
      7741 
      7742  // Accumulate statistics.
      7743  if(pDefragmentationStats != VMA_NULL)
      7744  {
      7745  const VkDeviceSize bytesMoved = m_pDefragmentator->GetBytesMoved();
      7746  const uint32_t allocationsMoved = m_pDefragmentator->GetAllocationsMoved();
      7747  pDefragmentationStats->bytesMoved += bytesMoved;
      7748  pDefragmentationStats->allocationsMoved += allocationsMoved;
      7749  VMA_ASSERT(bytesMoved <= maxBytesToMove);
      7750  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
      7751  maxBytesToMove -= bytesMoved;
      7752  maxAllocationsToMove -= allocationsMoved;
      7753  }
      7754 
      7755  // Free empty blocks.
      7756  m_HasEmptyBlock = false;
      7757  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      7758  {
      7759  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      7760  if(pBlock->m_Metadata.IsEmpty())
      7761  {
      7762  if(m_Blocks.size() > m_MinBlockCount)
      7763  {
      7764  if(pDefragmentationStats != VMA_NULL)
      7765  {
      7766  ++pDefragmentationStats->deviceMemoryBlocksFreed;
      7767  pDefragmentationStats->bytesFreed += pBlock->m_Metadata.GetSize();
      7768  }
      7769 
      7770  VmaVectorRemove(m_Blocks, blockIndex);
      7771  pBlock->Destroy(m_hAllocator);
      7772  vma_delete(m_hAllocator, pBlock);
      7773  }
      7774  else
      7775  {
      7776  m_HasEmptyBlock = true;
      7777  }
      7778  }
      7779  }
      7780 
      7781  return result;
      7782 }
      7783 
      7784 void VmaBlockVector::DestroyDefragmentator()
      7785 {
      7786  if(m_pDefragmentator != VMA_NULL)
      7787  {
      7788  vma_delete(m_hAllocator, m_pDefragmentator);
      7789  m_pDefragmentator = VMA_NULL;
      7790  }
      7791 }
      7792 
      7793 void VmaBlockVector::MakePoolAllocationsLost(
      7794  uint32_t currentFrameIndex,
      7795  size_t* pLostAllocationCount)
      7796 {
      7797  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7798  size_t lostAllocationCount = 0;
      7799  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7800  {
      7801  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7802  VMA_ASSERT(pBlock);
      7803  lostAllocationCount += pBlock->m_Metadata.MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
      7804  }
      7805  if(pLostAllocationCount != VMA_NULL)
      7806  {
      7807  *pLostAllocationCount = lostAllocationCount;
      7808  }
      7809 }
      7810 
      7811 VkResult VmaBlockVector::CheckCorruption()
      7812 {
      7813  if(!IsCorruptionDetectionEnabled())
      7814  {
      7815  return VK_ERROR_FEATURE_NOT_PRESENT;
      7816  }
      7817 
      7818  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7819  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7820  {
      7821  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7822  VMA_ASSERT(pBlock);
      7823  VkResult res = pBlock->CheckCorruption(m_hAllocator);
      7824  if(res != VK_SUCCESS)
      7825  {
      7826  return res;
      7827  }
      7828  }
      7829  return VK_SUCCESS;
      7830 }
      7831 
      7832 void VmaBlockVector::AddStats(VmaStats* pStats)
      7833 {
      7834  const uint32_t memTypeIndex = m_MemoryTypeIndex;
      7835  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
      7836 
      7837  VmaMutexLock lock(m_Mutex, m_hAllocator->m_UseMutex);
      7838 
      7839  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      7840  {
      7841  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      7842  VMA_ASSERT(pBlock);
      7843  VMA_HEAVY_ASSERT(pBlock->Validate());
      7844  VmaStatInfo allocationStatInfo;
      7845  pBlock->m_Metadata.CalcAllocationStatInfo(allocationStatInfo);
      7846  VmaAddStatInfo(pStats->total, allocationStatInfo);
      7847  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      7848  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      7849  }
      7850 }
      7851 
      7853 // VmaDefragmentator members definition
      7854 
      7855 VmaDefragmentator::VmaDefragmentator(
      7856  VmaAllocator hAllocator,
      7857  VmaBlockVector* pBlockVector,
      7858  uint32_t currentFrameIndex) :
      7859  m_hAllocator(hAllocator),
      7860  m_pBlockVector(pBlockVector),
      7861  m_CurrentFrameIndex(currentFrameIndex),
      7862  m_BytesMoved(0),
      7863  m_AllocationsMoved(0),
      7864  m_Allocations(VmaStlAllocator<AllocationInfo>(hAllocator->GetAllocationCallbacks())),
      7865  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
      7866 {
      7867 }
      7868 
      7869 VmaDefragmentator::~VmaDefragmentator()
      7870 {
      7871  for(size_t i = m_Blocks.size(); i--; )
      7872  {
      7873  vma_delete(m_hAllocator, m_Blocks[i]);
      7874  }
      7875 }
      7876 
      7877 void VmaDefragmentator::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
      7878 {
      7879  AllocationInfo allocInfo;
      7880  allocInfo.m_hAllocation = hAlloc;
      7881  allocInfo.m_pChanged = pChanged;
      7882  m_Allocations.push_back(allocInfo);
      7883 }
      7884 
      7885 VkResult VmaDefragmentator::BlockInfo::EnsureMapping(VmaAllocator hAllocator, void** ppMappedData)
      7886 {
      7887  // It has already been mapped for defragmentation.
      7888  if(m_pMappedDataForDefragmentation)
      7889  {
      7890  *ppMappedData = m_pMappedDataForDefragmentation;
      7891  return VK_SUCCESS;
      7892  }
      7893 
      7894  // It is originally mapped.
      7895  if(m_pBlock->GetMappedData())
      7896  {
      7897  *ppMappedData = m_pBlock->GetMappedData();
      7898  return VK_SUCCESS;
      7899  }
      7900 
      7901  // Map on first usage.
      7902  VkResult res = m_pBlock->Map(hAllocator, 1, &m_pMappedDataForDefragmentation);
      7903  *ppMappedData = m_pMappedDataForDefragmentation;
      7904  return res;
      7905 }
      7906 
      7907 void VmaDefragmentator::BlockInfo::Unmap(VmaAllocator hAllocator)
      7908 {
      7909  if(m_pMappedDataForDefragmentation != VMA_NULL)
      7910  {
      7911  m_pBlock->Unmap(hAllocator, 1);
      7912  }
      7913 }
      7914 
      7915 VkResult VmaDefragmentator::DefragmentRound(
      7916  VkDeviceSize maxBytesToMove,
      7917  uint32_t maxAllocationsToMove)
      7918 {
      7919  if(m_Blocks.empty())
      7920  {
      7921  return VK_SUCCESS;
      7922  }
      7923 
      7924  size_t srcBlockIndex = m_Blocks.size() - 1;
      7925  size_t srcAllocIndex = SIZE_MAX;
      7926  for(;;)
      7927  {
      7928  // 1. Find next allocation to move.
      7929  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
      7930  // 1.2. Then start from last to first m_Allocations - they are sorted from largest to smallest.
      7931  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
      7932  {
      7933  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
      7934  {
      7935  // Finished: no more allocations to process.
      7936  if(srcBlockIndex == 0)
      7937  {
      7938  return VK_SUCCESS;
      7939  }
      7940  else
      7941  {
      7942  --srcBlockIndex;
      7943  srcAllocIndex = SIZE_MAX;
      7944  }
      7945  }
      7946  else
      7947  {
      7948  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
      7949  }
      7950  }
      7951 
      7952  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
      7953  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
      7954 
      7955  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
      7956  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
      7957  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
      7958  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
      7959 
      7960  // 2. Try to find new place for this allocation in preceding or current block.
      7961  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
      7962  {
      7963  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
      7964  VmaAllocationRequest dstAllocRequest;
      7965  if(pDstBlockInfo->m_pBlock->m_Metadata.CreateAllocationRequest(
      7966  m_CurrentFrameIndex,
      7967  m_pBlockVector->GetFrameInUseCount(),
      7968  m_pBlockVector->GetBufferImageGranularity(),
      7969  size,
      7970  alignment,
      7971  suballocType,
      7972  false, // canMakeOtherLost
      7973  &dstAllocRequest) &&
      7974  MoveMakesSense(
      7975  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
      7976  {
      7977  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
      7978 
      7979  // Reached limit on number of allocations or bytes to move.
      7980  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
      7981  (m_BytesMoved + size > maxBytesToMove))
      7982  {
      7983  return VK_INCOMPLETE;
      7984  }
      7985 
      7986  void* pDstMappedData = VMA_NULL;
      7987  VkResult res = pDstBlockInfo->EnsureMapping(m_hAllocator, &pDstMappedData);
      7988  if(res != VK_SUCCESS)
      7989  {
      7990  return res;
      7991  }
      7992 
      7993  void* pSrcMappedData = VMA_NULL;
      7994  res = pSrcBlockInfo->EnsureMapping(m_hAllocator, &pSrcMappedData);
      7995  if(res != VK_SUCCESS)
      7996  {
      7997  return res;
      7998  }
      7999 
      8000  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
      8001  memcpy(
      8002  reinterpret_cast<char*>(pDstMappedData) + dstAllocRequest.offset,
      8003  reinterpret_cast<char*>(pSrcMappedData) + srcOffset,
      8004  static_cast<size_t>(size));
      8005 
      8006  if(VMA_DEBUG_MARGIN > 0)
      8007  {
      8008  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset - VMA_DEBUG_MARGIN);
      8009  VmaWriteMagicValue(pDstMappedData, dstAllocRequest.offset + size);
      8010  }
      8011 
      8012  pDstBlockInfo->m_pBlock->m_Metadata.Alloc(dstAllocRequest, suballocType, size, allocInfo.m_hAllocation);
      8013  pSrcBlockInfo->m_pBlock->m_Metadata.FreeAtOffset(srcOffset);
      8014 
      8015  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
      8016 
      8017  if(allocInfo.m_pChanged != VMA_NULL)
      8018  {
      8019  *allocInfo.m_pChanged = VK_TRUE;
      8020  }
      8021 
      8022  ++m_AllocationsMoved;
      8023  m_BytesMoved += size;
      8024 
      8025  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
      8026 
      8027  break;
      8028  }
      8029  }
      8030 
      8031  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
      8032 
      8033  if(srcAllocIndex > 0)
      8034  {
      8035  --srcAllocIndex;
      8036  }
      8037  else
      8038  {
      8039  if(srcBlockIndex > 0)
      8040  {
      8041  --srcBlockIndex;
      8042  srcAllocIndex = SIZE_MAX;
      8043  }
      8044  else
      8045  {
      8046  return VK_SUCCESS;
      8047  }
      8048  }
      8049  }
      8050 }
      8051 
      8052 VkResult VmaDefragmentator::Defragment(
      8053  VkDeviceSize maxBytesToMove,
      8054  uint32_t maxAllocationsToMove)
      8055 {
      8056  if(m_Allocations.empty())
      8057  {
      8058  return VK_SUCCESS;
      8059  }
      8060 
      8061  // Create block info for each block.
      8062  const size_t blockCount = m_pBlockVector->m_Blocks.size();
      8063  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      8064  {
      8065  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
      8066  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
      8067  m_Blocks.push_back(pBlockInfo);
      8068  }
      8069 
      8070  // Sort them by m_pBlock pointer value.
      8071  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
      8072 
      8073  // Move allocation infos from m_Allocations to appropriate m_Blocks[memTypeIndex].m_Allocations.
      8074  for(size_t blockIndex = 0, allocCount = m_Allocations.size(); blockIndex < allocCount; ++blockIndex)
      8075  {
      8076  AllocationInfo& allocInfo = m_Allocations[blockIndex];
      8077  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
      8078  if(allocInfo.m_hAllocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
      8079  {
      8080  VmaDeviceMemoryBlock* pBlock = allocInfo.m_hAllocation->GetBlock();
      8081  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
      8082  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
      8083  {
      8084  (*it)->m_Allocations.push_back(allocInfo);
      8085  }
      8086  else
      8087  {
      8088  VMA_ASSERT(0);
      8089  }
      8090  }
      8091  }
      8092  m_Allocations.clear();
      8093 
      8094  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      8095  {
      8096  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
      8097  pBlockInfo->CalcHasNonMovableAllocations();
      8098  pBlockInfo->SortAllocationsBySizeDescecnding();
      8099  }
      8100 
      8101  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
      8102  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
      8103 
      8104  // Execute defragmentation rounds (the main part).
      8105  VkResult result = VK_SUCCESS;
      8106  for(size_t round = 0; (round < 2) && (result == VK_SUCCESS); ++round)
      8107  {
      8108  result = DefragmentRound(maxBytesToMove, maxAllocationsToMove);
      8109  }
      8110 
      8111  // Unmap blocks that were mapped for defragmentation.
      8112  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      8113  {
      8114  m_Blocks[blockIndex]->Unmap(m_hAllocator);
      8115  }
      8116 
      8117  return result;
      8118 }
      8119 
      8120 bool VmaDefragmentator::MoveMakesSense(
      8121  size_t dstBlockIndex, VkDeviceSize dstOffset,
      8122  size_t srcBlockIndex, VkDeviceSize srcOffset)
      8123 {
      8124  if(dstBlockIndex < srcBlockIndex)
      8125  {
      8126  return true;
      8127  }
      8128  if(dstBlockIndex > srcBlockIndex)
      8129  {
      8130  return false;
      8131  }
      8132  if(dstOffset < srcOffset)
      8133  {
      8134  return true;
      8135  }
      8136  return false;
      8137 }
      8138 
      8140 // VmaRecorder
      8141 
      8142 #if VMA_RECORDING_ENABLED
      8143 
      8144 VmaRecorder::VmaRecorder() :
      8145  m_UseMutex(true),
      8146  m_Flags(0),
      8147  m_File(VMA_NULL),
      8148  m_Freq(INT64_MAX),
      8149  m_StartCounter(INT64_MAX)
      8150 {
      8151 }
      8152 
      8153 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
      8154 {
      8155  m_UseMutex = useMutex;
      8156  m_Flags = settings.flags;
      8157 
      8158  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
      8159  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
      8160 
      8161  // Open file for writing.
      8162  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
      8163  if(err != 0)
      8164  {
      8165  return VK_ERROR_INITIALIZATION_FAILED;
      8166  }
      8167 
      8168  // Write header.
      8169  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
      8170  fprintf(m_File, "%s\n", "1,3");
      8171 
      8172  return VK_SUCCESS;
      8173 }
      8174 
      8175 VmaRecorder::~VmaRecorder()
      8176 {
      8177  if(m_File != VMA_NULL)
      8178  {
      8179  fclose(m_File);
      8180  }
      8181 }
      8182 
      8183 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
      8184 {
      8185  CallParams callParams;
      8186  GetBasicParams(callParams);
      8187 
      8188  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8189  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
      8190  Flush();
      8191 }
      8192 
      8193 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
      8194 {
      8195  CallParams callParams;
      8196  GetBasicParams(callParams);
      8197 
      8198  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8199  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
      8200  Flush();
      8201 }
      8202 
      8203 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
      8204 {
      8205  CallParams callParams;
      8206  GetBasicParams(callParams);
      8207 
      8208  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8209  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
      8210  createInfo.memoryTypeIndex,
      8211  createInfo.flags,
      8212  createInfo.blockSize,
      8213  createInfo.minBlockCount,
      8214  createInfo.maxBlockCount,
      8215  createInfo.frameInUseCount,
      8216  pool);
      8217  Flush();
      8218 }
      8219 
      8220 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
      8221 {
      8222  CallParams callParams;
      8223  GetBasicParams(callParams);
      8224 
      8225  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8226  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
      8227  pool);
      8228  Flush();
      8229 }
      8230 
      8231 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
      8232  const VkMemoryRequirements& vkMemReq,
      8233  const VmaAllocationCreateInfo& createInfo,
      8234  VmaAllocation allocation)
      8235 {
      8236  CallParams callParams;
      8237  GetBasicParams(callParams);
      8238 
      8239  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8240  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      8241  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      8242  vkMemReq.size,
      8243  vkMemReq.alignment,
      8244  vkMemReq.memoryTypeBits,
      8245  createInfo.flags,
      8246  createInfo.usage,
      8247  createInfo.requiredFlags,
      8248  createInfo.preferredFlags,
      8249  createInfo.memoryTypeBits,
      8250  createInfo.pool,
      8251  allocation,
      8252  userDataStr.GetString());
      8253  Flush();
      8254 }
      8255 
      8256 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
      8257  const VkMemoryRequirements& vkMemReq,
      8258  bool requiresDedicatedAllocation,
      8259  bool prefersDedicatedAllocation,
      8260  const VmaAllocationCreateInfo& createInfo,
      8261  VmaAllocation allocation)
      8262 {
      8263  CallParams callParams;
      8264  GetBasicParams(callParams);
      8265 
      8266  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8267  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      8268  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,
      8269  vkMemReq.size,
      8270  vkMemReq.alignment,
      8271  vkMemReq.memoryTypeBits,
      8272  requiresDedicatedAllocation ? 1 : 0,
      8273  prefersDedicatedAllocation ? 1 : 0,
      8274  createInfo.flags,
      8275  createInfo.usage,
      8276  createInfo.requiredFlags,
      8277  createInfo.preferredFlags,
      8278  createInfo.memoryTypeBits,
      8279  createInfo.pool,
      8280  allocation,
      8281  userDataStr.GetString());
      8282  Flush();
      8283 }
      8284 
      8285 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
      8286  const VkMemoryRequirements& vkMemReq,
      8287  bool requiresDedicatedAllocation,
      8288  bool prefersDedicatedAllocation,
      8289  const VmaAllocationCreateInfo& createInfo,
      8290  VmaAllocation allocation)
      8291 {
      8292  CallParams callParams;
      8293  GetBasicParams(callParams);
      8294 
      8295  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8296  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      8297  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,
      8298  vkMemReq.size,
      8299  vkMemReq.alignment,
      8300  vkMemReq.memoryTypeBits,
      8301  requiresDedicatedAllocation ? 1 : 0,
      8302  prefersDedicatedAllocation ? 1 : 0,
      8303  createInfo.flags,
      8304  createInfo.usage,
      8305  createInfo.requiredFlags,
      8306  createInfo.preferredFlags,
      8307  createInfo.memoryTypeBits,
      8308  createInfo.pool,
      8309  allocation,
      8310  userDataStr.GetString());
      8311  Flush();
      8312 }
      8313 
      8314 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
      8315  VmaAllocation allocation)
      8316 {
      8317  CallParams callParams;
      8318  GetBasicParams(callParams);
      8319 
      8320  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8321  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      8322  allocation);
      8323  Flush();
      8324 }
      8325 
      8326 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
      8327  VmaAllocation allocation,
      8328  const void* pUserData)
      8329 {
      8330  CallParams callParams;
      8331  GetBasicParams(callParams);
      8332 
      8333  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8334  UserDataString userDataStr(
      8335  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
      8336  pUserData);
      8337  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      8338  allocation,
      8339  userDataStr.GetString());
      8340  Flush();
      8341 }
      8342 
      8343 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
      8344  VmaAllocation allocation)
      8345 {
      8346  CallParams callParams;
      8347  GetBasicParams(callParams);
      8348 
      8349  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8350  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
      8351  allocation);
      8352  Flush();
      8353 }
      8354 
      8355 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
      8356  VmaAllocation allocation)
      8357 {
      8358  CallParams callParams;
      8359  GetBasicParams(callParams);
      8360 
      8361  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8362  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      8363  allocation);
      8364  Flush();
      8365 }
      8366 
      8367 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
      8368  VmaAllocation allocation)
      8369 {
      8370  CallParams callParams;
      8371  GetBasicParams(callParams);
      8372 
      8373  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8374  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      8375  allocation);
      8376  Flush();
      8377 }
      8378 
      8379 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
      8380  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      8381 {
      8382  CallParams callParams;
      8383  GetBasicParams(callParams);
      8384 
      8385  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8386  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
      8387  allocation,
      8388  offset,
      8389  size);
      8390  Flush();
      8391 }
      8392 
      8393 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
      8394  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      8395 {
      8396  CallParams callParams;
      8397  GetBasicParams(callParams);
      8398 
      8399  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8400  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
      8401  allocation,
      8402  offset,
      8403  size);
      8404  Flush();
      8405 }
      8406 
      8407 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
      8408  const VkBufferCreateInfo& bufCreateInfo,
      8409  const VmaAllocationCreateInfo& allocCreateInfo,
      8410  VmaAllocation allocation)
      8411 {
      8412  CallParams callParams;
      8413  GetBasicParams(callParams);
      8414 
      8415  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8416  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
      8417  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,
      8418  bufCreateInfo.flags,
      8419  bufCreateInfo.size,
      8420  bufCreateInfo.usage,
      8421  bufCreateInfo.sharingMode,
      8422  allocCreateInfo.flags,
      8423  allocCreateInfo.usage,
      8424  allocCreateInfo.requiredFlags,
      8425  allocCreateInfo.preferredFlags,
      8426  allocCreateInfo.memoryTypeBits,
      8427  allocCreateInfo.pool,
      8428  allocation,
      8429  userDataStr.GetString());
      8430  Flush();
      8431 }
      8432 
      8433 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
      8434  const VkImageCreateInfo& imageCreateInfo,
      8435  const VmaAllocationCreateInfo& allocCreateInfo,
      8436  VmaAllocation allocation)
      8437 {
      8438  CallParams callParams;
      8439  GetBasicParams(callParams);
      8440 
      8441  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8442  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
      8443  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,
      8444  imageCreateInfo.flags,
      8445  imageCreateInfo.imageType,
      8446  imageCreateInfo.format,
      8447  imageCreateInfo.extent.width,
      8448  imageCreateInfo.extent.height,
      8449  imageCreateInfo.extent.depth,
      8450  imageCreateInfo.mipLevels,
      8451  imageCreateInfo.arrayLayers,
      8452  imageCreateInfo.samples,
      8453  imageCreateInfo.tiling,
      8454  imageCreateInfo.usage,
      8455  imageCreateInfo.sharingMode,
      8456  imageCreateInfo.initialLayout,
      8457  allocCreateInfo.flags,
      8458  allocCreateInfo.usage,
      8459  allocCreateInfo.requiredFlags,
      8460  allocCreateInfo.preferredFlags,
      8461  allocCreateInfo.memoryTypeBits,
      8462  allocCreateInfo.pool,
      8463  allocation,
      8464  userDataStr.GetString());
      8465  Flush();
      8466 }
      8467 
      8468 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
      8469  VmaAllocation allocation)
      8470 {
      8471  CallParams callParams;
      8472  GetBasicParams(callParams);
      8473 
      8474  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8475  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
      8476  allocation);
      8477  Flush();
      8478 }
      8479 
      8480 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
      8481  VmaAllocation allocation)
      8482 {
      8483  CallParams callParams;
      8484  GetBasicParams(callParams);
      8485 
      8486  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8487  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
      8488  allocation);
      8489  Flush();
      8490 }
      8491 
      8492 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
      8493  VmaAllocation allocation)
      8494 {
      8495  CallParams callParams;
      8496  GetBasicParams(callParams);
      8497 
      8498  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8499  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
      8500  allocation);
      8501  Flush();
      8502 }
      8503 
      8504 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
      8505  VmaAllocation allocation)
      8506 {
      8507  CallParams callParams;
      8508  GetBasicParams(callParams);
      8509 
      8510  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8511  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
      8512  allocation);
      8513  Flush();
      8514 }
      8515 
      8516 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
      8517  VmaPool pool)
      8518 {
      8519  CallParams callParams;
      8520  GetBasicParams(callParams);
      8521 
      8522  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      8523  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
      8524  pool);
      8525  Flush();
      8526 }
      8527 
      8528 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
      8529 {
      8530  if(pUserData != VMA_NULL)
      8531  {
      8532  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
      8533  {
      8534  m_Str = (const char*)pUserData;
      8535  }
      8536  else
      8537  {
      8538  sprintf_s(m_PtrStr, "%p", pUserData);
      8539  m_Str = m_PtrStr;
      8540  }
      8541  }
      8542  else
      8543  {
      8544  m_Str = "";
      8545  }
      8546 }
      8547 
      8548 void VmaRecorder::WriteConfiguration(
      8549  const VkPhysicalDeviceProperties& devProps,
      8550  const VkPhysicalDeviceMemoryProperties& memProps,
      8551  bool dedicatedAllocationExtensionEnabled)
      8552 {
      8553  fprintf(m_File, "Config,Begin\n");
      8554 
      8555  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
      8556  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
      8557  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
      8558  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
      8559  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
      8560  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
      8561 
      8562  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
      8563  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
      8564  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
      8565 
      8566  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
      8567  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
      8568  {
      8569  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
      8570  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
      8571  }
      8572  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
      8573  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
      8574  {
      8575  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
      8576  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
      8577  }
      8578 
      8579  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
      8580 
      8581  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
      8582  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
      8583  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
      8584  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
      8585  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
      8586  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
      8587  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
      8588  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
      8589  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      8590 
      8591  fprintf(m_File, "Config,End\n");
      8592 }
      8593 
      8594 void VmaRecorder::GetBasicParams(CallParams& outParams)
      8595 {
      8596  outParams.threadId = GetCurrentThreadId();
      8597 
      8598  LARGE_INTEGER counter;
      8599  QueryPerformanceCounter(&counter);
      8600  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
      8601 }
      8602 
      8603 void VmaRecorder::Flush()
      8604 {
      8605  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
      8606  {
      8607  fflush(m_File);
      8608  }
      8609 }
      8610 
      8611 #endif // #if VMA_RECORDING_ENABLED
      8612 
      8614 // VmaAllocator_T
      8615 
      8616 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
      8617  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
      8618  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
      8619  m_hDevice(pCreateInfo->device),
      8620  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
      8621  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
      8622  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
      8623  m_PreferredLargeHeapBlockSize(0),
      8624  m_PhysicalDevice(pCreateInfo->physicalDevice),
      8625  m_CurrentFrameIndex(0),
      8626  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
      8627  m_NextPoolId(0)
      8628 #if VMA_RECORDING_ENABLED
      8629  ,m_pRecorder(VMA_NULL)
      8630 #endif
      8631 {
      8632  if(VMA_DEBUG_DETECT_CORRUPTION)
      8633  {
      8634  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
      8635  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
      8636  }
      8637 
      8638  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
      8639 
      8640 #if !(VMA_DEDICATED_ALLOCATION)
      8641  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
      8642  {
      8643  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
      8644  }
      8645 #endif
      8646 
      8647  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
      8648  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
      8649  memset(&m_MemProps, 0, sizeof(m_MemProps));
      8650 
      8651  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
      8652  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
      8653 
      8654  for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
      8655  {
      8656  m_HeapSizeLimit[i] = VK_WHOLE_SIZE;
      8657  }
      8658 
      8659  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
      8660  {
      8661  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
      8662  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
      8663  }
      8664 
      8665  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
      8666 
      8667  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
      8668  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
      8669 
      8670  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
      8671  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      8672 
      8673  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
      8674  {
      8675  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
      8676  {
      8677  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
      8678  if(limit != VK_WHOLE_SIZE)
      8679  {
      8680  m_HeapSizeLimit[heapIndex] = limit;
      8681  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
      8682  {
      8683  m_MemProps.memoryHeaps[heapIndex].size = limit;
      8684  }
      8685  }
      8686  }
      8687  }
      8688 
      8689  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      8690  {
      8691  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
      8692 
      8693  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
      8694  this,
      8695  memTypeIndex,
      8696  preferredBlockSize,
      8697  0,
      8698  SIZE_MAX,
      8699  GetBufferImageGranularity(),
      8700  pCreateInfo->frameInUseCount,
      8701  false); // isCustomPool
      8702  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
      8703  // becase minBlockCount is 0.
      8704  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
      8705 
      8706  }
      8707 }
      8708 
      8709 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
      8710 {
      8711  VkResult res = VK_SUCCESS;
      8712 
      8713  if(pCreateInfo->pRecordSettings != VMA_NULL &&
      8714  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
      8715  {
      8716 #if VMA_RECORDING_ENABLED
      8717  m_pRecorder = vma_new(this, VmaRecorder)();
      8718  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
      8719  if(res != VK_SUCCESS)
      8720  {
      8721  return res;
      8722  }
      8723  m_pRecorder->WriteConfiguration(
      8724  m_PhysicalDeviceProperties,
      8725  m_MemProps,
      8726  m_UseKhrDedicatedAllocation);
      8727  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
      8728 #else
      8729  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
      8730  return VK_ERROR_FEATURE_NOT_PRESENT;
      8731 #endif
      8732  }
      8733 
      8734  return res;
      8735 }
      8736 
      8737 VmaAllocator_T::~VmaAllocator_T()
      8738 {
      8739 #if VMA_RECORDING_ENABLED
      8740  if(m_pRecorder != VMA_NULL)
      8741  {
      8742  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
      8743  vma_delete(this, m_pRecorder);
      8744  }
      8745 #endif
      8746 
      8747  VMA_ASSERT(m_Pools.empty());
      8748 
      8749  for(size_t i = GetMemoryTypeCount(); i--; )
      8750  {
      8751  vma_delete(this, m_pDedicatedAllocations[i]);
      8752  vma_delete(this, m_pBlockVectors[i]);
      8753  }
      8754 }
      8755 
      8756 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
      8757 {
      8758 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      8759  m_VulkanFunctions.vkGetPhysicalDeviceProperties = &vkGetPhysicalDeviceProperties;
      8760  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = &vkGetPhysicalDeviceMemoryProperties;
      8761  m_VulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
      8762  m_VulkanFunctions.vkFreeMemory = &vkFreeMemory;
      8763  m_VulkanFunctions.vkMapMemory = &vkMapMemory;
      8764  m_VulkanFunctions.vkUnmapMemory = &vkUnmapMemory;
      8765  m_VulkanFunctions.vkFlushMappedMemoryRanges = &vkFlushMappedMemoryRanges;
      8766  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = &vkInvalidateMappedMemoryRanges;
      8767  m_VulkanFunctions.vkBindBufferMemory = &vkBindBufferMemory;
      8768  m_VulkanFunctions.vkBindImageMemory = &vkBindImageMemory;
      8769  m_VulkanFunctions.vkGetBufferMemoryRequirements = &vkGetBufferMemoryRequirements;
      8770  m_VulkanFunctions.vkGetImageMemoryRequirements = &vkGetImageMemoryRequirements;
      8771  m_VulkanFunctions.vkCreateBuffer = &vkCreateBuffer;
      8772  m_VulkanFunctions.vkDestroyBuffer = &vkDestroyBuffer;
      8773  m_VulkanFunctions.vkCreateImage = &vkCreateImage;
      8774  m_VulkanFunctions.vkDestroyImage = &vkDestroyImage;
      8775 #if VMA_DEDICATED_ALLOCATION
      8776  if(m_UseKhrDedicatedAllocation)
      8777  {
      8778  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
      8779  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
      8780  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
      8781  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
      8782  }
      8783 #endif // #if VMA_DEDICATED_ALLOCATION
      8784 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      8785 
      8786 #define VMA_COPY_IF_NOT_NULL(funcName) \
      8787  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
      8788 
      8789  if(pVulkanFunctions != VMA_NULL)
      8790  {
      8791  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
      8792  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
      8793  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
      8794  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
      8795  VMA_COPY_IF_NOT_NULL(vkMapMemory);
      8796  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
      8797  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
      8798  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
      8799  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
      8800  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
      8801  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
      8802  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
      8803  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
      8804  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
      8805  VMA_COPY_IF_NOT_NULL(vkCreateImage);
      8806  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
      8807 #if VMA_DEDICATED_ALLOCATION
      8808  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
      8809  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
      8810 #endif
      8811  }
      8812 
      8813 #undef VMA_COPY_IF_NOT_NULL
      8814 
      8815  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
      8816  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
      8817  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
      8818  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
      8819  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
      8820  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
      8821  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
      8822  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
      8823  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
      8824  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
      8825  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
      8826  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
      8827  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
      8828  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
      8829  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
      8830  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
      8831  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
      8832  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
      8833 #if VMA_DEDICATED_ALLOCATION
      8834  if(m_UseKhrDedicatedAllocation)
      8835  {
      8836  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
      8837  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
      8838  }
      8839 #endif
      8840 }
      8841 
      8842 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
      8843 {
      8844  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      8845  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
      8846  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
      8847  return isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize;
      8848 }
      8849 
      8850 VkResult VmaAllocator_T::AllocateMemoryOfType(
      8851  VkDeviceSize size,
      8852  VkDeviceSize alignment,
      8853  bool dedicatedAllocation,
      8854  VkBuffer dedicatedBuffer,
      8855  VkImage dedicatedImage,
      8856  const VmaAllocationCreateInfo& createInfo,
      8857  uint32_t memTypeIndex,
      8858  VmaSuballocationType suballocType,
      8859  VmaAllocation* pAllocation)
      8860 {
      8861  VMA_ASSERT(pAllocation != VMA_NULL);
      8862  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, Size=%llu", memTypeIndex, vkMemReq.size);
      8863 
      8864  VmaAllocationCreateInfo finalCreateInfo = createInfo;
      8865 
      8866  // If memory type is not HOST_VISIBLE, disable MAPPED.
      8867  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      8868  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      8869  {
      8870  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
      8871  }
      8872 
      8873  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
      8874  VMA_ASSERT(blockVector);
      8875 
      8876  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
      8877  bool preferDedicatedMemory =
      8878  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
      8879  dedicatedAllocation ||
      8880  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
      8881  size > preferredBlockSize / 2;
      8882 
      8883  if(preferDedicatedMemory &&
      8884  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
      8885  finalCreateInfo.pool == VK_NULL_HANDLE)
      8886  {
      8887  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
      8888  }
      8889 
      8890  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
      8891  {
      8892  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      8893  {
      8894  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8895  }
      8896  else
      8897  {
      8898  return AllocateDedicatedMemory(
      8899  size,
      8900  suballocType,
      8901  memTypeIndex,
      8902  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      8903  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      8904  finalCreateInfo.pUserData,
      8905  dedicatedBuffer,
      8906  dedicatedImage,
      8907  pAllocation);
      8908  }
      8909  }
      8910  else
      8911  {
      8912  VkResult res = blockVector->Allocate(
      8913  VK_NULL_HANDLE, // hCurrentPool
      8914  m_CurrentFrameIndex.load(),
      8915  size,
      8916  alignment,
      8917  finalCreateInfo,
      8918  suballocType,
      8919  pAllocation);
      8920  if(res == VK_SUCCESS)
      8921  {
      8922  return res;
      8923  }
      8924 
      8925  // 5. Try dedicated memory.
      8926  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      8927  {
      8928  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      8929  }
      8930  else
      8931  {
      8932  res = AllocateDedicatedMemory(
      8933  size,
      8934  suballocType,
      8935  memTypeIndex,
      8936  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      8937  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      8938  finalCreateInfo.pUserData,
      8939  dedicatedBuffer,
      8940  dedicatedImage,
      8941  pAllocation);
      8942  if(res == VK_SUCCESS)
      8943  {
      8944  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
      8945  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
      8946  return VK_SUCCESS;
      8947  }
      8948  else
      8949  {
      8950  // Everything failed: Return error code.
      8951  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      8952  return res;
      8953  }
      8954  }
      8955  }
      8956 }
      8957 
      8958 VkResult VmaAllocator_T::AllocateDedicatedMemory(
      8959  VkDeviceSize size,
      8960  VmaSuballocationType suballocType,
      8961  uint32_t memTypeIndex,
      8962  bool map,
      8963  bool isUserDataString,
      8964  void* pUserData,
      8965  VkBuffer dedicatedBuffer,
      8966  VkImage dedicatedImage,
      8967  VmaAllocation* pAllocation)
      8968 {
      8969  VMA_ASSERT(pAllocation);
      8970 
      8971  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      8972  allocInfo.memoryTypeIndex = memTypeIndex;
      8973  allocInfo.allocationSize = size;
      8974 
      8975 #if VMA_DEDICATED_ALLOCATION
      8976  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
      8977  if(m_UseKhrDedicatedAllocation)
      8978  {
      8979  if(dedicatedBuffer != VK_NULL_HANDLE)
      8980  {
      8981  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
      8982  dedicatedAllocInfo.buffer = dedicatedBuffer;
      8983  allocInfo.pNext = &dedicatedAllocInfo;
      8984  }
      8985  else if(dedicatedImage != VK_NULL_HANDLE)
      8986  {
      8987  dedicatedAllocInfo.image = dedicatedImage;
      8988  allocInfo.pNext = &dedicatedAllocInfo;
      8989  }
      8990  }
      8991 #endif // #if VMA_DEDICATED_ALLOCATION
      8992 
      8993  // Allocate VkDeviceMemory.
      8994  VkDeviceMemory hMemory = VK_NULL_HANDLE;
      8995  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
      8996  if(res < 0)
      8997  {
      8998  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      8999  return res;
      9000  }
      9001 
      9002  void* pMappedData = VMA_NULL;
      9003  if(map)
      9004  {
      9005  res = (*m_VulkanFunctions.vkMapMemory)(
      9006  m_hDevice,
      9007  hMemory,
      9008  0,
      9009  VK_WHOLE_SIZE,
      9010  0,
      9011  &pMappedData);
      9012  if(res < 0)
      9013  {
      9014  VMA_DEBUG_LOG(" vkMapMemory FAILED");
      9015  FreeVulkanMemory(memTypeIndex, size, hMemory);
      9016  return res;
      9017  }
      9018  }
      9019 
      9020  *pAllocation = vma_new(this, VmaAllocation_T)(m_CurrentFrameIndex.load(), isUserDataString);
      9021  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
      9022  (*pAllocation)->SetUserData(this, pUserData);
      9023  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      9024  {
      9025  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      9026  }
      9027 
      9028  // Register it in m_pDedicatedAllocations.
      9029  {
      9030  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      9031  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      9032  VMA_ASSERT(pDedicatedAllocations);
      9033  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, *pAllocation);
      9034  }
      9035 
      9036  VMA_DEBUG_LOG(" Allocated DedicatedMemory MemoryTypeIndex=#%u", memTypeIndex);
      9037 
      9038  return VK_SUCCESS;
      9039 }
      9040 
      9041 void VmaAllocator_T::GetBufferMemoryRequirements(
      9042  VkBuffer hBuffer,
      9043  VkMemoryRequirements& memReq,
      9044  bool& requiresDedicatedAllocation,
      9045  bool& prefersDedicatedAllocation) const
      9046 {
      9047 #if VMA_DEDICATED_ALLOCATION
      9048  if(m_UseKhrDedicatedAllocation)
      9049  {
      9050  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
      9051  memReqInfo.buffer = hBuffer;
      9052 
      9053  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      9054 
      9055  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      9056  memReq2.pNext = &memDedicatedReq;
      9057 
      9058  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      9059 
      9060  memReq = memReq2.memoryRequirements;
      9061  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      9062  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      9063  }
      9064  else
      9065 #endif // #if VMA_DEDICATED_ALLOCATION
      9066  {
      9067  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
      9068  requiresDedicatedAllocation = false;
      9069  prefersDedicatedAllocation = false;
      9070  }
      9071 }
      9072 
      9073 void VmaAllocator_T::GetImageMemoryRequirements(
      9074  VkImage hImage,
      9075  VkMemoryRequirements& memReq,
      9076  bool& requiresDedicatedAllocation,
      9077  bool& prefersDedicatedAllocation) const
      9078 {
      9079 #if VMA_DEDICATED_ALLOCATION
      9080  if(m_UseKhrDedicatedAllocation)
      9081  {
      9082  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
      9083  memReqInfo.image = hImage;
      9084 
      9085  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      9086 
      9087  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      9088  memReq2.pNext = &memDedicatedReq;
      9089 
      9090  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      9091 
      9092  memReq = memReq2.memoryRequirements;
      9093  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      9094  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      9095  }
      9096  else
      9097 #endif // #if VMA_DEDICATED_ALLOCATION
      9098  {
      9099  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
      9100  requiresDedicatedAllocation = false;
      9101  prefersDedicatedAllocation = false;
      9102  }
      9103 }
      9104 
      9105 VkResult VmaAllocator_T::AllocateMemory(
      9106  const VkMemoryRequirements& vkMemReq,
      9107  bool requiresDedicatedAllocation,
      9108  bool prefersDedicatedAllocation,
      9109  VkBuffer dedicatedBuffer,
      9110  VkImage dedicatedImage,
      9111  const VmaAllocationCreateInfo& createInfo,
      9112  VmaSuballocationType suballocType,
      9113  VmaAllocation* pAllocation)
      9114 {
      9115  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
      9116  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      9117  {
      9118  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
      9119  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9120  }
      9121  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      9122  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
      9123  {
      9124  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
      9125  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9126  }
      9127  if(requiresDedicatedAllocation)
      9128  {
      9129  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      9130  {
      9131  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
      9132  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9133  }
      9134  if(createInfo.pool != VK_NULL_HANDLE)
      9135  {
      9136  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
      9137  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9138  }
      9139  }
      9140  if((createInfo.pool != VK_NULL_HANDLE) &&
      9141  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
      9142  {
      9143  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
      9144  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9145  }
      9146 
      9147  if(createInfo.pool != VK_NULL_HANDLE)
      9148  {
      9149  const VkDeviceSize alignmentForPool = VMA_MAX(
      9150  vkMemReq.alignment,
      9151  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
      9152  return createInfo.pool->m_BlockVector.Allocate(
      9153  createInfo.pool,
      9154  m_CurrentFrameIndex.load(),
      9155  vkMemReq.size,
      9156  alignmentForPool,
      9157  createInfo,
      9158  suballocType,
      9159  pAllocation);
      9160  }
      9161  else
      9162  {
      9163  // Bit mask of memory Vulkan types acceptable for this allocation.
      9164  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
      9165  uint32_t memTypeIndex = UINT32_MAX;
      9166  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      9167  if(res == VK_SUCCESS)
      9168  {
      9169  VkDeviceSize alignmentForMemType = VMA_MAX(
      9170  vkMemReq.alignment,
      9171  GetMemoryTypeMinAlignment(memTypeIndex));
      9172 
      9173  res = AllocateMemoryOfType(
      9174  vkMemReq.size,
      9175  alignmentForMemType,
      9176  requiresDedicatedAllocation || prefersDedicatedAllocation,
      9177  dedicatedBuffer,
      9178  dedicatedImage,
      9179  createInfo,
      9180  memTypeIndex,
      9181  suballocType,
      9182  pAllocation);
      9183  // Succeeded on first try.
      9184  if(res == VK_SUCCESS)
      9185  {
      9186  return res;
      9187  }
      9188  // Allocation from this memory type failed. Try other compatible memory types.
      9189  else
      9190  {
      9191  for(;;)
      9192  {
      9193  // Remove old memTypeIndex from list of possibilities.
      9194  memoryTypeBits &= ~(1u << memTypeIndex);
      9195  // Find alternative memTypeIndex.
      9196  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      9197  if(res == VK_SUCCESS)
      9198  {
      9199  alignmentForMemType = VMA_MAX(
      9200  vkMemReq.alignment,
      9201  GetMemoryTypeMinAlignment(memTypeIndex));
      9202 
      9203  res = AllocateMemoryOfType(
      9204  vkMemReq.size,
      9205  alignmentForMemType,
      9206  requiresDedicatedAllocation || prefersDedicatedAllocation,
      9207  dedicatedBuffer,
      9208  dedicatedImage,
      9209  createInfo,
      9210  memTypeIndex,
      9211  suballocType,
      9212  pAllocation);
      9213  // Allocation from this alternative memory type succeeded.
      9214  if(res == VK_SUCCESS)
      9215  {
      9216  return res;
      9217  }
      9218  // else: Allocation from this memory type failed. Try next one - next loop iteration.
      9219  }
      9220  // No other matching memory type index could be found.
      9221  else
      9222  {
      9223  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
      9224  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9225  }
      9226  }
      9227  }
      9228  }
      9229  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
      9230  else
      9231  return res;
      9232  }
      9233 }
      9234 
      9235 void VmaAllocator_T::FreeMemory(const VmaAllocation allocation)
      9236 {
      9237  VMA_ASSERT(allocation);
      9238 
      9239  if(allocation->CanBecomeLost() == false ||
      9240  allocation->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
      9241  {
      9242  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      9243  {
      9244  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
      9245  }
      9246 
      9247  switch(allocation->GetType())
      9248  {
      9249  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9250  {
      9251  VmaBlockVector* pBlockVector = VMA_NULL;
      9252  VmaPool hPool = allocation->GetPool();
      9253  if(hPool != VK_NULL_HANDLE)
      9254  {
      9255  pBlockVector = &hPool->m_BlockVector;
      9256  }
      9257  else
      9258  {
      9259  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      9260  pBlockVector = m_pBlockVectors[memTypeIndex];
      9261  }
      9262  pBlockVector->Free(allocation);
      9263  }
      9264  break;
      9265  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9266  FreeDedicatedMemory(allocation);
      9267  break;
      9268  default:
      9269  VMA_ASSERT(0);
      9270  }
      9271  }
      9272 
      9273  allocation->SetUserData(this, VMA_NULL);
      9274  vma_delete(this, allocation);
      9275 }
      9276 
      9277 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
      9278 {
      9279  // Initialize.
      9280  InitStatInfo(pStats->total);
      9281  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
      9282  InitStatInfo(pStats->memoryType[i]);
      9283  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
      9284  InitStatInfo(pStats->memoryHeap[i]);
      9285 
      9286  // Process default pools.
      9287  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      9288  {
      9289  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      9290  VMA_ASSERT(pBlockVector);
      9291  pBlockVector->AddStats(pStats);
      9292  }
      9293 
      9294  // Process custom pools.
      9295  {
      9296  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      9297  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      9298  {
      9299  m_Pools[poolIndex]->GetBlockVector().AddStats(pStats);
      9300  }
      9301  }
      9302 
      9303  // Process dedicated allocations.
      9304  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      9305  {
      9306  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      9307  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      9308  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      9309  VMA_ASSERT(pDedicatedAllocVector);
      9310  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
      9311  {
      9312  VmaStatInfo allocationStatInfo;
      9313  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
      9314  VmaAddStatInfo(pStats->total, allocationStatInfo);
      9315  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      9316  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      9317  }
      9318  }
      9319 
      9320  // Postprocess.
      9321  VmaPostprocessCalcStatInfo(pStats->total);
      9322  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
      9323  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
      9324  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
      9325  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
      9326 }
      9327 
      9328 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
      9329 
      9330 VkResult VmaAllocator_T::Defragment(
      9331  VmaAllocation* pAllocations,
      9332  size_t allocationCount,
      9333  VkBool32* pAllocationsChanged,
      9334  const VmaDefragmentationInfo* pDefragmentationInfo,
      9335  VmaDefragmentationStats* pDefragmentationStats)
      9336 {
      9337  if(pAllocationsChanged != VMA_NULL)
      9338  {
      9339  memset(pAllocationsChanged, 0, sizeof(*pAllocationsChanged));
      9340  }
      9341  if(pDefragmentationStats != VMA_NULL)
      9342  {
      9343  memset(pDefragmentationStats, 0, sizeof(*pDefragmentationStats));
      9344  }
      9345 
      9346  const uint32_t currentFrameIndex = m_CurrentFrameIndex.load();
      9347 
      9348  VmaMutexLock poolsLock(m_PoolsMutex, m_UseMutex);
      9349 
      9350  const size_t poolCount = m_Pools.size();
      9351 
      9352  // Dispatch pAllocations among defragmentators. Create them in BlockVectors when necessary.
      9353  for(size_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      9354  {
      9355  VmaAllocation hAlloc = pAllocations[allocIndex];
      9356  VMA_ASSERT(hAlloc);
      9357  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
      9358  // DedicatedAlloc cannot be defragmented.
      9359  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
      9360  // Only HOST_VISIBLE memory types can be defragmented.
      9361  ((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) &&
      9362  // Lost allocation cannot be defragmented.
      9363  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
      9364  {
      9365  VmaBlockVector* pAllocBlockVector = VMA_NULL;
      9366 
      9367  const VmaPool hAllocPool = hAlloc->GetPool();
      9368  // This allocation belongs to custom pool.
      9369  if(hAllocPool != VK_NULL_HANDLE)
      9370  {
      9371  pAllocBlockVector = &hAllocPool->GetBlockVector();
      9372  }
      9373  // This allocation belongs to general pool.
      9374  else
      9375  {
      9376  pAllocBlockVector = m_pBlockVectors[memTypeIndex];
      9377  }
      9378 
      9379  VmaDefragmentator* const pDefragmentator = pAllocBlockVector->EnsureDefragmentator(this, currentFrameIndex);
      9380 
      9381  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
      9382  &pAllocationsChanged[allocIndex] : VMA_NULL;
      9383  pDefragmentator->AddAllocation(hAlloc, pChanged);
      9384  }
      9385  }
      9386 
      9387  VkResult result = VK_SUCCESS;
      9388 
      9389  // ======== Main processing.
      9390 
      9391  VkDeviceSize maxBytesToMove = SIZE_MAX;
      9392  uint32_t maxAllocationsToMove = UINT32_MAX;
      9393  if(pDefragmentationInfo != VMA_NULL)
      9394  {
      9395  maxBytesToMove = pDefragmentationInfo->maxBytesToMove;
      9396  maxAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
      9397  }
      9398 
      9399  // Process standard memory.
      9400  for(uint32_t memTypeIndex = 0;
      9401  (memTypeIndex < GetMemoryTypeCount()) && (result == VK_SUCCESS);
      9402  ++memTypeIndex)
      9403  {
      9404  // Only HOST_VISIBLE memory types can be defragmented.
      9405  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      9406  {
      9407  result = m_pBlockVectors[memTypeIndex]->Defragment(
      9408  pDefragmentationStats,
      9409  maxBytesToMove,
      9410  maxAllocationsToMove);
      9411  }
      9412  }
      9413 
      9414  // Process custom pools.
      9415  for(size_t poolIndex = 0; (poolIndex < poolCount) && (result == VK_SUCCESS); ++poolIndex)
      9416  {
      9417  result = m_Pools[poolIndex]->GetBlockVector().Defragment(
      9418  pDefragmentationStats,
      9419  maxBytesToMove,
      9420  maxAllocationsToMove);
      9421  }
      9422 
      9423  // ======== Destroy defragmentators.
      9424 
      9425  // Process custom pools.
      9426  for(size_t poolIndex = poolCount; poolIndex--; )
      9427  {
      9428  m_Pools[poolIndex]->GetBlockVector().DestroyDefragmentator();
      9429  }
      9430 
      9431  // Process standard memory.
      9432  for(uint32_t memTypeIndex = GetMemoryTypeCount(); memTypeIndex--; )
      9433  {
      9434  if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      9435  {
      9436  m_pBlockVectors[memTypeIndex]->DestroyDefragmentator();
      9437  }
      9438  }
      9439 
      9440  return result;
      9441 }
      9442 
      9443 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
      9444 {
      9445  if(hAllocation->CanBecomeLost())
      9446  {
      9447  /*
      9448  Warning: This is a carefully designed algorithm.
      9449  Do not modify unless you really know what you're doing :)
      9450  */
      9451  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      9452  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      9453  for(;;)
      9454  {
      9455  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      9456  {
      9457  pAllocationInfo->memoryType = UINT32_MAX;
      9458  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
      9459  pAllocationInfo->offset = 0;
      9460  pAllocationInfo->size = hAllocation->GetSize();
      9461  pAllocationInfo->pMappedData = VMA_NULL;
      9462  pAllocationInfo->pUserData = hAllocation->GetUserData();
      9463  return;
      9464  }
      9465  else if(localLastUseFrameIndex == localCurrFrameIndex)
      9466  {
      9467  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      9468  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      9469  pAllocationInfo->offset = hAllocation->GetOffset();
      9470  pAllocationInfo->size = hAllocation->GetSize();
      9471  pAllocationInfo->pMappedData = VMA_NULL;
      9472  pAllocationInfo->pUserData = hAllocation->GetUserData();
      9473  return;
      9474  }
      9475  else // Last use time earlier than current time.
      9476  {
      9477  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      9478  {
      9479  localLastUseFrameIndex = localCurrFrameIndex;
      9480  }
      9481  }
      9482  }
      9483  }
      9484  else
      9485  {
      9486 #if VMA_STATS_STRING_ENABLED
      9487  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      9488  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      9489  for(;;)
      9490  {
      9491  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      9492  if(localLastUseFrameIndex == localCurrFrameIndex)
      9493  {
      9494  break;
      9495  }
      9496  else // Last use time earlier than current time.
      9497  {
      9498  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      9499  {
      9500  localLastUseFrameIndex = localCurrFrameIndex;
      9501  }
      9502  }
      9503  }
      9504 #endif
      9505 
      9506  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      9507  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      9508  pAllocationInfo->offset = hAllocation->GetOffset();
      9509  pAllocationInfo->size = hAllocation->GetSize();
      9510  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
      9511  pAllocationInfo->pUserData = hAllocation->GetUserData();
      9512  }
      9513 }
      9514 
      9515 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
      9516 {
      9517  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
      9518  if(hAllocation->CanBecomeLost())
      9519  {
      9520  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      9521  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      9522  for(;;)
      9523  {
      9524  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      9525  {
      9526  return false;
      9527  }
      9528  else if(localLastUseFrameIndex == localCurrFrameIndex)
      9529  {
      9530  return true;
      9531  }
      9532  else // Last use time earlier than current time.
      9533  {
      9534  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      9535  {
      9536  localLastUseFrameIndex = localCurrFrameIndex;
      9537  }
      9538  }
      9539  }
      9540  }
      9541  else
      9542  {
      9543 #if VMA_STATS_STRING_ENABLED
      9544  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      9545  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      9546  for(;;)
      9547  {
      9548  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      9549  if(localLastUseFrameIndex == localCurrFrameIndex)
      9550  {
      9551  break;
      9552  }
      9553  else // Last use time earlier than current time.
      9554  {
      9555  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      9556  {
      9557  localLastUseFrameIndex = localCurrFrameIndex;
      9558  }
      9559  }
      9560  }
      9561 #endif
      9562 
      9563  return true;
      9564  }
      9565 }
      9566 
      9567 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
      9568 {
      9569  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u", pCreateInfo->memoryTypeIndex);
      9570 
      9571  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
      9572 
      9573  if(newCreateInfo.maxBlockCount == 0)
      9574  {
      9575  newCreateInfo.maxBlockCount = SIZE_MAX;
      9576  }
      9577  if(newCreateInfo.blockSize == 0)
      9578  {
      9579  newCreateInfo.blockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
      9580  }
      9581 
      9582  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo);
      9583 
      9584  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
      9585  if(res != VK_SUCCESS)
      9586  {
      9587  vma_delete(this, *pPool);
      9588  *pPool = VMA_NULL;
      9589  return res;
      9590  }
      9591 
      9592  // Add to m_Pools.
      9593  {
      9594  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      9595  (*pPool)->SetId(m_NextPoolId++);
      9596  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
      9597  }
      9598 
      9599  return VK_SUCCESS;
      9600 }
      9601 
      9602 void VmaAllocator_T::DestroyPool(VmaPool pool)
      9603 {
      9604  // Remove from m_Pools.
      9605  {
      9606  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      9607  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
      9608  VMA_ASSERT(success && "Pool not found in Allocator.");
      9609  }
      9610 
      9611  vma_delete(this, pool);
      9612 }
      9613 
      9614 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
      9615 {
      9616  pool->m_BlockVector.GetPoolStats(pPoolStats);
      9617 }
      9618 
      9619 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
      9620 {
      9621  m_CurrentFrameIndex.store(frameIndex);
      9622 }
      9623 
      9624 void VmaAllocator_T::MakePoolAllocationsLost(
      9625  VmaPool hPool,
      9626  size_t* pLostAllocationCount)
      9627 {
      9628  hPool->m_BlockVector.MakePoolAllocationsLost(
      9629  m_CurrentFrameIndex.load(),
      9630  pLostAllocationCount);
      9631 }
      9632 
      9633 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
      9634 {
      9635  return hPool->m_BlockVector.CheckCorruption();
      9636 }
      9637 
      9638 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
      9639 {
      9640  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
      9641 
      9642  // Process default pools.
      9643  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      9644  {
      9645  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
      9646  {
      9647  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      9648  VMA_ASSERT(pBlockVector);
      9649  VkResult localRes = pBlockVector->CheckCorruption();
      9650  switch(localRes)
      9651  {
      9652  case VK_ERROR_FEATURE_NOT_PRESENT:
      9653  break;
      9654  case VK_SUCCESS:
      9655  finalRes = VK_SUCCESS;
      9656  break;
      9657  default:
      9658  return localRes;
      9659  }
      9660  }
      9661  }
      9662 
      9663  // Process custom pools.
      9664  {
      9665  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      9666  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      9667  {
      9668  if(((1u << m_Pools[poolIndex]->GetBlockVector().GetMemoryTypeIndex()) & memoryTypeBits) != 0)
      9669  {
      9670  VkResult localRes = m_Pools[poolIndex]->GetBlockVector().CheckCorruption();
      9671  switch(localRes)
      9672  {
      9673  case VK_ERROR_FEATURE_NOT_PRESENT:
      9674  break;
      9675  case VK_SUCCESS:
      9676  finalRes = VK_SUCCESS;
      9677  break;
      9678  default:
      9679  return localRes;
      9680  }
      9681  }
      9682  }
      9683  }
      9684 
      9685  return finalRes;
      9686 }
      9687 
      9688 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
      9689 {
      9690  *pAllocation = vma_new(this, VmaAllocation_T)(VMA_FRAME_INDEX_LOST, false);
      9691  (*pAllocation)->InitLost();
      9692 }
      9693 
      9694 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
      9695 {
      9696  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
      9697 
      9698  VkResult res;
      9699  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
      9700  {
      9701  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
      9702  if(m_HeapSizeLimit[heapIndex] >= pAllocateInfo->allocationSize)
      9703  {
      9704  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
      9705  if(res == VK_SUCCESS)
      9706  {
      9707  m_HeapSizeLimit[heapIndex] -= pAllocateInfo->allocationSize;
      9708  }
      9709  }
      9710  else
      9711  {
      9712  res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
      9713  }
      9714  }
      9715  else
      9716  {
      9717  res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
      9718  }
      9719 
      9720  if(res == VK_SUCCESS && m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
      9721  {
      9722  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
      9723  }
      9724 
      9725  return res;
      9726 }
      9727 
      9728 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
      9729 {
      9730  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
      9731  {
      9732  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
      9733  }
      9734 
      9735  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
      9736 
      9737  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
      9738  if(m_HeapSizeLimit[heapIndex] != VK_WHOLE_SIZE)
      9739  {
      9740  VmaMutexLock lock(m_HeapSizeLimitMutex, m_UseMutex);
      9741  m_HeapSizeLimit[heapIndex] += size;
      9742  }
      9743 }
      9744 
      9745 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
      9746 {
      9747  if(hAllocation->CanBecomeLost())
      9748  {
      9749  return VK_ERROR_MEMORY_MAP_FAILED;
      9750  }
      9751 
      9752  switch(hAllocation->GetType())
      9753  {
      9754  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9755  {
      9756  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      9757  char *pBytes = VMA_NULL;
      9758  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
      9759  if(res == VK_SUCCESS)
      9760  {
      9761  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
      9762  hAllocation->BlockAllocMap();
      9763  }
      9764  return res;
      9765  }
      9766  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9767  return hAllocation->DedicatedAllocMap(this, ppData);
      9768  default:
      9769  VMA_ASSERT(0);
      9770  return VK_ERROR_MEMORY_MAP_FAILED;
      9771  }
      9772 }
      9773 
      9774 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
      9775 {
      9776  switch(hAllocation->GetType())
      9777  {
      9778  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9779  {
      9780  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      9781  hAllocation->BlockAllocUnmap();
      9782  pBlock->Unmap(this, 1);
      9783  }
      9784  break;
      9785  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9786  hAllocation->DedicatedAllocUnmap(this);
      9787  break;
      9788  default:
      9789  VMA_ASSERT(0);
      9790  }
      9791 }
      9792 
      9793 VkResult VmaAllocator_T::BindBufferMemory(VmaAllocation hAllocation, VkBuffer hBuffer)
      9794 {
      9795  VkResult res = VK_SUCCESS;
      9796  switch(hAllocation->GetType())
      9797  {
      9798  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9799  res = GetVulkanFunctions().vkBindBufferMemory(
      9800  m_hDevice,
      9801  hBuffer,
      9802  hAllocation->GetMemory(),
      9803  0); //memoryOffset
      9804  break;
      9805  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9806  {
      9807  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      9808  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
      9809  res = pBlock->BindBufferMemory(this, hAllocation, hBuffer);
      9810  break;
      9811  }
      9812  default:
      9813  VMA_ASSERT(0);
      9814  }
      9815  return res;
      9816 }
      9817 
      9818 VkResult VmaAllocator_T::BindImageMemory(VmaAllocation hAllocation, VkImage hImage)
      9819 {
      9820  VkResult res = VK_SUCCESS;
      9821  switch(hAllocation->GetType())
      9822  {
      9823  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9824  res = GetVulkanFunctions().vkBindImageMemory(
      9825  m_hDevice,
      9826  hImage,
      9827  hAllocation->GetMemory(),
      9828  0); //memoryOffset
      9829  break;
      9830  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9831  {
      9832  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      9833  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
      9834  res = pBlock->BindImageMemory(this, hAllocation, hImage);
      9835  break;
      9836  }
      9837  default:
      9838  VMA_ASSERT(0);
      9839  }
      9840  return res;
      9841 }
      9842 
      9843 void VmaAllocator_T::FlushOrInvalidateAllocation(
      9844  VmaAllocation hAllocation,
      9845  VkDeviceSize offset, VkDeviceSize size,
      9846  VMA_CACHE_OPERATION op)
      9847 {
      9848  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
      9849  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
      9850  {
      9851  const VkDeviceSize allocationSize = hAllocation->GetSize();
      9852  VMA_ASSERT(offset <= allocationSize);
      9853 
      9854  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
      9855 
      9856  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
      9857  memRange.memory = hAllocation->GetMemory();
      9858 
      9859  switch(hAllocation->GetType())
      9860  {
      9861  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      9862  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      9863  if(size == VK_WHOLE_SIZE)
      9864  {
      9865  memRange.size = allocationSize - memRange.offset;
      9866  }
      9867  else
      9868  {
      9869  VMA_ASSERT(offset + size <= allocationSize);
      9870  memRange.size = VMA_MIN(
      9871  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
      9872  allocationSize - memRange.offset);
      9873  }
      9874  break;
      9875 
      9876  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      9877  {
      9878  // 1. Still within this allocation.
      9879  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      9880  if(size == VK_WHOLE_SIZE)
      9881  {
      9882  size = allocationSize - offset;
      9883  }
      9884  else
      9885  {
      9886  VMA_ASSERT(offset + size <= allocationSize);
      9887  }
      9888  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
      9889 
      9890  // 2. Adjust to whole block.
      9891  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
      9892  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
      9893  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_Metadata.GetSize();
      9894  memRange.offset += allocationOffset;
      9895  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
      9896 
      9897  break;
      9898  }
      9899 
      9900  default:
      9901  VMA_ASSERT(0);
      9902  }
      9903 
      9904  switch(op)
      9905  {
      9906  case VMA_CACHE_FLUSH:
      9907  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
      9908  break;
      9909  case VMA_CACHE_INVALIDATE:
      9910  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
      9911  break;
      9912  default:
      9913  VMA_ASSERT(0);
      9914  }
      9915  }
      9916  // else: Just ignore this call.
      9917 }
      9918 
      9919 void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
      9920 {
      9921  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
      9922 
      9923  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      9924  {
      9925  VmaMutexLock lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      9926  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      9927  VMA_ASSERT(pDedicatedAllocations);
      9928  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
      9929  VMA_ASSERT(success);
      9930  }
      9931 
      9932  VkDeviceMemory hMemory = allocation->GetMemory();
      9933 
      9934  if(allocation->GetMappedData() != VMA_NULL)
      9935  {
      9936  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
      9937  }
      9938 
      9939  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
      9940 
      9941  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
      9942 }
      9943 
      9944 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
      9945 {
      9946  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
      9947  !hAllocation->CanBecomeLost() &&
      9948  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      9949  {
      9950  void* pData = VMA_NULL;
      9951  VkResult res = Map(hAllocation, &pData);
      9952  if(res == VK_SUCCESS)
      9953  {
      9954  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
      9955  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
      9956  Unmap(hAllocation);
      9957  }
      9958  else
      9959  {
      9960  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
      9961  }
      9962  }
      9963 }
      9964 
      9965 #if VMA_STATS_STRING_ENABLED
      9966 
      9967 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
      9968 {
      9969  bool dedicatedAllocationsStarted = false;
      9970  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      9971  {
      9972  VmaMutexLock dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      9973  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      9974  VMA_ASSERT(pDedicatedAllocVector);
      9975  if(pDedicatedAllocVector->empty() == false)
      9976  {
      9977  if(dedicatedAllocationsStarted == false)
      9978  {
      9979  dedicatedAllocationsStarted = true;
      9980  json.WriteString("DedicatedAllocations");
      9981  json.BeginObject();
      9982  }
      9983 
      9984  json.BeginString("Type ");
      9985  json.ContinueString(memTypeIndex);
      9986  json.EndString();
      9987 
      9988  json.BeginArray();
      9989 
      9990  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
      9991  {
      9992  json.BeginObject(true);
      9993  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
      9994  hAlloc->PrintParameters(json);
      9995  json.EndObject();
      9996  }
      9997 
      9998  json.EndArray();
      9999  }
      10000  }
      10001  if(dedicatedAllocationsStarted)
      10002  {
      10003  json.EndObject();
      10004  }
      10005 
      10006  {
      10007  bool allocationsStarted = false;
      10008  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      10009  {
      10010  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
      10011  {
      10012  if(allocationsStarted == false)
      10013  {
      10014  allocationsStarted = true;
      10015  json.WriteString("DefaultPools");
      10016  json.BeginObject();
      10017  }
      10018 
      10019  json.BeginString("Type ");
      10020  json.ContinueString(memTypeIndex);
      10021  json.EndString();
      10022 
      10023  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
      10024  }
      10025  }
      10026  if(allocationsStarted)
      10027  {
      10028  json.EndObject();
      10029  }
      10030  }
      10031 
      10032  {
      10033  VmaMutexLock lock(m_PoolsMutex, m_UseMutex);
      10034  const size_t poolCount = m_Pools.size();
      10035  if(poolCount > 0)
      10036  {
      10037  json.WriteString("Pools");
      10038  json.BeginObject();
      10039  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
      10040  {
      10041  json.BeginString();
      10042  json.ContinueString(m_Pools[poolIndex]->GetId());
      10043  json.EndString();
      10044 
      10045  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
      10046  }
      10047  json.EndObject();
      10048  }
      10049  }
      10050 }
      10051 
      10052 #endif // #if VMA_STATS_STRING_ENABLED
      10053 
      10055 // Public interface
      10056 
      10057 VkResult vmaCreateAllocator(
      10058  const VmaAllocatorCreateInfo* pCreateInfo,
      10059  VmaAllocator* pAllocator)
      10060 {
      10061  VMA_ASSERT(pCreateInfo && pAllocator);
      10062  VMA_DEBUG_LOG("vmaCreateAllocator");
      10063  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
      10064  return (*pAllocator)->Init(pCreateInfo);
      10065 }
      10066 
      10067 void vmaDestroyAllocator(
      10068  VmaAllocator allocator)
      10069 {
      10070  if(allocator != VK_NULL_HANDLE)
      10071  {
      10072  VMA_DEBUG_LOG("vmaDestroyAllocator");
      10073  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
      10074  vma_delete(&allocationCallbacks, allocator);
      10075  }
      10076 }
      10077 
      10078 void vmaGetPhysicalDeviceProperties(
      10079  VmaAllocator allocator,
      10080  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
      10081 {
      10082  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
      10083  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
      10084 }
      10085 
      10086 void vmaGetMemoryProperties(
      10087  VmaAllocator allocator,
      10088  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
      10089 {
      10090  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
      10091  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
      10092 }
      10093 
      10094 void vmaGetMemoryTypeProperties(
      10095  VmaAllocator allocator,
      10096  uint32_t memoryTypeIndex,
      10097  VkMemoryPropertyFlags* pFlags)
      10098 {
      10099  VMA_ASSERT(allocator && pFlags);
      10100  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
      10101  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
      10102 }
      10103 
      10104 void vmaSetCurrentFrameIndex(
      10105  VmaAllocator allocator,
      10106  uint32_t frameIndex)
      10107 {
      10108  VMA_ASSERT(allocator);
      10109  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
      10110 
      10111  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10112 
      10113  allocator->SetCurrentFrameIndex(frameIndex);
      10114 }
      10115 
      10116 void vmaCalculateStats(
      10117  VmaAllocator allocator,
      10118  VmaStats* pStats)
      10119 {
      10120  VMA_ASSERT(allocator && pStats);
      10121  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10122  allocator->CalculateStats(pStats);
      10123 }
      10124 
      10125 #if VMA_STATS_STRING_ENABLED
      10126 
      10127 void vmaBuildStatsString(
      10128  VmaAllocator allocator,
      10129  char** ppStatsString,
      10130  VkBool32 detailedMap)
      10131 {
      10132  VMA_ASSERT(allocator && ppStatsString);
      10133  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10134 
      10135  VmaStringBuilder sb(allocator);
      10136  {
      10137  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
      10138  json.BeginObject();
      10139 
      10140  VmaStats stats;
      10141  allocator->CalculateStats(&stats);
      10142 
      10143  json.WriteString("Total");
      10144  VmaPrintStatInfo(json, stats.total);
      10145 
      10146  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
      10147  {
      10148  json.BeginString("Heap ");
      10149  json.ContinueString(heapIndex);
      10150  json.EndString();
      10151  json.BeginObject();
      10152 
      10153  json.WriteString("Size");
      10154  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
      10155 
      10156  json.WriteString("Flags");
      10157  json.BeginArray(true);
      10158  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
      10159  {
      10160  json.WriteString("DEVICE_LOCAL");
      10161  }
      10162  json.EndArray();
      10163 
      10164  if(stats.memoryHeap[heapIndex].blockCount > 0)
      10165  {
      10166  json.WriteString("Stats");
      10167  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
      10168  }
      10169 
      10170  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
      10171  {
      10172  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
      10173  {
      10174  json.BeginString("Type ");
      10175  json.ContinueString(typeIndex);
      10176  json.EndString();
      10177 
      10178  json.BeginObject();
      10179 
      10180  json.WriteString("Flags");
      10181  json.BeginArray(true);
      10182  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
      10183  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
      10184  {
      10185  json.WriteString("DEVICE_LOCAL");
      10186  }
      10187  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      10188  {
      10189  json.WriteString("HOST_VISIBLE");
      10190  }
      10191  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
      10192  {
      10193  json.WriteString("HOST_COHERENT");
      10194  }
      10195  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
      10196  {
      10197  json.WriteString("HOST_CACHED");
      10198  }
      10199  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
      10200  {
      10201  json.WriteString("LAZILY_ALLOCATED");
      10202  }
      10203  json.EndArray();
      10204 
      10205  if(stats.memoryType[typeIndex].blockCount > 0)
      10206  {
      10207  json.WriteString("Stats");
      10208  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
      10209  }
      10210 
      10211  json.EndObject();
      10212  }
      10213  }
      10214 
      10215  json.EndObject();
      10216  }
      10217  if(detailedMap == VK_TRUE)
      10218  {
      10219  allocator->PrintDetailedMap(json);
      10220  }
      10221 
      10222  json.EndObject();
      10223  }
      10224 
      10225  const size_t len = sb.GetLength();
      10226  char* const pChars = vma_new_array(allocator, char, len + 1);
      10227  if(len > 0)
      10228  {
      10229  memcpy(pChars, sb.GetData(), len);
      10230  }
      10231  pChars[len] = '\0';
      10232  *ppStatsString = pChars;
      10233 }
      10234 
      10235 void vmaFreeStatsString(
      10236  VmaAllocator allocator,
      10237  char* pStatsString)
      10238 {
      10239  if(pStatsString != VMA_NULL)
      10240  {
      10241  VMA_ASSERT(allocator);
      10242  size_t len = strlen(pStatsString);
      10243  vma_delete_array(allocator, pStatsString, len + 1);
      10244  }
      10245 }
      10246 
      10247 #endif // #if VMA_STATS_STRING_ENABLED
      10248 
      10249 /*
      10250 This function is not protected by any mutex because it just reads immutable data.
      10251 */
      10252 VkResult vmaFindMemoryTypeIndex(
      10253  VmaAllocator allocator,
      10254  uint32_t memoryTypeBits,
      10255  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      10256  uint32_t* pMemoryTypeIndex)
      10257 {
      10258  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      10259  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      10260  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      10261 
      10262  if(pAllocationCreateInfo->memoryTypeBits != 0)
      10263  {
      10264  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
      10265  }
      10266 
      10267  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
      10268  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
      10269 
      10270  const bool mapped = (pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      10271  if(mapped)
      10272  {
      10273  preferredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      10274  }
      10275 
      10276  // Convert usage to requiredFlags and preferredFlags.
      10277  switch(pAllocationCreateInfo->usage)
      10278  {
      10279  case VMA_MEMORY_USAGE_UNKNOWN:
      10280  break;
      10281  case VMA_MEMORY_USAGE_GPU_ONLY:
      10282  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      10283  {
      10284  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      10285  }
      10286  break;
      10287  case VMA_MEMORY_USAGE_CPU_ONLY:
      10288  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      10289  break;
      10290  case VMA_MEMORY_USAGE_CPU_TO_GPU:
      10291  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      10292  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      10293  {
      10294  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      10295  }
      10296  break;
      10297  case VMA_MEMORY_USAGE_GPU_TO_CPU:
      10298  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      10299  preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
      10300  break;
      10301  default:
      10302  break;
      10303  }
      10304 
      10305  *pMemoryTypeIndex = UINT32_MAX;
      10306  uint32_t minCost = UINT32_MAX;
      10307  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
      10308  memTypeIndex < allocator->GetMemoryTypeCount();
      10309  ++memTypeIndex, memTypeBit <<= 1)
      10310  {
      10311  // This memory type is acceptable according to memoryTypeBits bitmask.
      10312  if((memTypeBit & memoryTypeBits) != 0)
      10313  {
      10314  const VkMemoryPropertyFlags currFlags =
      10315  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
      10316  // This memory type contains requiredFlags.
      10317  if((requiredFlags & ~currFlags) == 0)
      10318  {
      10319  // Calculate cost as number of bits from preferredFlags not present in this memory type.
      10320  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
      10321  // Remember memory type with lowest cost.
      10322  if(currCost < minCost)
      10323  {
      10324  *pMemoryTypeIndex = memTypeIndex;
      10325  if(currCost == 0)
      10326  {
      10327  return VK_SUCCESS;
      10328  }
      10329  minCost = currCost;
      10330  }
      10331  }
      10332  }
      10333  }
      10334  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
      10335 }
      10336 
      10337 VkResult vmaFindMemoryTypeIndexForBufferInfo(
      10338  VmaAllocator allocator,
      10339  const VkBufferCreateInfo* pBufferCreateInfo,
      10340  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      10341  uint32_t* pMemoryTypeIndex)
      10342 {
      10343  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      10344  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
      10345  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      10346  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      10347 
      10348  const VkDevice hDev = allocator->m_hDevice;
      10349  VkBuffer hBuffer = VK_NULL_HANDLE;
      10350  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
      10351  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
      10352  if(res == VK_SUCCESS)
      10353  {
      10354  VkMemoryRequirements memReq = {};
      10355  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
      10356  hDev, hBuffer, &memReq);
      10357 
      10358  res = vmaFindMemoryTypeIndex(
      10359  allocator,
      10360  memReq.memoryTypeBits,
      10361  pAllocationCreateInfo,
      10362  pMemoryTypeIndex);
      10363 
      10364  allocator->GetVulkanFunctions().vkDestroyBuffer(
      10365  hDev, hBuffer, allocator->GetAllocationCallbacks());
      10366  }
      10367  return res;
      10368 }
      10369 
      10370 VkResult vmaFindMemoryTypeIndexForImageInfo(
      10371  VmaAllocator allocator,
      10372  const VkImageCreateInfo* pImageCreateInfo,
      10373  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      10374  uint32_t* pMemoryTypeIndex)
      10375 {
      10376  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      10377  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
      10378  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      10379  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      10380 
      10381  const VkDevice hDev = allocator->m_hDevice;
      10382  VkImage hImage = VK_NULL_HANDLE;
      10383  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
      10384  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
      10385  if(res == VK_SUCCESS)
      10386  {
      10387  VkMemoryRequirements memReq = {};
      10388  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
      10389  hDev, hImage, &memReq);
      10390 
      10391  res = vmaFindMemoryTypeIndex(
      10392  allocator,
      10393  memReq.memoryTypeBits,
      10394  pAllocationCreateInfo,
      10395  pMemoryTypeIndex);
      10396 
      10397  allocator->GetVulkanFunctions().vkDestroyImage(
      10398  hDev, hImage, allocator->GetAllocationCallbacks());
      10399  }
      10400  return res;
      10401 }
      10402 
      10403 VkResult vmaCreatePool(
      10404  VmaAllocator allocator,
      10405  const VmaPoolCreateInfo* pCreateInfo,
      10406  VmaPool* pPool)
      10407 {
      10408  VMA_ASSERT(allocator && pCreateInfo && pPool);
      10409 
      10410  VMA_DEBUG_LOG("vmaCreatePool");
      10411 
      10412  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10413 
      10414  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
      10415 
      10416 #if VMA_RECORDING_ENABLED
      10417  if(allocator->GetRecorder() != VMA_NULL)
      10418  {
      10419  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
      10420  }
      10421 #endif
      10422 
      10423  return res;
      10424 }
      10425 
      10426 void vmaDestroyPool(
      10427  VmaAllocator allocator,
      10428  VmaPool pool)
      10429 {
      10430  VMA_ASSERT(allocator);
      10431 
      10432  if(pool == VK_NULL_HANDLE)
      10433  {
      10434  return;
      10435  }
      10436 
      10437  VMA_DEBUG_LOG("vmaDestroyPool");
      10438 
      10439  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10440 
      10441 #if VMA_RECORDING_ENABLED
      10442  if(allocator->GetRecorder() != VMA_NULL)
      10443  {
      10444  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
      10445  }
      10446 #endif
      10447 
      10448  allocator->DestroyPool(pool);
      10449 }
      10450 
      10451 void vmaGetPoolStats(
      10452  VmaAllocator allocator,
      10453  VmaPool pool,
      10454  VmaPoolStats* pPoolStats)
      10455 {
      10456  VMA_ASSERT(allocator && pool && pPoolStats);
      10457 
      10458  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10459 
      10460  allocator->GetPoolStats(pool, pPoolStats);
      10461 }
      10462 
      10463 void vmaMakePoolAllocationsLost(
      10464  VmaAllocator allocator,
      10465  VmaPool pool,
      10466  size_t* pLostAllocationCount)
      10467 {
      10468  VMA_ASSERT(allocator && pool);
      10469 
      10470  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10471 
      10472 #if VMA_RECORDING_ENABLED
      10473  if(allocator->GetRecorder() != VMA_NULL)
      10474  {
      10475  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
      10476  }
      10477 #endif
      10478 
      10479  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
      10480 }
      10481 
      10482 VkResult vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
      10483 {
      10484  VMA_ASSERT(allocator && pool);
      10485 
      10486  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10487 
      10488  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
      10489 
      10490  return allocator->CheckPoolCorruption(pool);
      10491 }
      10492 
      10493 VkResult vmaAllocateMemory(
      10494  VmaAllocator allocator,
      10495  const VkMemoryRequirements* pVkMemoryRequirements,
      10496  const VmaAllocationCreateInfo* pCreateInfo,
      10497  VmaAllocation* pAllocation,
      10498  VmaAllocationInfo* pAllocationInfo)
      10499 {
      10500  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
      10501 
      10502  VMA_DEBUG_LOG("vmaAllocateMemory");
      10503 
      10504  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10505 
      10506  VkResult result = allocator->AllocateMemory(
      10507  *pVkMemoryRequirements,
      10508  false, // requiresDedicatedAllocation
      10509  false, // prefersDedicatedAllocation
      10510  VK_NULL_HANDLE, // dedicatedBuffer
      10511  VK_NULL_HANDLE, // dedicatedImage
      10512  *pCreateInfo,
      10513  VMA_SUBALLOCATION_TYPE_UNKNOWN,
      10514  pAllocation);
      10515 
      10516 #if VMA_RECORDING_ENABLED
      10517  if(allocator->GetRecorder() != VMA_NULL)
      10518  {
      10519  allocator->GetRecorder()->RecordAllocateMemory(
      10520  allocator->GetCurrentFrameIndex(),
      10521  *pVkMemoryRequirements,
      10522  *pCreateInfo,
      10523  *pAllocation);
      10524  }
      10525 #endif
      10526 
      10527  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
      10528  {
      10529  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      10530  }
      10531 
      10532  return result;
      10533 }
      10534 
      10535 VkResult vmaAllocateMemoryForBuffer(
      10536  VmaAllocator allocator,
      10537  VkBuffer buffer,
      10538  const VmaAllocationCreateInfo* pCreateInfo,
      10539  VmaAllocation* pAllocation,
      10540  VmaAllocationInfo* pAllocationInfo)
      10541 {
      10542  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      10543 
      10544  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
      10545 
      10546  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10547 
      10548  VkMemoryRequirements vkMemReq = {};
      10549  bool requiresDedicatedAllocation = false;
      10550  bool prefersDedicatedAllocation = false;
      10551  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
      10552  requiresDedicatedAllocation,
      10553  prefersDedicatedAllocation);
      10554 
      10555  VkResult result = allocator->AllocateMemory(
      10556  vkMemReq,
      10557  requiresDedicatedAllocation,
      10558  prefersDedicatedAllocation,
      10559  buffer, // dedicatedBuffer
      10560  VK_NULL_HANDLE, // dedicatedImage
      10561  *pCreateInfo,
      10562  VMA_SUBALLOCATION_TYPE_BUFFER,
      10563  pAllocation);
      10564 
      10565 #if VMA_RECORDING_ENABLED
      10566  if(allocator->GetRecorder() != VMA_NULL)
      10567  {
      10568  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
      10569  allocator->GetCurrentFrameIndex(),
      10570  vkMemReq,
      10571  requiresDedicatedAllocation,
      10572  prefersDedicatedAllocation,
      10573  *pCreateInfo,
      10574  *pAllocation);
      10575  }
      10576 #endif
      10577 
      10578  if(pAllocationInfo && result == VK_SUCCESS)
      10579  {
      10580  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      10581  }
      10582 
      10583  return result;
      10584 }
      10585 
      10586 VkResult vmaAllocateMemoryForImage(
      10587  VmaAllocator allocator,
      10588  VkImage image,
      10589  const VmaAllocationCreateInfo* pCreateInfo,
      10590  VmaAllocation* pAllocation,
      10591  VmaAllocationInfo* pAllocationInfo)
      10592 {
      10593  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      10594 
      10595  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
      10596 
      10597  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10598 
      10599  VkMemoryRequirements vkMemReq = {};
      10600  bool requiresDedicatedAllocation = false;
      10601  bool prefersDedicatedAllocation = false;
      10602  allocator->GetImageMemoryRequirements(image, vkMemReq,
      10603  requiresDedicatedAllocation, prefersDedicatedAllocation);
      10604 
      10605  VkResult result = allocator->AllocateMemory(
      10606  vkMemReq,
      10607  requiresDedicatedAllocation,
      10608  prefersDedicatedAllocation,
      10609  VK_NULL_HANDLE, // dedicatedBuffer
      10610  image, // dedicatedImage
      10611  *pCreateInfo,
      10612  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
      10613  pAllocation);
      10614 
      10615 #if VMA_RECORDING_ENABLED
      10616  if(allocator->GetRecorder() != VMA_NULL)
      10617  {
      10618  allocator->GetRecorder()->RecordAllocateMemoryForImage(
      10619  allocator->GetCurrentFrameIndex(),
      10620  vkMemReq,
      10621  requiresDedicatedAllocation,
      10622  prefersDedicatedAllocation,
      10623  *pCreateInfo,
      10624  *pAllocation);
      10625  }
      10626 #endif
      10627 
      10628  if(pAllocationInfo && result == VK_SUCCESS)
      10629  {
      10630  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      10631  }
      10632 
      10633  return result;
      10634 }
      10635 
      10636 void vmaFreeMemory(
      10637  VmaAllocator allocator,
      10638  VmaAllocation allocation)
      10639 {
      10640  VMA_ASSERT(allocator);
      10641 
      10642  if(allocation == VK_NULL_HANDLE)
      10643  {
      10644  return;
      10645  }
      10646 
      10647  VMA_DEBUG_LOG("vmaFreeMemory");
      10648 
      10649  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10650 
      10651 #if VMA_RECORDING_ENABLED
      10652  if(allocator->GetRecorder() != VMA_NULL)
      10653  {
      10654  allocator->GetRecorder()->RecordFreeMemory(
      10655  allocator->GetCurrentFrameIndex(),
      10656  allocation);
      10657  }
      10658 #endif
      10659 
      10660  allocator->FreeMemory(allocation);
      10661 }
      10662 
      10663 void vmaGetAllocationInfo(
      10664  VmaAllocator allocator,
      10665  VmaAllocation allocation,
      10666  VmaAllocationInfo* pAllocationInfo)
      10667 {
      10668  VMA_ASSERT(allocator && allocation && pAllocationInfo);
      10669 
      10670  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10671 
      10672 #if VMA_RECORDING_ENABLED
      10673  if(allocator->GetRecorder() != VMA_NULL)
      10674  {
      10675  allocator->GetRecorder()->RecordGetAllocationInfo(
      10676  allocator->GetCurrentFrameIndex(),
      10677  allocation);
      10678  }
      10679 #endif
      10680 
      10681  allocator->GetAllocationInfo(allocation, pAllocationInfo);
      10682 }
      10683 
      10684 VkBool32 vmaTouchAllocation(
      10685  VmaAllocator allocator,
      10686  VmaAllocation allocation)
      10687 {
      10688  VMA_ASSERT(allocator && allocation);
      10689 
      10690  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10691 
      10692 #if VMA_RECORDING_ENABLED
      10693  if(allocator->GetRecorder() != VMA_NULL)
      10694  {
      10695  allocator->GetRecorder()->RecordTouchAllocation(
      10696  allocator->GetCurrentFrameIndex(),
      10697  allocation);
      10698  }
      10699 #endif
      10700 
      10701  return allocator->TouchAllocation(allocation);
      10702 }
      10703 
      10704 void vmaSetAllocationUserData(
      10705  VmaAllocator allocator,
      10706  VmaAllocation allocation,
      10707  void* pUserData)
      10708 {
      10709  VMA_ASSERT(allocator && allocation);
      10710 
      10711  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10712 
      10713  allocation->SetUserData(allocator, pUserData);
      10714 
      10715 #if VMA_RECORDING_ENABLED
      10716  if(allocator->GetRecorder() != VMA_NULL)
      10717  {
      10718  allocator->GetRecorder()->RecordSetAllocationUserData(
      10719  allocator->GetCurrentFrameIndex(),
      10720  allocation,
      10721  pUserData);
      10722  }
      10723 #endif
      10724 }
      10725 
      10726 void vmaCreateLostAllocation(
      10727  VmaAllocator allocator,
      10728  VmaAllocation* pAllocation)
      10729 {
      10730  VMA_ASSERT(allocator && pAllocation);
      10731 
      10732  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
      10733 
      10734  allocator->CreateLostAllocation(pAllocation);
      10735 
      10736 #if VMA_RECORDING_ENABLED
      10737  if(allocator->GetRecorder() != VMA_NULL)
      10738  {
      10739  allocator->GetRecorder()->RecordCreateLostAllocation(
      10740  allocator->GetCurrentFrameIndex(),
      10741  *pAllocation);
      10742  }
      10743 #endif
      10744 }
      10745 
      10746 VkResult vmaMapMemory(
      10747  VmaAllocator allocator,
      10748  VmaAllocation allocation,
      10749  void** ppData)
      10750 {
      10751  VMA_ASSERT(allocator && allocation && ppData);
      10752 
      10753  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10754 
      10755  VkResult res = allocator->Map(allocation, ppData);
      10756 
      10757 #if VMA_RECORDING_ENABLED
      10758  if(allocator->GetRecorder() != VMA_NULL)
      10759  {
      10760  allocator->GetRecorder()->RecordMapMemory(
      10761  allocator->GetCurrentFrameIndex(),
      10762  allocation);
      10763  }
      10764 #endif
      10765 
      10766  return res;
      10767 }
      10768 
      10769 void vmaUnmapMemory(
      10770  VmaAllocator allocator,
      10771  VmaAllocation allocation)
      10772 {
      10773  VMA_ASSERT(allocator && allocation);
      10774 
      10775  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10776 
      10777 #if VMA_RECORDING_ENABLED
      10778  if(allocator->GetRecorder() != VMA_NULL)
      10779  {
      10780  allocator->GetRecorder()->RecordUnmapMemory(
      10781  allocator->GetCurrentFrameIndex(),
      10782  allocation);
      10783  }
      10784 #endif
      10785 
      10786  allocator->Unmap(allocation);
      10787 }
      10788 
      10789 void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      10790 {
      10791  VMA_ASSERT(allocator && allocation);
      10792 
      10793  VMA_DEBUG_LOG("vmaFlushAllocation");
      10794 
      10795  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10796 
      10797  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
      10798 
      10799 #if VMA_RECORDING_ENABLED
      10800  if(allocator->GetRecorder() != VMA_NULL)
      10801  {
      10802  allocator->GetRecorder()->RecordFlushAllocation(
      10803  allocator->GetCurrentFrameIndex(),
      10804  allocation, offset, size);
      10805  }
      10806 #endif
      10807 }
      10808 
      10809 void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      10810 {
      10811  VMA_ASSERT(allocator && allocation);
      10812 
      10813  VMA_DEBUG_LOG("vmaInvalidateAllocation");
      10814 
      10815  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10816 
      10817  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
      10818 
      10819 #if VMA_RECORDING_ENABLED
      10820  if(allocator->GetRecorder() != VMA_NULL)
      10821  {
      10822  allocator->GetRecorder()->RecordInvalidateAllocation(
      10823  allocator->GetCurrentFrameIndex(),
      10824  allocation, offset, size);
      10825  }
      10826 #endif
      10827 }
      10828 
      10829 VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
      10830 {
      10831  VMA_ASSERT(allocator);
      10832 
      10833  VMA_DEBUG_LOG("vmaCheckCorruption");
      10834 
      10835  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10836 
      10837  return allocator->CheckCorruption(memoryTypeBits);
      10838 }
      10839 
      10840 VkResult vmaDefragment(
      10841  VmaAllocator allocator,
      10842  VmaAllocation* pAllocations,
      10843  size_t allocationCount,
      10844  VkBool32* pAllocationsChanged,
      10845  const VmaDefragmentationInfo *pDefragmentationInfo,
      10846  VmaDefragmentationStats* pDefragmentationStats)
      10847 {
      10848  VMA_ASSERT(allocator && pAllocations);
      10849 
      10850  VMA_DEBUG_LOG("vmaDefragment");
      10851 
      10852  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10853 
      10854  return allocator->Defragment(pAllocations, allocationCount, pAllocationsChanged, pDefragmentationInfo, pDefragmentationStats);
      10855 }
      10856 
      10857 VkResult vmaBindBufferMemory(
      10858  VmaAllocator allocator,
      10859  VmaAllocation allocation,
      10860  VkBuffer buffer)
      10861 {
      10862  VMA_ASSERT(allocator && allocation && buffer);
      10863 
      10864  VMA_DEBUG_LOG("vmaBindBufferMemory");
      10865 
      10866  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10867 
      10868  return allocator->BindBufferMemory(allocation, buffer);
      10869 }
      10870 
      10871 VkResult vmaBindImageMemory(
      10872  VmaAllocator allocator,
      10873  VmaAllocation allocation,
      10874  VkImage image)
      10875 {
      10876  VMA_ASSERT(allocator && allocation && image);
      10877 
      10878  VMA_DEBUG_LOG("vmaBindImageMemory");
      10879 
      10880  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10881 
      10882  return allocator->BindImageMemory(allocation, image);
      10883 }
      10884 
      10885 VkResult vmaCreateBuffer(
      10886  VmaAllocator allocator,
      10887  const VkBufferCreateInfo* pBufferCreateInfo,
      10888  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      10889  VkBuffer* pBuffer,
      10890  VmaAllocation* pAllocation,
      10891  VmaAllocationInfo* pAllocationInfo)
      10892 {
      10893  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
      10894 
      10895  VMA_DEBUG_LOG("vmaCreateBuffer");
      10896 
      10897  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      10898 
      10899  *pBuffer = VK_NULL_HANDLE;
      10900  *pAllocation = VK_NULL_HANDLE;
      10901 
      10902  // 1. Create VkBuffer.
      10903  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
      10904  allocator->m_hDevice,
      10905  pBufferCreateInfo,
      10906  allocator->GetAllocationCallbacks(),
      10907  pBuffer);
      10908  if(res >= 0)
      10909  {
      10910  // 2. vkGetBufferMemoryRequirements.
      10911  VkMemoryRequirements vkMemReq = {};
      10912  bool requiresDedicatedAllocation = false;
      10913  bool prefersDedicatedAllocation = false;
      10914  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
      10915  requiresDedicatedAllocation, prefersDedicatedAllocation);
      10916 
      10917  // Make sure alignment requirements for specific buffer usages reported
      10918  // in Physical Device Properties are included in alignment reported by memory requirements.
      10919  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
      10920  {
      10921  VMA_ASSERT(vkMemReq.alignment %
      10922  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
      10923  }
      10924  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
      10925  {
      10926  VMA_ASSERT(vkMemReq.alignment %
      10927  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
      10928  }
      10929  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
      10930  {
      10931  VMA_ASSERT(vkMemReq.alignment %
      10932  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
      10933  }
      10934 
      10935  // 3. Allocate memory using allocator.
      10936  res = allocator->AllocateMemory(
      10937  vkMemReq,
      10938  requiresDedicatedAllocation,
      10939  prefersDedicatedAllocation,
      10940  *pBuffer, // dedicatedBuffer
      10941  VK_NULL_HANDLE, // dedicatedImage
      10942  *pAllocationCreateInfo,
      10943  VMA_SUBALLOCATION_TYPE_BUFFER,
      10944  pAllocation);
      10945 
      10946 #if VMA_RECORDING_ENABLED
      10947  if(allocator->GetRecorder() != VMA_NULL)
      10948  {
      10949  allocator->GetRecorder()->RecordCreateBuffer(
      10950  allocator->GetCurrentFrameIndex(),
      10951  *pBufferCreateInfo,
      10952  *pAllocationCreateInfo,
      10953  *pAllocation);
      10954  }
      10955 #endif
      10956 
      10957  if(res >= 0)
      10958  {
      10959  // 3. Bind buffer with memory.
      10960  res = allocator->BindBufferMemory(*pAllocation, *pBuffer);
      10961  if(res >= 0)
      10962  {
      10963  // All steps succeeded.
      10964  #if VMA_STATS_STRING_ENABLED
      10965  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
      10966  #endif
      10967  if(pAllocationInfo != VMA_NULL)
      10968  {
      10969  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      10970  }
      10971 
      10972  return VK_SUCCESS;
      10973  }
      10974  allocator->FreeMemory(*pAllocation);
      10975  *pAllocation = VK_NULL_HANDLE;
      10976  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      10977  *pBuffer = VK_NULL_HANDLE;
      10978  return res;
      10979  }
      10980  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      10981  *pBuffer = VK_NULL_HANDLE;
      10982  return res;
      10983  }
      10984  return res;
      10985 }
      10986 
      10987 void vmaDestroyBuffer(
      10988  VmaAllocator allocator,
      10989  VkBuffer buffer,
      10990  VmaAllocation allocation)
      10991 {
      10992  VMA_ASSERT(allocator);
      10993 
      10994  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
      10995  {
      10996  return;
      10997  }
      10998 
      10999  VMA_DEBUG_LOG("vmaDestroyBuffer");
      11000 
      11001  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      11002 
      11003 #if VMA_RECORDING_ENABLED
      11004  if(allocator->GetRecorder() != VMA_NULL)
      11005  {
      11006  allocator->GetRecorder()->RecordDestroyBuffer(
      11007  allocator->GetCurrentFrameIndex(),
      11008  allocation);
      11009  }
      11010 #endif
      11011 
      11012  if(buffer != VK_NULL_HANDLE)
      11013  {
      11014  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
      11015  }
      11016 
      11017  if(allocation != VK_NULL_HANDLE)
      11018  {
      11019  allocator->FreeMemory(allocation);
      11020  }
      11021 }
      11022 
      11023 VkResult vmaCreateImage(
      11024  VmaAllocator allocator,
      11025  const VkImageCreateInfo* pImageCreateInfo,
      11026  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      11027  VkImage* pImage,
      11028  VmaAllocation* pAllocation,
      11029  VmaAllocationInfo* pAllocationInfo)
      11030 {
      11031  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
      11032 
      11033  VMA_DEBUG_LOG("vmaCreateImage");
      11034 
      11035  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      11036 
      11037  *pImage = VK_NULL_HANDLE;
      11038  *pAllocation = VK_NULL_HANDLE;
      11039 
      11040  // 1. Create VkImage.
      11041  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
      11042  allocator->m_hDevice,
      11043  pImageCreateInfo,
      11044  allocator->GetAllocationCallbacks(),
      11045  pImage);
      11046  if(res >= 0)
      11047  {
      11048  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
      11049  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
      11050  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
      11051 
      11052  // 2. Allocate memory using allocator.
      11053  VkMemoryRequirements vkMemReq = {};
      11054  bool requiresDedicatedAllocation = false;
      11055  bool prefersDedicatedAllocation = false;
      11056  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
      11057  requiresDedicatedAllocation, prefersDedicatedAllocation);
      11058 
      11059  res = allocator->AllocateMemory(
      11060  vkMemReq,
      11061  requiresDedicatedAllocation,
      11062  prefersDedicatedAllocation,
      11063  VK_NULL_HANDLE, // dedicatedBuffer
      11064  *pImage, // dedicatedImage
      11065  *pAllocationCreateInfo,
      11066  suballocType,
      11067  pAllocation);
      11068 
      11069 #if VMA_RECORDING_ENABLED
      11070  if(allocator->GetRecorder() != VMA_NULL)
      11071  {
      11072  allocator->GetRecorder()->RecordCreateImage(
      11073  allocator->GetCurrentFrameIndex(),
      11074  *pImageCreateInfo,
      11075  *pAllocationCreateInfo,
      11076  *pAllocation);
      11077  }
      11078 #endif
      11079 
      11080  if(res >= 0)
      11081  {
      11082  // 3. Bind image with memory.
      11083  res = allocator->BindImageMemory(*pAllocation, *pImage);
      11084  if(res >= 0)
      11085  {
      11086  // All steps succeeded.
      11087  #if VMA_STATS_STRING_ENABLED
      11088  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
      11089  #endif
      11090  if(pAllocationInfo != VMA_NULL)
      11091  {
      11092  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      11093  }
      11094 
      11095  return VK_SUCCESS;
      11096  }
      11097  allocator->FreeMemory(*pAllocation);
      11098  *pAllocation = VK_NULL_HANDLE;
      11099  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      11100  *pImage = VK_NULL_HANDLE;
      11101  return res;
      11102  }
      11103  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      11104  *pImage = VK_NULL_HANDLE;
      11105  return res;
      11106  }
      11107  return res;
      11108 }
      11109 
      11110 void vmaDestroyImage(
      11111  VmaAllocator allocator,
      11112  VkImage image,
      11113  VmaAllocation allocation)
      11114 {
      11115  VMA_ASSERT(allocator);
      11116 
      11117  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
      11118  {
      11119  return;
      11120  }
      11121 
      11122  VMA_DEBUG_LOG("vmaDestroyImage");
      11123 
      11124  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      11125 
      11126 #if VMA_RECORDING_ENABLED
      11127  if(allocator->GetRecorder() != VMA_NULL)
      11128  {
      11129  allocator->GetRecorder()->RecordDestroyImage(
      11130  allocator->GetCurrentFrameIndex(),
      11131  allocation);
      11132  }
      11133 #endif
      11134 
      11135  if(image != VK_NULL_HANDLE)
      11136  {
      11137  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
      11138  }
      11139  if(allocation != VK_NULL_HANDLE)
      11140  {
      11141  allocator->FreeMemory(allocation);
      11142  }
      11143 }
      11144 
      11145 #endif // #ifdef VMA_IMPLEMENTATION
      VmaVulkanFunctions::vkGetPhysicalDeviceProperties
      PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
      Definition: vk_mem_alloc.h:1345
      +
      VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
      Set this flag if the allocation should have its own memory block.
      Definition: vk_mem_alloc.h:1658
      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:1300
      +
      VmaAllocatorCreateInfo::physicalDevice
      VkPhysicalDevice physicalDevice
      Vulkan physical device.
      Definition: vk_mem_alloc.h:1414
      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.
      -
      VmaVulkanFunctions::vkCreateBuffer
      PFN_vkCreateBuffer vkCreateBuffer
      Definition: vk_mem_alloc.h:1283
      +
      VMA_RECORD_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1376
      +
      VmaVulkanFunctions::vkCreateBuffer
      PFN_vkCreateBuffer vkCreateBuffer
      Definition: vk_mem_alloc.h:1357
      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:1494
      -
      VmaVulkanFunctions::vkMapMemory
      PFN_vkMapMemory vkMapMemory
      Definition: vk_mem_alloc.h:1275
      -
      VmaAllocationInfo::deviceMemory
      VkDeviceMemory deviceMemory
      Handle to Vulkan memory object.
      Definition: vk_mem_alloc.h:1883
      -
      VmaAllocatorCreateInfo::flags
      VmaAllocatorCreateFlags flags
      Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1297
      -
      VmaDefragmentationInfo::maxAllocationsToMove
      uint32_t maxAllocationsToMove
      Maximum number of allocations that can be moved to different place.
      Definition: vk_mem_alloc.h:2128
      -
      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:1713
      +
      VMA_MEMORY_USAGE_GPU_ONLY
      Definition: vk_mem_alloc.h:1615
      +
      VmaVulkanFunctions::vkMapMemory
      PFN_vkMapMemory vkMapMemory
      Definition: vk_mem_alloc.h:1349
      +
      VmaAllocationInfo::deviceMemory
      VkDeviceMemory deviceMemory
      Handle to Vulkan memory object.
      Definition: vk_mem_alloc.h:2004
      +
      VmaAllocatorCreateInfo::flags
      VmaAllocatorCreateFlags flags
      Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1411
      +
      VmaDefragmentationInfo::maxAllocationsToMove
      uint32_t maxAllocationsToMove
      Maximum number of allocations that can be moved to different place.
      Definition: vk_mem_alloc.h:2249
      +
      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:1834
      +
      VMA_RECORDING_ENABLED
      #define VMA_RECORDING_ENABLED
      Definition: vk_mem_alloc.h:1388
      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:1767
      -
      VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
      Definition: vk_mem_alloc.h:1574
      -
      VmaAllocatorCreateFlags
      VkFlags VmaAllocatorCreateFlags
      Definition: vk_mem_alloc.h:1264
      -
      VmaAllocationCreateInfo::preferredFlags
      VkMemoryPropertyFlags preferredFlags
      Flags that preferably should be set in a memory type chosen for an allocation.
      Definition: vk_mem_alloc.h:1612
      -
      VMA_MEMORY_USAGE_MAX_ENUM
      Definition: vk_mem_alloc.h:1521
      -
      VmaAllocatorCreateInfo::pAllocationCallbacks
      const VkAllocationCallbacks * pAllocationCallbacks
      Custom CPU memory allocation callbacks. Optional.
      Definition: vk_mem_alloc.h:1309
      +
      VmaPoolStats::size
      VkDeviceSize size
      Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
      Definition: vk_mem_alloc.h:1888
      +
      VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
      Definition: vk_mem_alloc.h:1695
      +
      VmaAllocatorCreateFlags
      VkFlags VmaAllocatorCreateFlags
      Definition: vk_mem_alloc.h:1338
      +
      VmaAllocationCreateInfo::preferredFlags
      VkMemoryPropertyFlags preferredFlags
      Flags that preferably should be set in a memory type chosen for an allocation.
      Definition: vk_mem_alloc.h:1733
      +
      VMA_MEMORY_USAGE_MAX_ENUM
      Definition: vk_mem_alloc.h:1642
      +
      VmaAllocatorCreateInfo::pAllocationCallbacks
      const VkAllocationCallbacks * pAllocationCallbacks
      Custom CPU memory allocation callbacks. Optional.
      Definition: vk_mem_alloc.h:1423
      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:1362
      -
      VmaAllocatorCreateInfo
      Description of a Allocator to be created.
      Definition: vk_mem_alloc.h:1294
      +
      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:1476
      +
      VmaAllocatorCreateInfo
      Description of a Allocator to be created.
      Definition: vk_mem_alloc.h:1408
      vmaDestroyAllocator
      void vmaDestroyAllocator(VmaAllocator allocator)
      Destroys allocator object.
      -
      VmaAllocationCreateFlagBits
      VmaAllocationCreateFlagBits
      Flags to be passed as VmaAllocationCreateInfo::flags.
      Definition: vk_mem_alloc.h:1525
      +
      VmaAllocationCreateFlagBits
      VmaAllocationCreateFlagBits
      Flags to be passed as VmaAllocationCreateInfo::flags.
      Definition: vk_mem_alloc.h:1646
      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:1427
      -
      VmaVulkanFunctions::vkBindImageMemory
      PFN_vkBindImageMemory vkBindImageMemory
      Definition: vk_mem_alloc.h:1280
      -
      VmaStatInfo::unusedBytes
      VkDeviceSize unusedBytes
      Total number of bytes occupied by unused ranges.
      Definition: vk_mem_alloc.h:1426
      -
      VmaDefragmentationStats
      Statistics returned by function vmaDefragment().
      Definition: vk_mem_alloc.h:2132
      +
      VmaStatInfo::allocationSizeMax
      VkDeviceSize allocationSizeMax
      Definition: vk_mem_alloc.h:1548
      +
      VmaVulkanFunctions::vkBindImageMemory
      PFN_vkBindImageMemory vkBindImageMemory
      Definition: vk_mem_alloc.h:1354
      +
      VmaStatInfo::unusedBytes
      VkDeviceSize unusedBytes
      Total number of bytes occupied by unused ranges.
      Definition: vk_mem_alloc.h:1547
      +
      VmaDefragmentationStats
      Statistics returned by function vmaDefragment().
      Definition: vk_mem_alloc.h:2253
      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:1326
      -
      VmaStats::total
      VmaStatInfo total
      Definition: vk_mem_alloc.h:1436
      -
      VmaDefragmentationStats::deviceMemoryBlocksFreed
      uint32_t deviceMemoryBlocksFreed
      Number of empty VkDeviceMemory objects that have been released to the system.
      Definition: vk_mem_alloc.h:2140
      -
      VmaAllocationCreateInfo::flags
      VmaAllocationCreateFlags flags
      Use VmaAllocationCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1596
      -
      VmaDefragmentationInfo::maxBytesToMove
      VkDeviceSize maxBytesToMove
      Maximum total numbers of bytes that can be copied while moving allocations to different places...
      Definition: vk_mem_alloc.h:2123
      -
      VmaVulkanFunctions::vkGetBufferMemoryRequirements
      PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
      Definition: vk_mem_alloc.h:1281
      -
      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:1206
      +
      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:1440
      +
      VmaStats::total
      VmaStatInfo total
      Definition: vk_mem_alloc.h:1557
      +
      VmaDefragmentationStats::deviceMemoryBlocksFreed
      uint32_t deviceMemoryBlocksFreed
      Number of empty VkDeviceMemory objects that have been released to the system.
      Definition: vk_mem_alloc.h:2261
      +
      VmaAllocationCreateInfo::flags
      VmaAllocationCreateFlags flags
      Use VmaAllocationCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1717
      +
      VmaDefragmentationInfo::maxBytesToMove
      VkDeviceSize maxBytesToMove
      Maximum total numbers of bytes that can be copied while moving allocations to different places...
      Definition: vk_mem_alloc.h:2244
      +
      VmaVulkanFunctions::vkGetBufferMemoryRequirements
      PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
      Definition: vk_mem_alloc.h:1355
      +
      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:1280
      VmaAllocator
      Represents main object of this library initialized.
      -
      VmaAllocatorCreateInfo::device
      VkDevice device
      Vulkan device.
      Definition: vk_mem_alloc.h:1303
      +
      VmaAllocatorCreateInfo::device
      VkDevice device
      Vulkan device.
      Definition: vk_mem_alloc.h:1417
      vmaBindBufferMemory
      VkResult vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)
      Binds buffer to allocation.
      -
      VmaPoolCreateInfo
      Describes parameter of created VmaPool.
      Definition: vk_mem_alloc.h:1721
      -
      VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1715
      -
      VmaAllocationInfo::size
      VkDeviceSize size
      Size of this allocation, in bytes.
      Definition: vk_mem_alloc.h:1893
      +
      VmaPoolCreateInfo
      Describes parameter of created VmaPool.
      Definition: vk_mem_alloc.h:1842
      +
      VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1836
      +
      VmaAllocatorCreateInfo::pRecordSettings
      const VmaRecordSettings * pRecordSettings
      Parameters for recording of VMA calls. Can be null.
      Definition: vk_mem_alloc.h:1483
      +
      VmaAllocationInfo::size
      VkDeviceSize size
      Size of this allocation, in bytes.
      Definition: vk_mem_alloc.h:2014
      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:1276
      -
      VmaAllocationCreateInfo::pUserData
      void * pUserData
      Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
      Definition: vk_mem_alloc.h:1633
      -
      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:1737
      -
      VmaPoolStats::allocationCount
      size_t allocationCount
      Number of VmaAllocation objects created from this pool that were not destroyed or lost...
      Definition: vk_mem_alloc.h:1773
      +
      VmaVulkanFunctions::vkUnmapMemory
      PFN_vkUnmapMemory vkUnmapMemory
      Definition: vk_mem_alloc.h:1350
      +
      VMA_RECORD_FLUSH_AFTER_CALL_BIT
      Enables flush after recording every function call.
      Definition: vk_mem_alloc.h:1374
      +
      VmaAllocationCreateInfo::pUserData
      void * pUserData
      Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
      Definition: vk_mem_alloc.h:1754
      +
      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:1858
      +
      VmaPoolStats::allocationCount
      size_t allocationCount
      Number of VmaAllocation objects created from this pool that were not destroyed or lost...
      Definition: vk_mem_alloc.h:1894
      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:1262
      -
      VmaPoolCreateInfo::memoryTypeIndex
      uint32_t memoryTypeIndex
      Vulkan memory type index to allocate this pool from.
      Definition: vk_mem_alloc.h:1724
      +
      VMA_ALLOCATOR_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1336
      +
      VmaPoolCreateInfo::memoryTypeIndex
      uint32_t memoryTypeIndex
      Vulkan memory type index to allocate this pool from.
      Definition: vk_mem_alloc.h:1845
      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:1472
      +
      VmaMemoryUsage
      VmaMemoryUsage
      Definition: vk_mem_alloc.h:1593
      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:2118
      +
      VmaDefragmentationInfo
      Optional configuration parameters to be passed to function vmaDefragment().
      Definition: vk_mem_alloc.h:2239
      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:2136
      -
      VMA_MEMORY_USAGE_CPU_TO_GPU
      Definition: vk_mem_alloc.h:1511
      -
      VmaAllocationCreateInfo::memoryTypeBits
      uint32_t memoryTypeBits
      Bitmask containing one bit set for every memory type acceptable for this allocation.
      Definition: vk_mem_alloc.h:1620
      -
      VmaVulkanFunctions::vkBindBufferMemory
      PFN_vkBindBufferMemory vkBindBufferMemory
      Definition: vk_mem_alloc.h:1279
      +
      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:2257
      +
      VMA_MEMORY_USAGE_CPU_TO_GPU
      Definition: vk_mem_alloc.h:1632
      +
      VmaAllocationCreateInfo::memoryTypeBits
      uint32_t memoryTypeBits
      Bitmask containing one bit set for every memory type acceptable for this allocation.
      Definition: vk_mem_alloc.h:1741
      +
      VmaVulkanFunctions::vkBindBufferMemory
      PFN_vkBindBufferMemory vkBindBufferMemory
      Definition: vk_mem_alloc.h:1353
      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:1432
      -
      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:1212
      +
      VmaStats
      General statistics from current state of Allocator.
      Definition: vk_mem_alloc.h:1553
      +
      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:1286
      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:1233
      +
      VmaAllocatorCreateFlagBits
      VmaAllocatorCreateFlagBits
      Flags for created VmaAllocator.
      Definition: vk_mem_alloc.h:1307
      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.
      -
      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:1238
      -
      VmaDefragmentationStats::allocationsMoved
      uint32_t allocationsMoved
      Number of allocations that have been moved to different places.
      Definition: vk_mem_alloc.h:2138
      +
      VmaRecordFlags
      VkFlags VmaRecordFlags
      Definition: vk_mem_alloc.h:1378
      +
      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:1312
      +
      VmaDefragmentationStats::allocationsMoved
      uint32_t allocationsMoved
      Number of allocations that have been moved to different places.
      Definition: vk_mem_alloc.h:2259
      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:1607
      -
      VmaPoolStats::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Size of the largest continuous free memory region.
      Definition: vk_mem_alloc.h:1783
      +
      VmaAllocationCreateInfo::requiredFlags
      VkMemoryPropertyFlags requiredFlags
      Flags that must be set in a Memory Type chosen for an allocation.
      Definition: vk_mem_alloc.h:1728
      +
      VmaPoolStats::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Size of the largest continuous free memory region.
      Definition: vk_mem_alloc.h:1904
      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:1272
      -
      VmaStatInfo
      Calculated statistics of memory usage in entire allocator.
      Definition: vk_mem_alloc.h:1415
      -
      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:1732
      -
      VmaDeviceMemoryCallbacks
      Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
      Definition: vk_mem_alloc.h:1225
      +
      VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
      PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
      Definition: vk_mem_alloc.h:1346
      +
      VmaStatInfo
      Calculated statistics of memory usage in entire allocator.
      Definition: vk_mem_alloc.h:1536
      +
      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:1853
      +
      VmaDeviceMemoryCallbacks
      Set of callbacks that the library will call for vkAllocateMemory and vkFreeMemory.
      Definition: vk_mem_alloc.h:1299
      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:1581
      -
      VmaStatInfo::unusedRangeSizeMin
      VkDeviceSize unusedRangeSizeMin
      Definition: vk_mem_alloc.h:1428
      -
      VmaDeviceMemoryCallbacks::pfnFree
      PFN_vmaFreeDeviceMemoryFunction pfnFree
      Optional, can be null.
      Definition: vk_mem_alloc.h:1229
      -
      VmaPoolCreateInfo::flags
      VmaPoolCreateFlags flags
      Use combination of VmaPoolCreateFlagBits.
      Definition: vk_mem_alloc.h:1727
      -
      VMA_MEMORY_USAGE_GPU_TO_CPU
      Definition: vk_mem_alloc.h:1520
      -
      VmaVulkanFunctions::vkInvalidateMappedMemoryRanges
      PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
      Definition: vk_mem_alloc.h:1278
      +
      VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
      Definition: vk_mem_alloc.h:1702
      +
      VmaStatInfo::unusedRangeSizeMin
      VkDeviceSize unusedRangeSizeMin
      Definition: vk_mem_alloc.h:1549
      +
      VmaDeviceMemoryCallbacks::pfnFree
      PFN_vmaFreeDeviceMemoryFunction pfnFree
      Optional, can be null.
      Definition: vk_mem_alloc.h:1303
      +
      VmaPoolCreateInfo::flags
      VmaPoolCreateFlags flags
      Use combination of VmaPoolCreateFlagBits.
      Definition: vk_mem_alloc.h:1848
      +
      VMA_MEMORY_USAGE_GPU_TO_CPU
      Definition: vk_mem_alloc.h:1641
      +
      VmaVulkanFunctions::vkInvalidateMappedMemoryRanges
      PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
      Definition: vk_mem_alloc.h:1352
      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:1602
      -
      VmaAllocationCreateInfo
      Definition: vk_mem_alloc.h:1593
      +
      VmaAllocationCreateInfo::usage
      VmaMemoryUsage usage
      Intended usage of memory.
      Definition: vk_mem_alloc.h:1723
      +
      VmaAllocationCreateInfo
      Definition: vk_mem_alloc.h:1714
      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:1418
      -
      VmaVulkanFunctions::vkFreeMemory
      PFN_vkFreeMemory vkFreeMemory
      Definition: vk_mem_alloc.h:1274
      -
      VmaPoolCreateInfo::maxBlockCount
      size_t maxBlockCount
      Maximum number of blocks that can be allocated in this pool. Optional.
      Definition: vk_mem_alloc.h:1745
      -
      VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
      const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
      Informative callbacks for vkAllocateMemory, vkFreeMemory. Optional.
      Definition: vk_mem_alloc.h:1312
      -
      VmaPoolStats::unusedRangeCount
      size_t unusedRangeCount
      Number of continuous memory ranges in the pool not used by any VmaAllocation.
      Definition: vk_mem_alloc.h:1776
      -
      VmaAllocationCreateFlags
      VkFlags VmaAllocationCreateFlags
      Definition: vk_mem_alloc.h:1591
      -
      VmaAllocationCreateInfo::pool
      VmaPool pool
      Pool that this allocation should be created in.
      Definition: vk_mem_alloc.h:1626
      +
      VmaStatInfo::blockCount
      uint32_t blockCount
      Number of VkDeviceMemory Vulkan memory blocks allocated.
      Definition: vk_mem_alloc.h:1539
      +
      VmaVulkanFunctions::vkFreeMemory
      PFN_vkFreeMemory vkFreeMemory
      Definition: vk_mem_alloc.h:1348
      +
      VmaPoolCreateInfo::maxBlockCount
      size_t maxBlockCount
      Maximum number of blocks that can be allocated in this pool. Optional.
      Definition: vk_mem_alloc.h:1866
      +
      VmaAllocatorCreateInfo::pDeviceMemoryCallbacks
      const VmaDeviceMemoryCallbacks * pDeviceMemoryCallbacks
      Informative callbacks for vkAllocateMemory, vkFreeMemory. Optional.
      Definition: vk_mem_alloc.h:1426
      +
      VmaPoolStats::unusedRangeCount
      size_t unusedRangeCount
      Number of continuous memory ranges in the pool not used by any VmaAllocation.
      Definition: vk_mem_alloc.h:1897
      +
      VmaAllocationCreateFlags
      VkFlags VmaAllocationCreateFlags
      Definition: vk_mem_alloc.h:1712
      +
      VmaAllocationCreateInfo::pool
      VmaPool pool
      Pool that this allocation should be created in.
      Definition: vk_mem_alloc.h:1747
      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:1350
      -
      VmaStats::memoryType
      VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
      Definition: vk_mem_alloc.h:1434
      -
      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:1561
      -
      VmaStatInfo::allocationSizeMin
      VkDeviceSize allocationSizeMin
      Definition: vk_mem_alloc.h:1427
      +
      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:1464
      +
      VmaStats::memoryType
      VmaStatInfo memoryType[VK_MAX_MEMORY_TYPES]
      Definition: vk_mem_alloc.h:1555
      +
      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:1682
      +
      VmaStatInfo::allocationSizeMin
      VkDeviceSize allocationSizeMin
      Definition: vk_mem_alloc.h:1548
      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:1285
      -
      VmaDeviceMemoryCallbacks::pfnAllocate
      PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
      Optional, can be null.
      Definition: vk_mem_alloc.h:1227
      -
      VmaVulkanFunctions::vkDestroyBuffer
      PFN_vkDestroyBuffer vkDestroyBuffer
      Definition: vk_mem_alloc.h:1284
      +
      VmaVulkanFunctions::vkCreateImage
      PFN_vkCreateImage vkCreateImage
      Definition: vk_mem_alloc.h:1359
      +
      VmaRecordSettings::flags
      VmaRecordFlags flags
      Flags for recording. Use VmaRecordFlagBits enum.
      Definition: vk_mem_alloc.h:1396
      +
      VmaDeviceMemoryCallbacks::pfnAllocate
      PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
      Optional, can be null.
      Definition: vk_mem_alloc.h:1301
      +
      VmaVulkanFunctions::vkDestroyBuffer
      PFN_vkDestroyBuffer vkDestroyBuffer
      Definition: vk_mem_alloc.h:1358
      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:1759
      -
      VmaVulkanFunctions::vkFlushMappedMemoryRanges
      PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
      Definition: vk_mem_alloc.h:1277
      +
      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:1880
      +
      VmaVulkanFunctions::vkFlushMappedMemoryRanges
      PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
      Definition: vk_mem_alloc.h:1351
      vmaAllocateMemoryForImage
      VkResult vmaAllocateMemoryForImage(VmaAllocator allocator, VkImage image, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
      Function similar to vmaAllocateMemoryForBuffer().
      VmaAllocatorCreateInfo
      struct VmaAllocatorCreateInfo VmaAllocatorCreateInfo
      Description of a Allocator to be created.
      -
      VmaAllocationInfo::pUserData
      void * pUserData
      Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
      Definition: vk_mem_alloc.h:1907
      -
      VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
      VkDeviceSize preferredLargeHeapBlockSize
      Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB...
      Definition: vk_mem_alloc.h:1306
      -
      VmaStatInfo::allocationSizeAvg
      VkDeviceSize allocationSizeAvg
      Definition: vk_mem_alloc.h:1427
      -
      VmaStatInfo::usedBytes
      VkDeviceSize usedBytes
      Total number of bytes occupied by all allocations.
      Definition: vk_mem_alloc.h:1424
      +
      VmaRecordSettings::pFilePath
      const char * pFilePath
      Path to the file that should be written by the recording.
      Definition: vk_mem_alloc.h:1404
      +
      VmaAllocationInfo::pUserData
      void * pUserData
      Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
      Definition: vk_mem_alloc.h:2028
      +
      VmaAllocatorCreateInfo::preferredLargeHeapBlockSize
      VkDeviceSize preferredLargeHeapBlockSize
      Preferred size of a single VkDeviceMemory block to be allocated from large heaps > 1 GiB...
      Definition: vk_mem_alloc.h:1420
      +
      VmaStatInfo::allocationSizeAvg
      VkDeviceSize allocationSizeAvg
      Definition: vk_mem_alloc.h:1548
      +
      VmaStatInfo::usedBytes
      VkDeviceSize usedBytes
      Total number of bytes occupied by all allocations.
      Definition: vk_mem_alloc.h:1545
      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:1764
      +
      VmaPoolStats
      Describes parameter of existing VmaPool.
      Definition: vk_mem_alloc.h:1885
      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:1888
      -
      VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1589
      -
      VmaDefragmentationStats::bytesMoved
      VkDeviceSize bytesMoved
      Total number of bytes that have been copied while moving allocations to different places...
      Definition: vk_mem_alloc.h:2134
      -
      VmaVulkanFunctions
      Pointers to some Vulkan functions - a subset used by the library.
      Definition: vk_mem_alloc.h:1270
      +
      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:2009
      +
      VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1710
      +
      VmaDefragmentationStats::bytesMoved
      VkDeviceSize bytesMoved
      Total number of bytes that have been copied while moving allocations to different places...
      Definition: vk_mem_alloc.h:2255
      +
      VmaVulkanFunctions
      Pointers to some Vulkan functions - a subset used by the library.
      Definition: vk_mem_alloc.h:1344
      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:1422
      -
      VMA_MEMORY_USAGE_UNKNOWN
      Definition: vk_mem_alloc.h:1477
      -
      VmaPoolCreateFlags
      VkFlags VmaPoolCreateFlags
      Definition: vk_mem_alloc.h:1717
      +
      VmaStatInfo::unusedRangeCount
      uint32_t unusedRangeCount
      Number of free ranges of memory between allocations.
      Definition: vk_mem_alloc.h:1543
      +
      VMA_MEMORY_USAGE_UNKNOWN
      Definition: vk_mem_alloc.h:1598
      +
      VmaPoolCreateFlags
      VkFlags VmaPoolCreateFlags
      Definition: vk_mem_alloc.h:1838
      vmaGetPhysicalDeviceProperties
      void vmaGetPhysicalDeviceProperties(VmaAllocator allocator, const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
      -
      VmaStatInfo::allocationCount
      uint32_t allocationCount
      Number of VmaAllocation allocation objects allocated.
      Definition: vk_mem_alloc.h:1420
      -
      VmaVulkanFunctions::vkGetImageMemoryRequirements
      PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
      Definition: vk_mem_alloc.h:1282
      -
      VmaVulkanFunctions::vkDestroyImage
      PFN_vkDestroyImage vkDestroyImage
      Definition: vk_mem_alloc.h:1286
      -
      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:1548
      -
      VMA_MEMORY_USAGE_CPU_ONLY
      Definition: vk_mem_alloc.h:1504
      -
      VmaAllocationInfo::pMappedData
      void * pMappedData
      Pointer to the beginning of this allocation as mapped data.
      Definition: vk_mem_alloc.h:1902
      +
      VmaRecordSettings
      Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSetting...
      Definition: vk_mem_alloc.h:1393
      +
      VmaStatInfo::allocationCount
      uint32_t allocationCount
      Number of VmaAllocation allocation objects allocated.
      Definition: vk_mem_alloc.h:1541
      +
      VmaVulkanFunctions::vkGetImageMemoryRequirements
      PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
      Definition: vk_mem_alloc.h:1356
      +
      VmaVulkanFunctions::vkDestroyImage
      PFN_vkDestroyImage vkDestroyImage
      Definition: vk_mem_alloc.h:1360
      +
      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:1669
      +
      VMA_MEMORY_USAGE_CPU_ONLY
      Definition: vk_mem_alloc.h:1625
      +
      VmaAllocationInfo::pMappedData
      void * pMappedData
      Pointer to the beginning of this allocation as mapped data.
      Definition: vk_mem_alloc.h:2023
      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:1260
      +
      VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
      Enables usage of VK_KHR_dedicated_allocation extension.
      Definition: vk_mem_alloc.h:1334
      VmaDefragmentationStats
      struct VmaDefragmentationStats VmaDefragmentationStats
      Statistics returned by function vmaDefragment().
      -
      VmaVulkanFunctions::vkAllocateMemory
      PFN_vkAllocateMemory vkAllocateMemory
      Definition: vk_mem_alloc.h:1273
      -
      VmaAllocationInfo
      Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
      Definition: vk_mem_alloc.h:1869
      +
      VmaVulkanFunctions::vkAllocateMemory
      PFN_vkAllocateMemory vkAllocateMemory
      Definition: vk_mem_alloc.h:1347
      +
      VmaAllocationInfo
      Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
      Definition: vk_mem_alloc.h:1990
      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:1695
      -
      VmaStatInfo::unusedRangeSizeAvg
      VkDeviceSize unusedRangeSizeAvg
      Definition: vk_mem_alloc.h:1428
      +
      VmaPoolCreateFlagBits
      VmaPoolCreateFlagBits
      Flags to be passed as VmaPoolCreateInfo::flags.
      Definition: vk_mem_alloc.h:1816
      +
      VmaStatInfo::unusedRangeSizeAvg
      VkDeviceSize unusedRangeSizeAvg
      Definition: vk_mem_alloc.h:1549
      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:1587
      -
      VmaStats::memoryHeap
      VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
      Definition: vk_mem_alloc.h:1435
      +
      VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
      Definition: vk_mem_alloc.h:1708
      +
      VmaRecordFlagBits
      VmaRecordFlagBits
      Flags to be used in VmaRecordSettings::flags.
      Definition: vk_mem_alloc.h:1368
      +
      VmaStats::memoryHeap
      VmaStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]
      Definition: vk_mem_alloc.h:1556
      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:1770
      -
      VmaStatInfo::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Definition: vk_mem_alloc.h:1428
      -
      VmaAllocationInfo::memoryType
      uint32_t memoryType
      Memory type index that this allocation was allocated from.
      Definition: vk_mem_alloc.h:1874
      +
      VmaPoolStats::unusedSize
      VkDeviceSize unusedSize
      Total number of bytes in the pool not used by any VmaAllocation.
      Definition: vk_mem_alloc.h:1891
      +
      VmaStatInfo::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Definition: vk_mem_alloc.h:1549
      +
      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:1995
      diff --git a/premake/premake5.lua b/premake/premake5.lua index 8893601..c6d2b93 100644 --- a/premake/premake5.lua +++ b/premake/premake5.lua @@ -12,7 +12,7 @@ startproject "VulkanSample" filter "platforms:x64" system "Windows" architecture "x64" -includedirs { "../third_party/mathfu-1.1.0/include", "$(VULKAN_SDK)/Include" } +includedirs { "$(VULKAN_SDK)/Include" } libdirs { "$(VULKAN_SDK)/Lib" } filter "platforms:Linux-x64" @@ -21,6 +21,7 @@ architecture "x64" includedirs { "$(VULKAN_SDK)/include" } libdirs { "$(VULKAN_SDK)/lib" } + project "VulkanSample" kind "ConsoleApp" language "C++" @@ -57,3 +58,41 @@ buildoptions { "/MDd" } filter { "configurations:Release", "platforms:Windows-x64" } buildoptions { "/MD" } + + +project "VmaReplay" +kind "ConsoleApp" +language "C++" +location "../build" +filename ("VmaReplay_" .. _SUFFIX) +targetdir "../bin" +objdir "../build/Desktop_%{_SUFFIX}/%{cfg.platform}/%{cfg.buildcfg}" +floatingpoint "Fast" +files { "../src/VmaReplay/*.h", "../src/VmaReplay/*.cpp" } +flags { "NoPCH", "FatalWarnings" } +characterset "Default" + +filter "configurations:Debug" +defines { "_DEBUG", "DEBUG" } +flags { } +targetsuffix ("_Debug_" .. _SUFFIX) + +filter "configurations:Release" +defines { "NDEBUG" } +optimize "On" +flags { "LinkTimeOptimization" } +targetsuffix ("_Release_" .. _SUFFIX) + +filter { "platforms:x64" } +defines { "WIN32", "_CONSOLE", "PROFILE", "_WINDOWS", "_WIN32_WINNT=0x0601" } +links { "vulkan-1" } + +filter { "platforms:Linux-x64" } +buildoptions { "-std=c++0x" } +links { "vulkan" } + +filter { "configurations:Debug", "platforms:x64" } +buildoptions { "/MDd" } + +filter { "configurations:Release", "platforms:Windows-x64" } +buildoptions { "/MD" } diff --git a/src/VmaReplay/Common.cpp b/src/VmaReplay/Common.cpp new file mode 100644 index 0000000..c324245 --- /dev/null +++ b/src/VmaReplay/Common.cpp @@ -0,0 +1,670 @@ +#include "Common.h" + +//////////////////////////////////////////////////////////////////////////////// +// LineSplit class + +bool LineSplit::GetNextLine(StrRange& out) +{ + if(m_NextLineBeg < m_NumBytes) + { + out.beg = m_Data + m_NextLineBeg; + size_t currLineEnd = m_NextLineBeg; + while(currLineEnd < m_NumBytes && m_Data[currLineEnd] != '\n') + ++currLineEnd; + out.end = m_Data + currLineEnd; + m_NextLineBeg = currLineEnd + 1; // Past '\n' + ++m_NextLineIndex; + return true; + } + else + return false; +} + +//////////////////////////////////////////////////////////////////////////////// +// CsvSplit class + +void CsvSplit::Set(const StrRange& line, size_t maxCount) +{ + assert(maxCount <= RANGE_COUNT_MAX); + m_Line = line; + const size_t strLen = line.length(); + size_t rangeIndex = 0; + size_t charIndex = 0; + while(charIndex < strLen && rangeIndex < maxCount) + { + m_Ranges[rangeIndex * 2] = charIndex; + while(charIndex < strLen && (rangeIndex + 1 == maxCount || m_Line.beg[charIndex] != ',')) + ++charIndex; + m_Ranges[rangeIndex * 2 + 1] = charIndex; + ++rangeIndex; + ++charIndex; // Past ',' + } + m_Count = rangeIndex; +} + +//////////////////////////////////////////////////////////////////////////////// +// class CmdLineParser + +bool CmdLineParser::ReadNextArg(std::string *OutArg) +{ + if (m_argv != NULL) + { + if (m_ArgIndex >= (size_t)m_argc) return false; + + *OutArg = m_argv[m_ArgIndex]; + m_ArgIndex++; + return true; + } + else + { + if (m_ArgIndex >= m_CmdLineLength) return false; + + OutArg->clear(); + bool InsideQuotes = false; + while (m_ArgIndex < m_CmdLineLength) + { + char Ch = m_CmdLine[m_ArgIndex]; + if (Ch == '\\') + { + bool FollowedByQuote = false; + size_t BackslashCount = 1; + size_t TmpIndex = m_ArgIndex + 1; + while (TmpIndex < m_CmdLineLength) + { + char TmpCh = m_CmdLine[TmpIndex]; + if (TmpCh == '\\') + { + BackslashCount++; + TmpIndex++; + } + else if (TmpCh == '"') + { + FollowedByQuote = true; + break; + } + else + break; + } + + if (FollowedByQuote) + { + if (BackslashCount % 2 == 0) + { + for (size_t i = 0; i < BackslashCount / 2; i++) + *OutArg += '\\'; + m_ArgIndex += BackslashCount + 1; + InsideQuotes = !InsideQuotes; + } + else + { + for (size_t i = 0; i < BackslashCount / 2; i++) + *OutArg += '\\'; + *OutArg += '"'; + m_ArgIndex += BackslashCount + 1; + } + } + else + { + for (size_t i = 0; i < BackslashCount; i++) + *OutArg += '\\'; + m_ArgIndex += BackslashCount; + } + } + else if (Ch == '"') + { + InsideQuotes = !InsideQuotes; + m_ArgIndex++; + } + else if (isspace(Ch)) + { + if (InsideQuotes) + { + *OutArg += Ch; + m_ArgIndex++; + } + else + { + m_ArgIndex++; + break; + } + } + else + { + *OutArg += Ch; + m_ArgIndex++; + } + } + + while (m_ArgIndex < m_CmdLineLength && isspace(m_CmdLine[m_ArgIndex])) + m_ArgIndex++; + + return true; + } +} + +CmdLineParser::SHORT_OPT * CmdLineParser::FindShortOpt(char Opt) +{ + for (size_t i = 0; i < m_ShortOpts.size(); i++) + if (m_ShortOpts[i].Opt == Opt) + return &m_ShortOpts[i]; + return NULL; +} + +CmdLineParser::LONG_OPT * CmdLineParser::FindLongOpt(const std::string &Opt) +{ + for (size_t i = 0; i < m_LongOpts.size(); i++) + if (m_LongOpts[i].Opt == Opt) + return &m_LongOpts[i]; + return NULL; +} + +CmdLineParser::CmdLineParser(int argc, char **argv) : + m_argv(argv), + m_CmdLine(NULL), + m_argc(argc), + m_CmdLineLength(0), + m_ArgIndex(1), + m_InsideMultioption(false), + m_LastArgIndex(0), + m_LastOptId(0) +{ + assert(argc > 0); + assert(argv != NULL); +} + +CmdLineParser::CmdLineParser(const char *CmdLine) : + m_argv(NULL), + m_CmdLine(CmdLine), + m_argc(0), + m_ArgIndex(0), + m_InsideMultioption(false), + m_LastArgIndex(0), + m_LastOptId(0) +{ + assert(CmdLine != NULL); + + m_CmdLineLength = strlen(m_CmdLine); + + while (m_ArgIndex < m_CmdLineLength && isspace(m_CmdLine[m_ArgIndex])) + m_ArgIndex++; +} + +void CmdLineParser::RegisterOpt(uint32_t Id, char Opt, bool Parameter) +{ + assert(Opt != '\0'); + + m_ShortOpts.push_back(SHORT_OPT(Id, Opt, Parameter)); +} + +void CmdLineParser::RegisterOpt(uint32_t Id, const std::string &Opt, bool Parameter) +{ + assert(!Opt.empty()); + + m_LongOpts.push_back(LONG_OPT(Id, Opt, Parameter)); +} + +CmdLineParser::RESULT CmdLineParser::ReadNext() +{ + if (m_InsideMultioption) + { + assert(m_LastArgIndex < m_LastArg.length()); + SHORT_OPT *so = FindShortOpt(m_LastArg[m_LastArgIndex]); + if (so == NULL) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + if (so->Parameter) + { + if (m_LastArg.length() == m_LastArgIndex+1) + { + if (!ReadNextArg(&m_LastParameter)) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + m_InsideMultioption = false; + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + else if (m_LastArg[m_LastArgIndex+1] == '=') + { + m_InsideMultioption = false; + m_LastParameter = m_LastArg.substr(m_LastArgIndex+2); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + else + { + m_InsideMultioption = false; + m_LastParameter = m_LastArg.substr(m_LastArgIndex+1); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + } + else + { + if (m_LastArg.length() == m_LastArgIndex+1) + { + m_InsideMultioption = false; + m_LastParameter.clear(); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + else + { + m_LastArgIndex++; + + m_LastParameter.clear(); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + } + } + else + { + if (!ReadNextArg(&m_LastArg)) + { + m_LastParameter.clear(); + m_LastOptId = 0; + return CmdLineParser::RESULT_END; + } + + if (!m_LastArg.empty() && m_LastArg[0] == '-') + { + if (m_LastArg.length() > 1 && m_LastArg[1] == '-') + { + size_t EqualIndex = m_LastArg.find('=', 2); + if (EqualIndex != std::string::npos) + { + LONG_OPT *lo = FindLongOpt(m_LastArg.substr(2, EqualIndex-2)); + if (lo == NULL || lo->Parameter == false) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + m_LastParameter = m_LastArg.substr(EqualIndex+1); + m_LastOptId = lo->Id; + return CmdLineParser::RESULT_OPT; + } + else + { + LONG_OPT *lo = FindLongOpt(m_LastArg.substr(2)); + if (lo == NULL) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + if (lo->Parameter) + { + if (!ReadNextArg(&m_LastParameter)) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + } + else + m_LastParameter.clear(); + m_LastOptId = lo->Id; + return CmdLineParser::RESULT_OPT; + } + } + else + { + if (m_LastArg.length() < 2) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + SHORT_OPT *so = FindShortOpt(m_LastArg[1]); + if (so == NULL) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + if (so->Parameter) + { + if (m_LastArg.length() == 2) + { + if (!ReadNextArg(&m_LastParameter)) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + else if (m_LastArg[2] == '=') + { + m_LastParameter = m_LastArg.substr(3); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + else + { + m_LastParameter = m_LastArg.substr(2); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + } + else + { + if (m_LastArg.length() == 2) + { + m_LastParameter.clear(); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + else + { + m_InsideMultioption = true; + m_LastArgIndex = 2; + + m_LastParameter.clear(); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + } + } + } + else if (!m_LastArg.empty() && m_LastArg[0] == '/') + { + size_t EqualIndex = m_LastArg.find('=', 1); + if (EqualIndex != std::string::npos) + { + if (EqualIndex == 2) + { + SHORT_OPT *so = FindShortOpt(m_LastArg[1]); + if (so != NULL) + { + if (so->Parameter == false) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + m_LastParameter = m_LastArg.substr(EqualIndex+1); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + } + LONG_OPT *lo = FindLongOpt(m_LastArg.substr(1, EqualIndex-1)); + if (lo == NULL || lo->Parameter == false) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + m_LastParameter = m_LastArg.substr(EqualIndex+1); + m_LastOptId = lo->Id; + return CmdLineParser::RESULT_OPT; + } + else + { + if (m_LastArg.length() == 2) + { + SHORT_OPT *so = FindShortOpt(m_LastArg[1]); + if (so != NULL) + { + if (so->Parameter) + { + if (!ReadNextArg(&m_LastParameter)) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + } + else + m_LastParameter.clear(); + m_LastOptId = so->Id; + return CmdLineParser::RESULT_OPT; + } + } + LONG_OPT *lo = FindLongOpt(m_LastArg.substr(1)); + if (lo == NULL) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + if (lo->Parameter) + { + if (!ReadNextArg(&m_LastParameter)) + { + m_LastOptId = 0; + m_LastParameter.clear(); + return CmdLineParser::RESULT_ERROR; + } + } + else + m_LastParameter.clear(); + m_LastOptId = lo->Id; + return CmdLineParser::RESULT_OPT; + } + } + else + { + m_LastOptId = 0; + m_LastParameter = m_LastArg; + return CmdLineParser::RESULT_PARAMETER; + } + } +} + +uint32_t CmdLineParser::GetOptId() +{ + return m_LastOptId; +} + +const std::string & CmdLineParser::GetParameter() +{ + return m_LastParameter; +} + +//////////////////////////////////////////////////////////////////////////////// +// Glolals + +/* + +void SetConsoleColor(CONSOLE_COLOR color) +{ + WORD attr = 0; + switch(color) + { + case CONSOLE_COLOR::INFO: + attr = FOREGROUND_INTENSITY;; + break; + case CONSOLE_COLOR::NORMAL: + attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; + break; + case CONSOLE_COLOR::WARNING: + attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; + break; + case CONSOLE_COLOR::ERROR_: + attr = FOREGROUND_RED | FOREGROUND_INTENSITY; + break; + default: + assert(0); + } + + HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); + SetConsoleTextAttribute(out, attr); +} + +void PrintMessage(CONSOLE_COLOR color, const char* msg) +{ + if(color != CONSOLE_COLOR::NORMAL) + SetConsoleColor(color); + + printf("%s\n", msg); + + if (color != CONSOLE_COLOR::NORMAL) + SetConsoleColor(CONSOLE_COLOR::NORMAL); +} + +void PrintMessage(CONSOLE_COLOR color, const wchar_t* msg) +{ + if(color != CONSOLE_COLOR::NORMAL) + SetConsoleColor(color); + + wprintf(L"%s\n", msg); + + if (color != CONSOLE_COLOR::NORMAL) + SetConsoleColor(CONSOLE_COLOR::NORMAL); +} + +static const size_t CONSOLE_SMALL_BUF_SIZE = 256; + +void PrintMessageV(CONSOLE_COLOR color, const char* format, va_list argList) +{ + size_t dstLen = (size_t)::_vscprintf(format, argList); + if(dstLen) + { + bool useSmallBuf = dstLen < CONSOLE_SMALL_BUF_SIZE; + char smallBuf[CONSOLE_SMALL_BUF_SIZE]; + std::vector bigBuf(useSmallBuf ? 0 : dstLen + 1); + char* bufPtr = useSmallBuf ? smallBuf : bigBuf.data(); + ::vsprintf_s(bufPtr, dstLen + 1, format, argList); + PrintMessage(color, bufPtr); + } +} + +void PrintMessageV(CONSOLE_COLOR color, const wchar_t* format, va_list argList) +{ + size_t dstLen = (size_t)::_vcwprintf(format, argList); + if(dstLen) + { + bool useSmallBuf = dstLen < CONSOLE_SMALL_BUF_SIZE; + wchar_t smallBuf[CONSOLE_SMALL_BUF_SIZE]; + std::vector bigBuf(useSmallBuf ? 0 : dstLen + 1); + wchar_t* bufPtr = useSmallBuf ? smallBuf : bigBuf.data(); + ::vswprintf_s(bufPtr, dstLen + 1, format, argList); + PrintMessage(color, bufPtr); + } +} + +void PrintMessageF(CONSOLE_COLOR color, const char* format, ...) +{ + va_list argList; + va_start(argList, format); + PrintMessageV(color, format, argList); + va_end(argList); +} + +void PrintMessageF(CONSOLE_COLOR color, const wchar_t* format, ...) +{ + va_list argList; + va_start(argList, format); + PrintMessageV(color, format, argList); + va_end(argList); +} + +void PrintWarningF(const char* format, ...) +{ + va_list argList; + va_start(argList, format); + PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); + va_end(argList); +} + +void PrintWarningF(const wchar_t* format, ...) +{ + va_list argList; + va_start(argList, format); + PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); + va_end(argList); +} + +void PrintErrorF(const char* format, ...) +{ + va_list argList; + va_start(argList, format); + PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); + va_end(argList); +} + +void PrintErrorF(const wchar_t* format, ...) +{ + va_list argList; + va_start(argList, format); + PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); + va_end(argList); +} +*/ + +void SecondsToFriendlyStr(float seconds, std::string& out) +{ + if(seconds == 0.f) + { + out = "0"; + return; + } + + if (seconds < 0.f) + { + out = "-"; + seconds = -seconds; + } + else + { + out.clear(); + } + + char s[32]; + + // #.### ns + if(seconds < 1e-6) + { + sprintf_s(s, "%.3f ns", seconds * 1e9); + out += s; + } + // #.### us + else if(seconds < 1e-3) + { + sprintf_s(s, "%.3f us", seconds * 1e6); + out += s; + } + // #.### ms + else if(seconds < 1.f) + { + sprintf_s(s, "%.3f ms", seconds * 1e3); + out += s; + } + // #.### s + else if(seconds < 60.f) + { + sprintf_s(s, "%.3f s", seconds); + out += s; + } + else + { + uint64_t seconds_u = (uint64_t)seconds; + // "#:## min" + if (seconds_u < 3600) + { + uint64_t minutes = seconds_u / 60; + seconds_u -= minutes * 60; + sprintf_s(s, "%llu:%02llu min", minutes, seconds_u); + out += s; + } + // "#:##:## h" + else + { + uint64_t minutes = seconds_u / 60; + seconds_u -= minutes * 60; + uint64_t hours = minutes / 60; + minutes -= hours * 60; + sprintf_s(s, "%llu:%02llu:%02llu h", hours, minutes, seconds_u); + out += s; + } + } +} diff --git a/src/VmaReplay/Common.h b/src/VmaReplay/Common.h new file mode 100644 index 0000000..28b5bbc --- /dev/null +++ b/src/VmaReplay/Common.h @@ -0,0 +1,391 @@ +#pragma once + +#include "VmaUsage.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +typedef std::chrono::high_resolution_clock::time_point time_point; +typedef std::chrono::high_resolution_clock::duration duration; + +inline float ToFloatSeconds(duration d) +{ + return std::chrono::duration_cast>(d).count(); +} + +void SecondsToFriendlyStr(float seconds, std::string& out); + +template +T ceil_div(T x, T y) +{ + return (x+y-1) / y; +} + +template +inline T align_up(T val, T align) +{ + return (val + align - 1) / align * align; +} + +struct StrRange +{ + const char* beg; + const char* end; + + StrRange() { } + StrRange(const char* beg, const char* end) : beg(beg), end(end) { } + explicit StrRange(const char* sz) : beg(sz), end(sz + strlen(sz)) { } + explicit StrRange(const std::string& s) : beg(s.data()), end(s.data() + s.length()) { } + + size_t length() const { return end - beg; } + void to_str(std::string& out) const { out.assign(beg, end); } +}; + +inline bool StrRangeEq(const StrRange& lhs, const char* rhsSz) +{ + const size_t rhsLen = strlen(rhsSz); + return rhsLen == lhs.length() && + memcmp(lhs.beg, rhsSz, rhsLen) == 0; +} + +inline bool StrRangeToUint(const StrRange& s, uint32_t& out) +{ + char* end = (char*)s.end; + out = (uint32_t)strtoul(s.beg, &end, 10); + return end == s.end; +} +inline bool StrRangeToUint(const StrRange& s, uint64_t& out) +{ + char* end = (char*)s.end; + out = (uint64_t)strtoull(s.beg, &end, 10); + return end == s.end; +} +inline bool StrRangeToPtr(const StrRange& s, uint64_t& out) +{ + char* end = (char*)s.end; + out = (uint64_t)strtoull(s.beg, &end, 16); + return end == s.end; +} +inline bool StrRangeToFloat(const StrRange& s, float& out) +{ + char* end = (char*)s.end; + out = strtof(s.beg, &end); + return end == s.end; +} +inline bool StrRangeToBool(const StrRange& s, bool& out) +{ + if(s.end - s.beg == 1) + { + if(*s.beg == '1') + { + out = true; + } + else if(*s.beg == '0') + { + out = false; + } + else + { + return false; + } + } + else + { + return false; + } + + return true; +} + +class LineSplit +{ +public: + LineSplit(const char* data, size_t numBytes) : + m_Data(data), + m_NumBytes(numBytes), + m_NextLineBeg(0), + m_NextLineIndex(0) + { + } + + bool GetNextLine(StrRange& out); + size_t GetNextLineIndex() const { return m_NextLineIndex; } + +private: + const char* const m_Data; + const size_t m_NumBytes; + size_t m_NextLineBeg; + size_t m_NextLineIndex; +}; + +class CsvSplit +{ +public: + static const size_t RANGE_COUNT_MAX = 32; + + void Set(const StrRange& line, size_t maxCount = RANGE_COUNT_MAX); + + const StrRange& GetLine() const { return m_Line; } + + size_t GetCount() const { return m_Count; } + StrRange GetRange(size_t index) const + { + return StrRange { + m_Line.beg + m_Ranges[index * 2], + m_Line.beg + m_Ranges[index * 2 + 1] }; + } + +private: + StrRange m_Line = { nullptr, nullptr }; + size_t m_Count = 0; + size_t m_Ranges[RANGE_COUNT_MAX * 2]; // Pairs of begin-end. +}; + +class CmdLineParser +{ +public: + enum RESULT + { + RESULT_OPT, + RESULT_PARAMETER, + RESULT_END, + RESULT_ERROR, + }; + + CmdLineParser(int argc, char **argv); + CmdLineParser(const char *CmdLine); + + void RegisterOpt(uint32_t Id, char Opt, bool Parameter); + void RegisterOpt(uint32_t Id, const std::string &Opt, bool Parameter); + + RESULT ReadNext(); + uint32_t GetOptId(); + const std::string & GetParameter(); + +private: + struct SHORT_OPT + { + uint32_t Id; + char Opt; + bool Parameter; + + SHORT_OPT(uint32_t Id, char Opt, bool Parameter) : Id(Id), Opt(Opt), Parameter(Parameter) { } + }; + + struct LONG_OPT + { + uint32_t Id; + std::string Opt; + bool Parameter; + + LONG_OPT(uint32_t Id, std::string Opt, bool Parameter) : Id(Id), Opt(Opt), Parameter(Parameter) { } + }; + + char **m_argv; + const char *m_CmdLine; + int m_argc; + size_t m_CmdLineLength; + size_t m_ArgIndex; + + bool ReadNextArg(std::string *OutArg); + + std::vector m_ShortOpts; + std::vector m_LongOpts; + + SHORT_OPT * FindShortOpt(char Opt); + LONG_OPT * FindLongOpt(const std::string &Opt); + + bool m_InsideMultioption; + std::string m_LastArg; + size_t m_LastArgIndex; + uint32_t m_LastOptId; + std::string m_LastParameter; +}; + +/* +Parses and stores a sequence of ranges. + +Upper range is inclusive. + +Examples: + + "1" -> [ {1, 1} ] + "1,10" -> [ {1, 1}, {10, 10} ] + "2-6" -> [ {2, 6} ] + "-8" -> [ {MIN, 8} ] + "12-" -> [ {12, MAX} ] + "1-10,12,15-" -> [ {1, 10}, {12, 12}, {15, MAX} ] + +TODO: Optimize it: Do sorting and merging while parsing. Do binary search while +reading. +*/ +template +class RangeSequence +{ +public: + typedef std::pair RangeType; + + void Clear() { m_Ranges.clear(); } + bool Parse(const StrRange& str); + + bool IsEmpty() const { return m_Ranges.empty(); } + size_t GetCount() const { return m_Ranges.size(); } + const RangeType* GetRanges() const { return m_Ranges.data(); } + + bool Includes(T number) const; + +private: + std::vector m_Ranges; +}; + +template +bool RangeSequence::Parse(const StrRange& str) +{ + m_Ranges.clear(); + + StrRange currRange = { str.beg, str.beg }; + while(currRange.beg < str.end) + { + currRange.end = currRange.beg + 1; + // Find next ',' or the end. + while(currRange.end < str.end && *currRange.end != ',') + { + ++currRange.end; + } + + // Find '-' within this range. + const char* hyphenPos = currRange.beg; + while(hyphenPos < currRange.end && *hyphenPos != '-') + { + ++hyphenPos; + } + + // No hyphen - single number like '10'. + if(hyphenPos == currRange.end) + { + RangeType range; + if(!StrRangeToUint(currRange, range.first)) + { + return false; + } + range.second = range.first; + m_Ranges.push_back(range); + } + // Hyphen at the end, like '10-'. + else if(hyphenPos + 1 == currRange.end) + { + const StrRange numberRange = { currRange.beg, hyphenPos }; + RangeType range; + if(!StrRangeToUint(numberRange, range.first)) + { + return false; + } + range.second = std::numeric_limits::max(); + m_Ranges.push_back(range); + } + // Hyphen at the beginning, like "-10". + else if(hyphenPos == currRange.beg) + { + const StrRange numberRange = { currRange.beg + 1, currRange.end }; + RangeType range; + range.first = std::numeric_limits::min(); + if(!StrRangeToUint(numberRange, range.second)) + { + return false; + } + m_Ranges.push_back(range); + } + // Hyphen in the middle, like "1-10". + else + { + const StrRange numberRange1 = { currRange.beg, hyphenPos }; + const StrRange numberRange2 = { hyphenPos + 1, currRange.end }; + RangeType range; + if(!StrRangeToUint(numberRange1, range.first) || + !StrRangeToUint(numberRange2, range.second) || + range.second < range.first) + { + return false; + } + m_Ranges.push_back(range); + } + + // Skip ',' + currRange.beg = currRange.end + 1; + } + + return true; +} + +template +bool RangeSequence::Includes(T number) const +{ + for(const auto& it : m_Ranges) + { + if(number >= it.first && number <= it.second) + { + return true; + } + } + return false; +} + +/* +class RandomNumberGenerator +{ +public: + RandomNumberGenerator() : m_Value{GetTickCount()} {} + RandomNumberGenerator(uint32_t seed) : m_Value{seed} { } + void Seed(uint32_t seed) { m_Value = seed; } + uint32_t Generate() { return GenerateFast() ^ (GenerateFast() >> 7); } + +private: + uint32_t m_Value; + uint32_t GenerateFast() { return m_Value = (m_Value * 196314165 + 907633515); } +}; + +enum class CONSOLE_COLOR +{ + INFO, + NORMAL, + WARNING, + ERROR_, + COUNT +}; + +void SetConsoleColor(CONSOLE_COLOR color); + +void PrintMessage(CONSOLE_COLOR color, const char* msg); +void PrintMessage(CONSOLE_COLOR color, const wchar_t* msg); + +inline void Print(const char* msg) { PrintMessage(CONSOLE_COLOR::NORMAL, msg); } +inline void Print(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::NORMAL, msg); } +inline void PrintWarning(const char* msg) { PrintMessage(CONSOLE_COLOR::WARNING, msg); } +inline void PrintWarning(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::WARNING, msg); } +inline void PrintError(const char* msg) { PrintMessage(CONSOLE_COLOR::ERROR_, msg); } +inline void PrintError(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::ERROR_, msg); } + +void PrintMessageV(CONSOLE_COLOR color, const char* format, va_list argList); +void PrintMessageV(CONSOLE_COLOR color, const wchar_t* format, va_list argList); +void PrintMessageF(CONSOLE_COLOR color, const char* format, ...); +void PrintMessageF(CONSOLE_COLOR color, const wchar_t* format, ...); +void PrintWarningF(const char* format, ...); +void PrintWarningF(const wchar_t* format, ...); +void PrintErrorF(const char* format, ...); +void PrintErrorF(const wchar_t* format, ...); +*/ diff --git a/src/VmaReplay/VmaReplay.cpp b/src/VmaReplay/VmaReplay.cpp new file mode 100644 index 0000000..9635b03 --- /dev/null +++ b/src/VmaReplay/VmaReplay.cpp @@ -0,0 +1,3000 @@ +// +// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// + +#include "VmaUsage.h" +#include "Common.h" +#include + +static const int RESULT_EXCEPTION = -1000; +static const int RESULT_ERROR_COMMAND_LINE = -1; +static const int RESULT_ERROR_SOURCE_FILE = -2; +static const int RESULT_ERROR_FORMAT = -3; +static const int RESULT_ERROR_VULKAN = -4; + +enum CMD_LINE_OPT +{ + CMD_LINE_OPT_VERBOSITY, + CMD_LINE_OPT_ITERATIONS, + CMD_LINE_OPT_LINES, + CMD_LINE_OPT_PHYSICAL_DEVICE, + CMD_LINE_OPT_USER_DATA, + CMD_LINE_OPT_VK_KHR_DEDICATED_ALLOCATION, + CMD_LINE_OPT_VK_LAYER_LUNARG_STANDARD_VALIDATION, + CMD_LINE_OPT_MEM_STATS, + CMD_LINE_OPT_DUMP_STATS_AFTER_LINE, + CMD_LINE_OPT_DUMP_DETAILED_STATS_AFTER_LINE, +}; + +static enum class VERBOSITY +{ + MINIMUM = 0, + DEFAULT, + MAXIMUM, + COUNT, +} g_Verbosity = VERBOSITY::DEFAULT; + +enum class VULKAN_EXTENSION_REQUEST +{ + DISABLED, + ENABLED, + DEFAULT +}; + +enum class OBJECT_TYPE { BUFFER, IMAGE }; + +enum class VMA_FUNCTION +{ + CreatePool, + DestroyPool, + SetAllocationUserData, + CreateBuffer, + DestroyBuffer, + CreateImage, + DestroyImage, + FreeMemory, + CreateLostAllocation, + AllocateMemory, + AllocateMemoryForBuffer, + AllocateMemoryForImage, + MapMemory, + UnmapMemory, + FlushAllocation, + InvalidateAllocation, + TouchAllocation, + GetAllocationInfo, + MakePoolAllocationsLost, + Count +}; +static const char* VMA_FUNCTION_NAMES[] = { + "vmaCreatePool", + "vmaDestroyPool", + "vmaSetAllocationUserData", + "vmaCreateBuffer", + "vmaDestroyBuffer", + "vmaCreateImage", + "vmaDestroyImage", + "vmaFreeMemory", + "vmaCreateLostAllocation", + "vmaAllocateMemory", + "vmaAllocateMemoryForBuffer", + "vmaAllocateMemoryForImage", + "vmaMapMemory", + "vmaUnmapMemory", + "vmaFlushAllocation", + "vmaInvalidateAllocation", + "vmaTouchAllocation", + "vmaGetAllocationInfo", + "vmaMakePoolAllocationsLost", +}; +static_assert( + _countof(VMA_FUNCTION_NAMES) == (size_t)VMA_FUNCTION::Count, + "VMA_FUNCTION_NAMES array doesn't match VMA_FUNCTION enum."); + +// Set this to false to disable deleting leaked VmaAllocation, VmaPool objects +// and let VMA report asserts about them. +static const bool CLEANUP_LEAKED_OBJECTS = true; + +static std::string g_FilePath; +// Most significant 16 bits are major version, least significant 16 bits are minor version. +static uint32_t g_FileVersion; + +inline uint32_t MakeVersion(uint32_t major, uint32_t minor) { return (major << 16) | minor; } +inline uint32_t GetVersionMajor(uint32_t version) { return version >> 16; } +inline uint32_t GetVersionMinor(uint32_t version) { return version & 0xFFFF; } + +static size_t g_IterationCount = 1; +static uint32_t g_PhysicalDeviceIndex = 0; +static RangeSequence g_LineRanges; +static bool g_UserDataEnabled = true; +static bool g_MemStatsEnabled = false; +VULKAN_EXTENSION_REQUEST g_VK_KHR_dedicated_allocation_request = VULKAN_EXTENSION_REQUEST::DEFAULT; +VULKAN_EXTENSION_REQUEST g_VK_LAYER_LUNARG_standard_validation = VULKAN_EXTENSION_REQUEST::DEFAULT; + +struct StatsAfterLineEntry +{ + size_t line; + bool detailed; + + bool operator<(const StatsAfterLineEntry& rhs) const { return line < rhs.line; } + bool operator==(const StatsAfterLineEntry& rhs) const { return line == rhs.line; } +}; +static std::vector g_DumpStatsAfterLine; +static size_t g_DumpStatsAfterLineNextIndex = 0; + +static bool ValidateFileVersion() +{ + if(GetVersionMajor(g_FileVersion) == 1 && + GetVersionMinor(g_FileVersion) <= 3) + { + return true; + } + + return false; +} + +static bool ParseFileVersion(const StrRange& s) +{ + CsvSplit csvSplit; + csvSplit.Set(s, 2); + uint32_t major, minor; + if(csvSplit.GetCount() == 2 && + StrRangeToUint(csvSplit.GetRange(0), major) && + StrRangeToUint(csvSplit.GetRange(1), minor)) + { + g_FileVersion = (major << 16) | minor; + return true; + } + else + { + return false; + } +} + +//////////////////////////////////////////////////////////////////////////////// +// class Statistics + +class Statistics +{ +public: + static uint32_t BufferUsageToClass(uint32_t usage); + static uint32_t ImageUsageToClass(uint32_t usage); + + Statistics(); + void Init(uint32_t memHeapCount, uint32_t memTypeCount); + void PrintMemStats() const; + + const size_t* GetFunctionCallCount() const { return m_FunctionCallCount; } + size_t GetImageCreationCount(uint32_t imgClass) const { return m_ImageCreationCount[imgClass]; } + size_t GetLinearImageCreationCount() const { return m_LinearImageCreationCount; } + size_t GetBufferCreationCount(uint32_t bufClass) const { return m_BufferCreationCount[bufClass]; } + size_t GetAllocationCreationCount() const { return m_AllocationCreationCount; } + size_t GetPoolCreationCount() const { return m_PoolCreationCount; } + + void RegisterFunctionCall(VMA_FUNCTION func); + void RegisterCreateImage(uint32_t usage, uint32_t tiling); + void RegisterCreateBuffer(uint32_t usage); + void RegisterCreatePool(); + void RegisterCreateAllocation(); + + void UpdateMemStats(const VmaStats& currStats); + +private: + uint32_t m_MemHeapCount = 0; + uint32_t m_MemTypeCount = 0; + + size_t m_FunctionCallCount[(size_t)VMA_FUNCTION::Count] = {}; + size_t m_ImageCreationCount[4] = { }; + size_t m_LinearImageCreationCount = 0; + size_t m_BufferCreationCount[4] = { }; + size_t m_AllocationCreationCount = 0; // Also includes buffers and images, and lost allocations. + size_t m_PoolCreationCount = 0; + + // Structure similar to VmaStatInfo, but not the same. + struct MemStatInfo + { + uint32_t blockCount; + uint32_t allocationCount; + uint32_t unusedRangeCount; + VkDeviceSize usedBytes; + VkDeviceSize unusedBytes; + VkDeviceSize totalBytes; + }; + struct MemStats + { + MemStatInfo memoryType[VK_MAX_MEMORY_TYPES]; + MemStatInfo memoryHeap[VK_MAX_MEMORY_HEAPS]; + MemStatInfo total; + } m_PeakMemStats; + + void UpdateMemStatInfo(MemStatInfo& inoutPeakInfo, const VmaStatInfo& currInfo); + static void PrintMemStatInfo(const MemStatInfo& info); +}; + +uint32_t Statistics::BufferUsageToClass(uint32_t usage) +{ + // Buffer is used as source of data for fixed-function stage of graphics pipeline. + // It's indirect, vertex, or index buffer. + if ((usage & (VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | + VK_BUFFER_USAGE_INDEX_BUFFER_BIT)) != 0) + { + return 0; + } + // Buffer is accessed by shaders for load/store/atomic. + // Aka "UAV" + else if ((usage & (VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) != 0) + { + return 1; + } + // Buffer is accessed by shaders for reading uniform data. + // Aka "constant buffer" + else if ((usage & (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)) != 0) + { + return 2; + } + // Any other type of buffer. + // Notice that VK_BUFFER_USAGE_TRANSFER_SRC_BIT and VK_BUFFER_USAGE_TRANSFER_DST_BIT + // flags are intentionally ignored. + else + { + return 3; + } +} + +uint32_t Statistics::ImageUsageToClass(uint32_t usage) +{ + // Image is used as depth/stencil "texture/surface". + if ((usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0) + { + return 0; + } + // Image is used as other type of attachment. + // Aka "render target" + else if ((usage & (VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) != 0) + { + return 1; + } + // Image is accessed by shaders for sampling. + // Aka "texture" + else if ((usage & VK_IMAGE_USAGE_SAMPLED_BIT) != 0) + { + return 2; + } + // Any other type of image. + // Notice that VK_IMAGE_USAGE_TRANSFER_SRC_BIT and VK_IMAGE_USAGE_TRANSFER_DST_BIT + // flags are intentionally ignored. + else + { + return 3; + } +} + +Statistics::Statistics() +{ + ZeroMemory(&m_PeakMemStats, sizeof(m_PeakMemStats)); +} + +void Statistics::Init(uint32_t memHeapCount, uint32_t memTypeCount) +{ + m_MemHeapCount = memHeapCount; + m_MemTypeCount = memTypeCount; +} + +void Statistics::PrintMemStats() const +{ + printf("Memory statistics:\n"); + + printf(" Total:\n"); + PrintMemStatInfo(m_PeakMemStats.total); + + for(uint32_t i = 0; i < m_MemHeapCount; ++i) + { + const MemStatInfo& info = m_PeakMemStats.memoryHeap[i]; + if(info.blockCount > 0 || info.totalBytes > 0) + { + printf(" Heap %u:\n", i); + PrintMemStatInfo(info); + } + } + + for(uint32_t i = 0; i < m_MemTypeCount; ++i) + { + const MemStatInfo& info = m_PeakMemStats.memoryType[i]; + if(info.blockCount > 0 || info.totalBytes > 0) + { + printf(" Type %u:\n", i); + PrintMemStatInfo(info); + } + } +} + +void Statistics::RegisterFunctionCall(VMA_FUNCTION func) +{ + ++m_FunctionCallCount[(size_t)func]; +} + +void Statistics::RegisterCreateImage(uint32_t usage, uint32_t tiling) +{ + if(tiling == VK_IMAGE_TILING_LINEAR) + ++m_LinearImageCreationCount; + else + { + const uint32_t imgClass = ImageUsageToClass(usage); + ++m_ImageCreationCount[imgClass]; + } + + ++m_AllocationCreationCount; +} + +void Statistics::RegisterCreateBuffer(uint32_t usage) +{ + const uint32_t bufClass = BufferUsageToClass(usage); + ++m_BufferCreationCount[bufClass]; + + ++m_AllocationCreationCount; +} + +void Statistics::RegisterCreatePool() +{ + ++m_PoolCreationCount; +} + +void Statistics::RegisterCreateAllocation() +{ + ++m_AllocationCreationCount; +} + +void Statistics::UpdateMemStats(const VmaStats& currStats) +{ + UpdateMemStatInfo(m_PeakMemStats.total, currStats.total); + + for(uint32_t i = 0; i < m_MemHeapCount; ++i) + { + UpdateMemStatInfo(m_PeakMemStats.memoryHeap[i], currStats.memoryHeap[i]); + } + + for(uint32_t i = 0; i < m_MemTypeCount; ++i) + { + UpdateMemStatInfo(m_PeakMemStats.memoryType[i], currStats.memoryType[i]); + } +} + +void Statistics::UpdateMemStatInfo(MemStatInfo& inoutPeakInfo, const VmaStatInfo& currInfo) +{ +#define SET_PEAK(inoutDst, src) \ + if((src) > (inoutDst)) \ + { \ + (inoutDst) = (src); \ + } + + SET_PEAK(inoutPeakInfo.blockCount, currInfo.blockCount); + SET_PEAK(inoutPeakInfo.allocationCount, currInfo.allocationCount); + SET_PEAK(inoutPeakInfo.unusedRangeCount, currInfo.unusedRangeCount); + SET_PEAK(inoutPeakInfo.usedBytes, currInfo.usedBytes); + SET_PEAK(inoutPeakInfo.unusedBytes, currInfo.unusedBytes); + SET_PEAK(inoutPeakInfo.totalBytes, currInfo.usedBytes + currInfo.unusedBytes); + +#undef SET_PEAK +} + +void Statistics::PrintMemStatInfo(const MemStatInfo& info) +{ + printf(" Peak blocks %u, allocations %u, unused ranges %u\n", + info.blockCount, + info.allocationCount, + info.unusedRangeCount); + printf(" Peak total bytes %llu, used bytes %llu, unused bytes %llu\n", + info.totalBytes, + info.usedBytes, + info.unusedBytes); +} + +//////////////////////////////////////////////////////////////////////////////// +// class ConfigurationParser + +class ConfigurationParser +{ +public: + ConfigurationParser(); + + bool Parse(LineSplit& lineSplit); + + void Compare( + const VkPhysicalDeviceProperties& currDevProps, + const VkPhysicalDeviceMemoryProperties& currMemProps, + bool currDedicatedAllocationExtensionEnabled); + +private: + enum class OPTION + { + PhysicalDevice_apiVersion, + PhysicalDevice_driverVersion, + PhysicalDevice_vendorID, + PhysicalDevice_deviceID, + PhysicalDevice_deviceType, + PhysicalDevice_deviceName, + PhysicalDeviceLimits_maxMemoryAllocationCount, + PhysicalDeviceLimits_bufferImageGranularity, + PhysicalDeviceLimits_nonCoherentAtomSize, + Extension_VK_KHR_dedicated_allocation, + Macro_VMA_DEBUG_ALWAYS_DEDICATED_MEMORY, + Macro_VMA_DEBUG_ALIGNMENT, + Macro_VMA_DEBUG_MARGIN, + Macro_VMA_DEBUG_INITIALIZE_ALLOCATIONS, + Macro_VMA_DEBUG_DETECT_CORRUPTION, + Macro_VMA_DEBUG_GLOBAL_MUTEX, + Macro_VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY, + Macro_VMA_SMALL_HEAP_MAX_SIZE, + Macro_VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE, + Count + }; + + std::vector m_OptionSet; + std::vector m_OptionValue; + VkPhysicalDeviceMemoryProperties m_MemProps; + + bool m_WarningHeaderPrinted = false; + + void SetOption( + size_t lineNumber, + OPTION option, + const StrRange& str); + void EnsureWarningHeader(); + void CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, uint32_t currValue); + void CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, uint64_t currValue); + void CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, bool currValue); + void CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, const char* currValue); + void CompareMemProps( + const VkPhysicalDeviceMemoryProperties& currMemProps); +}; + +ConfigurationParser::ConfigurationParser() : + m_OptionSet((size_t)OPTION::Count), + m_OptionValue((size_t)OPTION::Count) +{ + ZeroMemory(&m_MemProps, sizeof(m_MemProps)); +} + +bool ConfigurationParser::Parse(LineSplit& lineSplit) +{ + for(auto& it : m_OptionSet) + { + it = false; + } + for(auto& it : m_OptionValue) + { + it.clear(); + } + + StrRange line; + + if(!lineSplit.GetNextLine(line) && !StrRangeEq(line, "Config,Begin")) + { + return false; + } + + CsvSplit csvSplit; + while(lineSplit.GetNextLine(line)) + { + if(StrRangeEq(line, "Config,End")) + { + break; + } + + const size_t currLineNumber = lineSplit.GetNextLineIndex(); + + csvSplit.Set(line); + if(csvSplit.GetCount() == 0) + { + return false; + } + + const StrRange optionName = csvSplit.GetRange(0); + if(StrRangeEq(optionName, "PhysicalDevice")) + { + if(csvSplit.GetCount() >= 3) + { + const StrRange subOptionName = csvSplit.GetRange(1); + if(StrRangeEq(subOptionName, "apiVersion")) + SetOption(currLineNumber, OPTION::PhysicalDevice_apiVersion, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "driverVersion")) + SetOption(currLineNumber, OPTION::PhysicalDevice_driverVersion, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "vendorID")) + SetOption(currLineNumber, OPTION::PhysicalDevice_vendorID, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "deviceID")) + SetOption(currLineNumber, OPTION::PhysicalDevice_deviceID, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "deviceType")) + SetOption(currLineNumber, OPTION::PhysicalDevice_deviceType, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "deviceName")) + SetOption(currLineNumber, OPTION::PhysicalDevice_deviceName, StrRange(csvSplit.GetRange(2).beg, line.end)); + else + printf("Line %zu: Unrecognized configuration option.\n", currLineNumber); + } + else + printf("Line %zu: Too few columns.\n", currLineNumber); + } + else if(StrRangeEq(optionName, "PhysicalDeviceLimits")) + { + if(csvSplit.GetCount() >= 3) + { + const StrRange subOptionName = csvSplit.GetRange(1); + if(StrRangeEq(subOptionName, "maxMemoryAllocationCount")) + SetOption(currLineNumber, OPTION::PhysicalDeviceLimits_maxMemoryAllocationCount, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "bufferImageGranularity")) + SetOption(currLineNumber, OPTION::PhysicalDeviceLimits_bufferImageGranularity, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "nonCoherentAtomSize")) + SetOption(currLineNumber, OPTION::PhysicalDeviceLimits_nonCoherentAtomSize, csvSplit.GetRange(2)); + else + printf("Line %zu: Unrecognized configuration option.\n", currLineNumber); + } + else + printf("Line %zu: Too few columns.\n", currLineNumber); + } + else if(StrRangeEq(optionName, "Extension")) + { + if(csvSplit.GetCount() >= 3) + { + const StrRange subOptionName = csvSplit.GetRange(1); + if(StrRangeEq(subOptionName, "VK_KHR_dedicated_allocation")) + SetOption(currLineNumber, OPTION::Extension_VK_KHR_dedicated_allocation, csvSplit.GetRange(2)); + else + printf("Line %zu: Unrecognized configuration option.\n", currLineNumber); + } + else + printf("Line %zu: Too few columns.\n", currLineNumber); + } + else if(StrRangeEq(optionName, "Macro")) + { + if(csvSplit.GetCount() >= 3) + { + const StrRange subOptionName = csvSplit.GetRange(1); + if(StrRangeEq(subOptionName, "VMA_DEBUG_ALWAYS_DEDICATED_MEMORY")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_ALWAYS_DEDICATED_MEMORY, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEBUG_ALIGNMENT")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_ALIGNMENT, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEBUG_MARGIN")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_MARGIN, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEBUG_INITIALIZE_ALLOCATIONS")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_INITIALIZE_ALLOCATIONS, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEBUG_DETECT_CORRUPTION")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_DETECT_CORRUPTION, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEBUG_GLOBAL_MUTEX")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_GLOBAL_MUTEX, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_SMALL_HEAP_MAX_SIZE")) + SetOption(currLineNumber, OPTION::Macro_VMA_SMALL_HEAP_MAX_SIZE, csvSplit.GetRange(2)); + else if(StrRangeEq(subOptionName, "VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE")) + SetOption(currLineNumber, OPTION::Macro_VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE, csvSplit.GetRange(2)); + else + printf("Line %zu: Unrecognized configuration option.\n", currLineNumber); + } + else + printf("Line %zu: Too few columns.\n", currLineNumber); + } + else if(StrRangeEq(optionName, "PhysicalDeviceMemory")) + { + uint32_t value = 0; + if(csvSplit.GetCount() == 3 && StrRangeEq(csvSplit.GetRange(1), "HeapCount") && + StrRangeToUint(csvSplit.GetRange(2), value)) + { + m_MemProps.memoryHeapCount = value; + } + else if(csvSplit.GetCount() == 3 && StrRangeEq(csvSplit.GetRange(1), "TypeCount") && + StrRangeToUint(csvSplit.GetRange(2), value)) + { + m_MemProps.memoryTypeCount = value; + } + else if(csvSplit.GetCount() == 5 && StrRangeEq(csvSplit.GetRange(1), "Heap") && + StrRangeToUint(csvSplit.GetRange(2), value) && + value < m_MemProps.memoryHeapCount) + { + if(StrRangeEq(csvSplit.GetRange(3), "size") && + StrRangeToUint(csvSplit.GetRange(4), m_MemProps.memoryHeaps[value].size)) + { + // Parsed. + } + else if(StrRangeEq(csvSplit.GetRange(3), "flags") && + StrRangeToUint(csvSplit.GetRange(4), m_MemProps.memoryHeaps[value].flags)) + { + // Parsed. + } + else + printf("Line %zu: Invalid configuration option.\n", currLineNumber); + } + else if(csvSplit.GetCount() == 5 && StrRangeEq(csvSplit.GetRange(1), "Type") && + StrRangeToUint(csvSplit.GetRange(2), value) && + value < m_MemProps.memoryTypeCount) + { + if(StrRangeEq(csvSplit.GetRange(3), "heapIndex") && + StrRangeToUint(csvSplit.GetRange(4), m_MemProps.memoryTypes[value].heapIndex)) + { + // Parsed. + } + else if(StrRangeEq(csvSplit.GetRange(3), "propertyFlags") && + StrRangeToUint(csvSplit.GetRange(4), m_MemProps.memoryTypes[value].propertyFlags)) + { + // Parsed. + } + else + printf("Line %zu: Invalid configuration option.\n", currLineNumber); + } + else + printf("Line %zu: Invalid configuration option.\n", currLineNumber); + } + else + printf("Line %zu: Unrecognized configuration option.\n", currLineNumber); + } + + return true; +} + +void ConfigurationParser::Compare( + const VkPhysicalDeviceProperties& currDevProps, + const VkPhysicalDeviceMemoryProperties& currMemProps, + bool currDedicatedAllocationExtensionEnabled) +{ + CompareOption(VERBOSITY::MAXIMUM, "PhysicalDevice apiVersion", + OPTION::PhysicalDevice_apiVersion, currDevProps.apiVersion); + CompareOption(VERBOSITY::MAXIMUM, "PhysicalDevice driverVersion", + OPTION::PhysicalDevice_driverVersion, currDevProps.driverVersion); + CompareOption(VERBOSITY::MAXIMUM, "PhysicalDevice vendorID", + OPTION::PhysicalDevice_vendorID, currDevProps.vendorID); + CompareOption(VERBOSITY::MAXIMUM, "PhysicalDevice deviceID", + OPTION::PhysicalDevice_deviceID, currDevProps.deviceID); + CompareOption(VERBOSITY::MAXIMUM, "PhysicalDevice deviceType", + OPTION::PhysicalDevice_deviceType, (uint32_t)currDevProps.deviceType); + CompareOption(VERBOSITY::MAXIMUM, "PhysicalDevice deviceName", + OPTION::PhysicalDevice_deviceName, currDevProps.deviceName); + + CompareOption(VERBOSITY::DEFAULT, "PhysicalDeviceLimits maxMemoryAllocationCount", + OPTION::PhysicalDeviceLimits_maxMemoryAllocationCount, currDevProps.limits.maxMemoryAllocationCount); + CompareOption(VERBOSITY::DEFAULT, "PhysicalDeviceLimits bufferImageGranularity", + OPTION::PhysicalDeviceLimits_bufferImageGranularity, currDevProps.limits.bufferImageGranularity); + CompareOption(VERBOSITY::DEFAULT, "PhysicalDeviceLimits nonCoherentAtomSize", + OPTION::PhysicalDeviceLimits_nonCoherentAtomSize, currDevProps.limits.nonCoherentAtomSize); + CompareOption(VERBOSITY::DEFAULT, "Extension VK_KHR_dedicated_allocation", + OPTION::Extension_VK_KHR_dedicated_allocation, currDedicatedAllocationExtensionEnabled); + + CompareMemProps(currMemProps); +} + +void ConfigurationParser::SetOption( + size_t lineNumber, + OPTION option, + const StrRange& str) +{ + if(m_OptionSet[(size_t)option]) + { + printf("Line %zu: Option already specified.\n" ,lineNumber); + } + + m_OptionSet[(size_t)option] = true; + + std::string val; + str.to_str(val); + m_OptionValue[(size_t)option] = std::move(val); +} + +void ConfigurationParser::EnsureWarningHeader() +{ + if(!m_WarningHeaderPrinted) + { + printf("WARNING: Following configuration parameters don't match:\n"); + m_WarningHeaderPrinted = true; + } +} + +void ConfigurationParser::CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, uint32_t currValue) +{ + if(m_OptionSet[(size_t)option] && + g_Verbosity >= minVerbosity) + { + uint32_t origValue; + if(StrRangeToUint(StrRange(m_OptionValue[(size_t)option]), origValue)) + { + if(origValue != currValue) + { + EnsureWarningHeader(); + printf(" %s: original %u, current %u\n", name, origValue, currValue); + } + } + } +} + +void ConfigurationParser::CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, uint64_t currValue) +{ + if(m_OptionSet[(size_t)option] && + g_Verbosity >= minVerbosity) + { + uint64_t origValue; + if(StrRangeToUint(StrRange(m_OptionValue[(size_t)option]), origValue)) + { + if(origValue != currValue) + { + EnsureWarningHeader(); + printf(" %s: original %llu, current %llu\n", name, origValue, currValue); + } + } + } +} + +void ConfigurationParser::CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, bool currValue) +{ + if(m_OptionSet[(size_t)option] && + g_Verbosity >= minVerbosity) + { + bool origValue; + if(StrRangeToBool(StrRange(m_OptionValue[(size_t)option]), origValue)) + { + if(origValue != currValue) + { + EnsureWarningHeader(); + printf(" %s: original %u, current %u\n", name, + origValue ? 1 : 0, + currValue ? 1 : 0); + } + } + } +} + +void ConfigurationParser::CompareOption(VERBOSITY minVerbosity, const char* name, + OPTION option, const char* currValue) +{ + if(m_OptionSet[(size_t)option] && + g_Verbosity >= minVerbosity) + { + const std::string& origValue = m_OptionValue[(size_t)option]; + if(origValue != currValue) + { + EnsureWarningHeader(); + printf(" %s: original \"%s\", current \"%s\"\n", name, origValue.c_str(), currValue); + } + } +} + +void ConfigurationParser::CompareMemProps( + const VkPhysicalDeviceMemoryProperties& currMemProps) +{ + if(g_Verbosity < VERBOSITY::DEFAULT) + { + return; + } + + bool memoryMatch = + currMemProps.memoryHeapCount == m_MemProps.memoryHeapCount && + currMemProps.memoryTypeCount == m_MemProps.memoryTypeCount; + + for(uint32_t i = 0; memoryMatch && i < currMemProps.memoryHeapCount; ++i) + { + memoryMatch = + currMemProps.memoryHeaps[i].flags == m_MemProps.memoryHeaps[i].flags; + } + for(uint32_t i = 0; memoryMatch && i < currMemProps.memoryTypeCount; ++i) + { + memoryMatch = + currMemProps.memoryTypes[i].heapIndex == m_MemProps.memoryTypes[i].heapIndex && + currMemProps.memoryTypes[i].propertyFlags == m_MemProps.memoryTypes[i].propertyFlags; + } + + if(memoryMatch && g_Verbosity == VERBOSITY::MAXIMUM) + { + bool memorySizeMatch = true; + for(uint32_t i = 0; memorySizeMatch && i < currMemProps.memoryHeapCount; ++i) + { + memorySizeMatch = + currMemProps.memoryHeaps[i].size == m_MemProps.memoryHeaps[i].size; + } + + if(!memorySizeMatch) + { + printf("WARNING: Sizes of original memory heaps are different from current ones.\n"); + } + } + else + { + printf("WARNING: Layout of original memory heaps and types is different from current one.\n"); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// class Player + +static const char* const VALIDATION_LAYER_NAME = "VK_LAYER_LUNARG_standard_validation"; + +static bool g_MemoryAliasingWarningEnabled = true; + +static VKAPI_ATTR VkBool32 VKAPI_CALL MyDebugReportCallback( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData) +{ + // "Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug." + if(!g_MemoryAliasingWarningEnabled && flags == VK_DEBUG_REPORT_WARNING_BIT_EXT && + (strstr(pMessage, " is aliased with non-linear ") || strstr(pMessage, " is aliased with linear "))) + { + return VK_FALSE; + } + + // Ignoring because when VK_KHR_dedicated_allocation extension is enabled, + // vkGetBufferMemoryRequirements2KHR function is used instead, while Validation + // Layer seems to be unaware of it. + if (strstr(pMessage, "but vkGetBufferMemoryRequirements() has not been called on that buffer") != nullptr) + { + return VK_FALSE; + } + if (strstr(pMessage, "but vkGetImageMemoryRequirements() has not been called on that image") != nullptr) + { + return VK_FALSE; + } + + /* + "Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used." + Ignoring because we map entire VkDeviceMemory blocks, where different types of + images and buffers may end up together, especially on GPUs with unified memory + like Intel. + */ + if(strstr(pMessage, "Mapping an image with layout") != nullptr && + strstr(pMessage, "can result in undefined behavior if this memory is used by the device") != nullptr) + { + return VK_FALSE; + } + + printf("%s \xBA %s\n", pLayerPrefix, pMessage); + + return VK_FALSE; +} + +static bool IsLayerSupported(const VkLayerProperties* pProps, size_t propCount, const char* pLayerName) +{ + const VkLayerProperties* propsEnd = pProps + propCount; + return std::find_if( + pProps, + propsEnd, + [pLayerName](const VkLayerProperties& prop) -> bool { + return strcmp(pLayerName, prop.layerName) == 0; + }) != propsEnd; +} + +static const size_t FIRST_PARAM_INDEX = 4; + +static void InitVulkanFeatures( + VkPhysicalDeviceFeatures& outFeatures, + const VkPhysicalDeviceFeatures& supportedFeatures) +{ + ZeroMemory(&outFeatures, sizeof(outFeatures)); + + // Enable something what may interact with memory/buffer/image support. + + outFeatures.fullDrawIndexUint32 = supportedFeatures.fullDrawIndexUint32; + outFeatures.imageCubeArray = supportedFeatures.imageCubeArray; + outFeatures.geometryShader = supportedFeatures.geometryShader; + outFeatures.tessellationShader = supportedFeatures.tessellationShader; + outFeatures.multiDrawIndirect = supportedFeatures.multiDrawIndirect; + outFeatures.textureCompressionETC2 = supportedFeatures.textureCompressionETC2; + outFeatures.textureCompressionASTC_LDR = supportedFeatures.textureCompressionASTC_LDR; + outFeatures.textureCompressionBC = supportedFeatures.textureCompressionBC; +} + +class Player +{ +public: + Player(); + int Init(); + ~Player(); + + void ApplyConfig(ConfigurationParser& configParser); + void ExecuteLine(size_t lineNumber, const StrRange& line); + void DumpStats(const char* fileNameFormat, size_t lineNumber, bool detailed); + + void PrintStats(); + +private: + static const size_t MAX_WARNINGS_TO_SHOW = 64; + + size_t m_WarningCount = 0; + bool m_AllocateForBufferImageWarningIssued = false; + + VkInstance m_VulkanInstance = VK_NULL_HANDLE; + VkPhysicalDevice m_PhysicalDevice = VK_NULL_HANDLE; + uint32_t m_GraphicsQueueFamilyIndex = UINT_MAX; + VkDevice m_Device = VK_NULL_HANDLE; + VmaAllocator m_Allocator = VK_NULL_HANDLE; + bool m_DedicatedAllocationEnabled = false; + const VkPhysicalDeviceProperties* m_DevProps = nullptr; + const VkPhysicalDeviceMemoryProperties* m_MemProps = nullptr; + + PFN_vkCreateDebugReportCallbackEXT m_pvkCreateDebugReportCallbackEXT; + PFN_vkDebugReportMessageEXT m_pvkDebugReportMessageEXT; + PFN_vkDestroyDebugReportCallbackEXT m_pvkDestroyDebugReportCallbackEXT; + VkDebugReportCallbackEXT m_hCallback; + + uint32_t m_VmaFrameIndex = 0; + + // Any of these handles null can mean it was created in original but couldn't be created now. + struct Pool + { + VmaPool pool; + }; + struct Allocation + { + uint32_t allocationFlags; + VmaAllocation allocation; + VkBuffer buffer; + VkImage image; + }; + std::unordered_map m_Pools; + std::unordered_map m_Allocations; + + struct Thread + { + uint32_t callCount; + }; + std::unordered_map m_Threads; + + // Copy of column [1] from previously parsed line. + std::string m_LastLineTimeStr; + Statistics m_Stats; + + std::vector m_UserDataTmpStr; + + void Destroy(const Allocation& alloc); + + // Finds VmaPool bu original pointer. + // If origPool = null, returns true and outPool = null. + // If failed, prints warning, returns false and outPool = null. + bool FindPool(size_t lineNumber, uint64_t origPool, VmaPool& outPool); + // If allocation with that origPtr already exists, prints warning and replaces it. + void AddAllocation(size_t lineNumber, uint64_t origPtr, VkResult res, const char* functionName, Allocation&& allocDesc); + + // Increments warning counter. Returns true if warning message should be printed. + bool IssueWarning(); + + int InitVulkan(); + void FinalizeVulkan(); + void RegisterDebugCallbacks(); + + // If parmeter count doesn't match, issues warning and returns false. + bool ValidateFunctionParameterCount(size_t lineNumber, const CsvSplit& csvSplit, size_t expectedParamCount, bool lastUnbound); + + // If failed, prints warning, returns false, and sets allocCreateInfo.pUserData to null. + bool PrepareUserData(size_t lineNumber, uint32_t allocCreateFlags, const StrRange& userDataColumn, const StrRange& wholeLine, void*& outUserData); + + void UpdateMemStats(); + + void ExecuteCreatePool(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteDestroyPool(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteSetAllocationUserData(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteCreateBuffer(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteDestroyBuffer(size_t lineNumber, const CsvSplit& csvSplit) { m_Stats.RegisterFunctionCall(VMA_FUNCTION::DestroyBuffer); DestroyAllocation(lineNumber, csvSplit); } + void ExecuteCreateImage(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteDestroyImage(size_t lineNumber, const CsvSplit& csvSplit) { m_Stats.RegisterFunctionCall(VMA_FUNCTION::DestroyImage); DestroyAllocation(lineNumber, csvSplit); } + void ExecuteFreeMemory(size_t lineNumber, const CsvSplit& csvSplit) { m_Stats.RegisterFunctionCall(VMA_FUNCTION::FreeMemory); DestroyAllocation(lineNumber, csvSplit); } + void ExecuteCreateLostAllocation(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteAllocateMemory(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteAllocateMemoryForBufferOrImage(size_t lineNumber, const CsvSplit& csvSplit, OBJECT_TYPE objType); + void ExecuteMapMemory(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteUnmapMemory(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteFlushAllocation(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteInvalidateAllocation(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteTouchAllocation(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteGetAllocationInfo(size_t lineNumber, const CsvSplit& csvSplit); + void ExecuteMakePoolAllocationsLost(size_t lineNumber, const CsvSplit& csvSplit); + + void DestroyAllocation(size_t lineNumber, const CsvSplit& csvSplit); +}; + +Player::Player() +{ +} + +int Player::Init() +{ + int result = InitVulkan(); + + if(result == 0) + { + m_Stats.Init(m_MemProps->memoryHeapCount, m_MemProps->memoryTypeCount); + UpdateMemStats(); + } + + return result; +} + +Player::~Player() +{ + FinalizeVulkan(); + + if(g_Verbosity < VERBOSITY::MAXIMUM && m_WarningCount > MAX_WARNINGS_TO_SHOW) + printf("WARNING: %zu more warnings not shown.\n", m_WarningCount - MAX_WARNINGS_TO_SHOW); +} + +void Player::ApplyConfig(ConfigurationParser& configParser) +{ + configParser.Compare(*m_DevProps, *m_MemProps, m_DedicatedAllocationEnabled); +} + +void Player::ExecuteLine(size_t lineNumber, const StrRange& line) +{ + CsvSplit csvSplit; + csvSplit.Set(line); + + if(csvSplit.GetCount() >= FIRST_PARAM_INDEX) + { + // Check thread ID. + uint32_t threadId; + if(StrRangeToUint(csvSplit.GetRange(0), threadId)) + { + const auto it = m_Threads.find(threadId); + if(it != m_Threads.end()) + { + ++it->second.callCount; + } + else + { + Thread threadInfo{}; + threadInfo.callCount = 1; + m_Threads[threadId] = threadInfo; + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Incorrect thread ID.\n", lineNumber); + } + } + + // Save time. + csvSplit.GetRange(1).to_str(m_LastLineTimeStr); + + // Update VMA current frame index. + StrRange frameIndexStr = csvSplit.GetRange(2); + uint32_t frameIndex; + if(StrRangeToUint(frameIndexStr, frameIndex)) + { + if(frameIndex != m_VmaFrameIndex) + { + vmaSetCurrentFrameIndex(m_Allocator, frameIndex); + m_VmaFrameIndex = frameIndex; + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Incorrect frame index.\n", lineNumber); + } + } + + StrRange functionName = csvSplit.GetRange(3); + + if(StrRangeEq(functionName, "vmaCreateAllocator")) + { + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 0, false)) + { + // Nothing. + } + } + else if(StrRangeEq(functionName, "vmaDestroyAllocator")) + { + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 0, false)) + { + // Nothing. + } + } + else if(StrRangeEq(functionName, "vmaCreatePool")) + ExecuteCreatePool(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaDestroyPool")) + ExecuteDestroyPool(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaSetAllocationUserData")) + ExecuteSetAllocationUserData(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaCreateBuffer")) + ExecuteCreateBuffer(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaDestroyBuffer")) + ExecuteDestroyBuffer(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaCreateImage")) + ExecuteCreateImage(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaDestroyImage")) + ExecuteDestroyImage(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaFreeMemory")) + ExecuteFreeMemory(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaCreateLostAllocation")) + ExecuteCreateLostAllocation(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaAllocateMemory")) + ExecuteAllocateMemory(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaAllocateMemoryForBuffer")) + ExecuteAllocateMemoryForBufferOrImage(lineNumber, csvSplit, OBJECT_TYPE::BUFFER); + else if(StrRangeEq(functionName, "vmaAllocateMemoryForImage")) + ExecuteAllocateMemoryForBufferOrImage(lineNumber, csvSplit, OBJECT_TYPE::IMAGE); + else if(StrRangeEq(functionName, "vmaMapMemory")) + ExecuteMapMemory(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaUnmapMemory")) + ExecuteUnmapMemory(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaFlushAllocation")) + ExecuteFlushAllocation(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaInvalidateAllocation")) + ExecuteInvalidateAllocation(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaTouchAllocation")) + ExecuteTouchAllocation(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaGetAllocationInfo")) + ExecuteGetAllocationInfo(lineNumber, csvSplit); + else if(StrRangeEq(functionName, "vmaMakePoolAllocationsLost")) + ExecuteMakePoolAllocationsLost(lineNumber, csvSplit); + else + { + if(IssueWarning()) + { + printf("Line %zu: Unknown function.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Too few columns.\n", lineNumber); + } + } +} + +void Player::DumpStats(const char* fileNameFormat, size_t lineNumber, bool detailed) +{ + char* pStatsString = nullptr; + vmaBuildStatsString(m_Allocator, &pStatsString, detailed ? VK_TRUE : VK_FALSE); + + char fileName[MAX_PATH]; + sprintf_s(fileName, fileNameFormat, lineNumber); + + FILE* file = nullptr; + errno_t err = fopen_s(&file, fileName, "wb"); + if(err == 0) + { + fwrite(pStatsString, 1, strlen(pStatsString), file); + fclose(file); + } + else + { + printf("ERROR: Failed to write file: %s\n", fileName); + } + + vmaFreeStatsString(m_Allocator, pStatsString); +} + +void Player::Destroy(const Allocation& alloc) +{ + if(alloc.buffer) + { + assert(alloc.image == VK_NULL_HANDLE); + vmaDestroyBuffer(m_Allocator, alloc.buffer, alloc.allocation); + } + else if(alloc.image) + { + vmaDestroyImage(m_Allocator, alloc.image, alloc.allocation); + } + else + vmaFreeMemory(m_Allocator, alloc.allocation); +} + +bool Player::FindPool(size_t lineNumber, uint64_t origPool, VmaPool& outPool) +{ + outPool = VK_NULL_HANDLE; + + if(origPool != 0) + { + const auto poolIt = m_Pools.find(origPool); + if(poolIt != m_Pools.end()) + { + outPool = poolIt->second.pool; + return true; + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Pool %llX not found.\n", lineNumber, origPool); + } + } + } + + return true; +} + +void Player::AddAllocation(size_t lineNumber, uint64_t origPtr, VkResult res, const char* functionName, Allocation&& allocDesc) +{ + if(origPtr) + { + if(res == VK_SUCCESS) + { + // Originally succeeded, currently succeeded. + // Just save pointer (done below). + } + else + { + // Originally succeeded, currently failed. + // Print warning. Save null pointer. + if(IssueWarning()) + { + printf("Line %zu: %s failed (%d), while originally succeeded.\n", lineNumber, functionName, res); + } + } + + const auto existingIt = m_Allocations.find(origPtr); + if(existingIt != m_Allocations.end()) + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX already exists.\n", lineNumber, origPtr); + } + } + m_Allocations[origPtr] = std::move(allocDesc); + } + else + { + if(res == VK_SUCCESS) + { + // Originally failed, currently succeeded. + // Print warning, destroy the object. + if(IssueWarning()) + { + printf("Line %zu: %s succeeded, originally failed.\n", lineNumber, functionName); + } + + Destroy(allocDesc); + } + else + { + // Originally failed, currently failed. + // Print warning. + if(IssueWarning()) + { + printf("Line %zu: %s failed (%d), originally also failed.\n", lineNumber, functionName, res); + } + } + } +} + +bool Player::IssueWarning() +{ + if(g_Verbosity < VERBOSITY::MAXIMUM) + { + return m_WarningCount++ < MAX_WARNINGS_TO_SHOW; + } + else + { + ++m_WarningCount; + return true; + } +} + +int Player::InitVulkan() +{ + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf("Initializing Vulkan...\n"); + } + + uint32_t instanceLayerPropCount = 0; + VkResult res = vkEnumerateInstanceLayerProperties(&instanceLayerPropCount, nullptr); + assert(res == VK_SUCCESS); + + std::vector instanceLayerProps(instanceLayerPropCount); + if(instanceLayerPropCount > 0) + { + res = vkEnumerateInstanceLayerProperties(&instanceLayerPropCount, instanceLayerProps.data()); + assert(res == VK_SUCCESS); + } + + const bool validationLayersAvailable = + IsLayerSupported(instanceLayerProps.data(), instanceLayerProps.size(), VALIDATION_LAYER_NAME); + + bool validationLayersEnabled = false; + switch(g_VK_LAYER_LUNARG_standard_validation) + { + case VULKAN_EXTENSION_REQUEST::DISABLED: + break; + case VULKAN_EXTENSION_REQUEST::DEFAULT: + validationLayersEnabled = validationLayersAvailable; + break; + case VULKAN_EXTENSION_REQUEST::ENABLED: + validationLayersEnabled = validationLayersAvailable; + if(!validationLayersAvailable) + { + printf("WARNING: %s layer cannot be enabled.\n", VALIDATION_LAYER_NAME); + } + break; + default: assert(0); + } + + std::vector instanceExtensions; + //instanceExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME); + //instanceExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME); + + std::vector instanceLayers; + if(validationLayersEnabled) + { + instanceLayers.push_back(VALIDATION_LAYER_NAME); + instanceExtensions.push_back("VK_EXT_debug_report"); + } + + VkApplicationInfo appInfo = { VK_STRUCTURE_TYPE_APPLICATION_INFO }; + appInfo.pApplicationName = "VmaReplay"; + appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); + appInfo.pEngineName = "Vulkan Memory Allocator"; + appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); + appInfo.apiVersion = VK_API_VERSION_1_0; + + VkInstanceCreateInfo instInfo = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO }; + instInfo.pApplicationInfo = &appInfo; + instInfo.enabledExtensionCount = (uint32_t)instanceExtensions.size(); + instInfo.ppEnabledExtensionNames = instanceExtensions.data(); + instInfo.enabledLayerCount = (uint32_t)instanceLayers.size(); + instInfo.ppEnabledLayerNames = instanceLayers.data(); + + res = vkCreateInstance(&instInfo, NULL, &m_VulkanInstance); + if(res != VK_SUCCESS) + { + printf("ERROR: vkCreateInstance failed (%d)\n", res); + return RESULT_ERROR_VULKAN; + } + + if(validationLayersEnabled) + { + RegisterDebugCallbacks(); + } + + // Find physical device + + uint32_t physicalDeviceCount = 0; + res = vkEnumeratePhysicalDevices(m_VulkanInstance, &physicalDeviceCount, nullptr); + assert(res == VK_SUCCESS); + if(physicalDeviceCount == 0) + { + printf("ERROR: No Vulkan physical devices found.\n"); + return RESULT_ERROR_VULKAN; + } + + std::vector physicalDevices(physicalDeviceCount); + res = vkEnumeratePhysicalDevices(m_VulkanInstance, &physicalDeviceCount, physicalDevices.data()); + assert(res == VK_SUCCESS); + + if(g_PhysicalDeviceIndex >= physicalDeviceCount) + { + printf("ERROR: Incorrect Vulkan physical device index %u. System has %u physical devices.\n", + g_PhysicalDeviceIndex, + physicalDeviceCount); + return RESULT_ERROR_VULKAN; + } + + m_PhysicalDevice = physicalDevices[0]; + + // Find queue family index + + uint32_t queueFamilyCount = 0; + vkGetPhysicalDeviceQueueFamilyProperties(m_PhysicalDevice, &queueFamilyCount, nullptr); + if(queueFamilyCount) + { + std::vector queueFamilies(queueFamilyCount); + vkGetPhysicalDeviceQueueFamilyProperties(m_PhysicalDevice, &queueFamilyCount, queueFamilies.data()); + for(uint32_t i = 0; i < queueFamilyCount; ++i) + { + if(queueFamilies[i].queueCount > 0 && + (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) + { + m_GraphicsQueueFamilyIndex = i; + break; + } + } + } + if(m_GraphicsQueueFamilyIndex == UINT_MAX) + { + printf("ERROR: Couldn't find graphics queue.\n"); + return RESULT_ERROR_VULKAN; + } + + VkPhysicalDeviceFeatures supportedFeatures; + vkGetPhysicalDeviceFeatures(m_PhysicalDevice, &supportedFeatures); + + // Create logical device + + const float queuePriority = 1.f; + + VkDeviceQueueCreateInfo deviceQueueCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO }; + deviceQueueCreateInfo.queueFamilyIndex = m_GraphicsQueueFamilyIndex; + deviceQueueCreateInfo.queueCount = 1; + deviceQueueCreateInfo.pQueuePriorities = &queuePriority; + + // Enable something what may interact with memory/buffer/image support. + VkPhysicalDeviceFeatures enabledFeatures; + InitVulkanFeatures(enabledFeatures, supportedFeatures); + + bool VK_KHR_get_memory_requirements2_available = false; + bool VK_KHR_dedicated_allocation_available = false; + + // Determine list of device extensions to enable. + std::vector enabledDeviceExtensions; + //enabledDeviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME); + { + uint32_t propertyCount = 0; + res = vkEnumerateDeviceExtensionProperties(m_PhysicalDevice, nullptr, &propertyCount, nullptr); + assert(res == VK_SUCCESS); + + if(propertyCount) + { + std::vector properties{propertyCount}; + res = vkEnumerateDeviceExtensionProperties(m_PhysicalDevice, nullptr, &propertyCount, properties.data()); + assert(res == VK_SUCCESS); + + for(uint32_t i = 0; i < propertyCount; ++i) + { + if(strcmp(properties[i].extensionName, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME) == 0) + { + VK_KHR_get_memory_requirements2_available = true; + } + else if(strcmp(properties[i].extensionName, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) == 0) + { + VK_KHR_dedicated_allocation_available = true; + } + } + } + } + + const bool dedicatedAllocationAvailable = + VK_KHR_get_memory_requirements2_available && VK_KHR_dedicated_allocation_available; + + switch(g_VK_KHR_dedicated_allocation_request) + { + case VULKAN_EXTENSION_REQUEST::DISABLED: + break; + case VULKAN_EXTENSION_REQUEST::DEFAULT: + m_DedicatedAllocationEnabled = dedicatedAllocationAvailable; + break; + case VULKAN_EXTENSION_REQUEST::ENABLED: + m_DedicatedAllocationEnabled = dedicatedAllocationAvailable; + if(!dedicatedAllocationAvailable) + { + printf("WARNING: VK_KHR_dedicated_allocation extension cannot be enabled.\n"); + } + break; + default: assert(0); + } + + if(m_DedicatedAllocationEnabled) + { + enabledDeviceExtensions.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); + enabledDeviceExtensions.push_back(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); + } + + VkDeviceCreateInfo deviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }; + deviceCreateInfo.enabledExtensionCount = (uint32_t)enabledDeviceExtensions.size(); + deviceCreateInfo.ppEnabledExtensionNames = !enabledDeviceExtensions.empty() ? enabledDeviceExtensions.data() : nullptr; + deviceCreateInfo.queueCreateInfoCount = 1; + deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo; + deviceCreateInfo.pEnabledFeatures = &enabledFeatures; + + res = vkCreateDevice(m_PhysicalDevice, &deviceCreateInfo, nullptr, &m_Device); + if(res != VK_SUCCESS) + { + printf("ERROR: vkCreateDevice failed (%d)\n", res); + return RESULT_ERROR_VULKAN; + } + + // Create memory allocator + + VmaAllocatorCreateInfo allocatorInfo = {}; + allocatorInfo.physicalDevice = m_PhysicalDevice; + allocatorInfo.device = m_Device; + allocatorInfo.flags = VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT; + + if(m_DedicatedAllocationEnabled) + { + allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT; + } + + res = vmaCreateAllocator(&allocatorInfo, &m_Allocator); + if(res != VK_SUCCESS) + { + printf("ERROR: vmaCreateAllocator failed (%d)\n", res); + return RESULT_ERROR_VULKAN; + } + + vmaGetPhysicalDeviceProperties(m_Allocator, &m_DevProps); + vmaGetMemoryProperties(m_Allocator, &m_MemProps); + + return 0; +} + +void Player::FinalizeVulkan() +{ + if(!m_Allocations.empty()) + { + printf("WARNING: Allocations not destroyed: %zu.\n", m_Allocations.size()); + + if(CLEANUP_LEAKED_OBJECTS) + { + for(const auto it : m_Allocations) + { + Destroy(it.second); + } + } + + m_Allocations.clear(); + } + + if(!m_Pools.empty()) + { + printf("WARNING: Custom pools not destroyed: %zu.\n", m_Pools.size()); + + if(CLEANUP_LEAKED_OBJECTS) + { + for(const auto it : m_Pools) + { + vmaDestroyPool(m_Allocator, it.second.pool); + } + } + + m_Pools.clear(); + } + + vkDeviceWaitIdle(m_Device); + + if(m_Allocator != VK_NULL_HANDLE) + { + vmaDestroyAllocator(m_Allocator); + m_Allocator = nullptr; + } + + if(m_Device != VK_NULL_HANDLE) + { + vkDestroyDevice(m_Device, nullptr); + m_Device = nullptr; + } + + if(m_pvkDestroyDebugReportCallbackEXT && m_hCallback != VK_NULL_HANDLE) + { + m_pvkDestroyDebugReportCallbackEXT(m_VulkanInstance, m_hCallback, nullptr); + m_hCallback = VK_NULL_HANDLE; + } + + if(m_VulkanInstance != VK_NULL_HANDLE) + { + vkDestroyInstance(m_VulkanInstance, NULL); + m_VulkanInstance = VK_NULL_HANDLE; + } +} + +void Player::RegisterDebugCallbacks() +{ + m_pvkCreateDebugReportCallbackEXT = + reinterpret_cast + (vkGetInstanceProcAddr(m_VulkanInstance, "vkCreateDebugReportCallbackEXT")); + m_pvkDebugReportMessageEXT = + reinterpret_cast + (vkGetInstanceProcAddr(m_VulkanInstance, "vkDebugReportMessageEXT")); + m_pvkDestroyDebugReportCallbackEXT = + reinterpret_cast + (vkGetInstanceProcAddr(m_VulkanInstance, "vkDestroyDebugReportCallbackEXT")); + assert(m_pvkCreateDebugReportCallbackEXT); + assert(m_pvkDebugReportMessageEXT); + assert(m_pvkDestroyDebugReportCallbackEXT); + + VkDebugReportCallbackCreateInfoEXT callbackCreateInfo = { VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT }; + callbackCreateInfo.flags = //VK_DEBUG_REPORT_INFORMATION_BIT_EXT | + VK_DEBUG_REPORT_ERROR_BIT_EXT | + VK_DEBUG_REPORT_WARNING_BIT_EXT | + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT /*| + VK_DEBUG_REPORT_DEBUG_BIT_EXT*/; + callbackCreateInfo.pfnCallback = &MyDebugReportCallback; + + VkResult res = m_pvkCreateDebugReportCallbackEXT(m_VulkanInstance, &callbackCreateInfo, nullptr, &m_hCallback); + assert(res == VK_SUCCESS); +} + +void Player::PrintStats() +{ + if(g_Verbosity == VERBOSITY::MINIMUM) + { + return; + } + + printf("Statistics:\n"); + if(m_Stats.GetAllocationCreationCount() > 0) + { + printf(" Total allocations created: %zu\n", m_Stats.GetAllocationCreationCount()); + } + + // Buffers + const size_t bufferCreationCount = + m_Stats.GetBufferCreationCount(0) + + m_Stats.GetBufferCreationCount(1) + + m_Stats.GetBufferCreationCount(2) + + m_Stats.GetBufferCreationCount(3); + if(bufferCreationCount > 0) + { + printf(" Total buffers created: %zu\n", bufferCreationCount); + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf(" Class 0 (indirect/vertex/index): %zu\n", m_Stats.GetBufferCreationCount(0)); + printf(" Class 1 (storage): %zu\n", m_Stats.GetBufferCreationCount(1)); + printf(" Class 2 (uniform): %zu\n", m_Stats.GetBufferCreationCount(2)); + printf(" Class 3 (other): %zu\n", m_Stats.GetBufferCreationCount(3)); + } + } + + // Images + const size_t imageCreationCount = + m_Stats.GetImageCreationCount(0) + + m_Stats.GetImageCreationCount(1) + + m_Stats.GetImageCreationCount(2) + + m_Stats.GetImageCreationCount(3) + + m_Stats.GetLinearImageCreationCount(); + if(imageCreationCount > 0) + { + printf(" Total images created: %zu\n", imageCreationCount); + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf(" Class 0 (depth/stencil): %zu\n", m_Stats.GetImageCreationCount(0)); + printf(" Class 1 (attachment): %zu\n", m_Stats.GetImageCreationCount(1)); + printf(" Class 2 (sampled): %zu\n", m_Stats.GetImageCreationCount(2)); + printf(" Class 3 (other): %zu\n", m_Stats.GetImageCreationCount(3)); + if(m_Stats.GetLinearImageCreationCount() > 0) + { + printf(" LINEAR tiling: %zu\n", m_Stats.GetLinearImageCreationCount()); + } + } + } + + if(m_Stats.GetPoolCreationCount() > 0) + { + printf(" Total custom pools created: %zu\n", m_Stats.GetPoolCreationCount()); + } + + float lastTime; + if(!m_LastLineTimeStr.empty() && StrRangeToFloat(StrRange(m_LastLineTimeStr), lastTime)) + { + std::string origTimeStr; + SecondsToFriendlyStr(lastTime, origTimeStr); + printf(" Original recording time: %s\n", origTimeStr.c_str()); + } + + // Thread statistics. + const size_t threadCount = m_Threads.size(); + if(threadCount > 1) + { + uint32_t threadCallCountMax = 0; + uint32_t threadCallCountSum = 0; + for(const auto& it : m_Threads) + { + threadCallCountMax = std::max(threadCallCountMax, it.second.callCount); + threadCallCountSum += it.second.callCount; + } + printf(" Threads making calls to VMA: %zu\n", threadCount); + printf(" %.2f%% calls from most active thread.\n", + (float)threadCallCountMax * 100.f / (float)threadCallCountSum); + } + else + { + printf(" VMA used from only one thread.\n"); + } + + // Function call count + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf(" Function call count:\n"); + const size_t* const functionCallCount = m_Stats.GetFunctionCallCount(); + for(size_t i = 0; i < (size_t)VMA_FUNCTION::Count; ++i) + { + if(functionCallCount[i] > 0) + { + printf(" %s %zu\n", VMA_FUNCTION_NAMES[i], functionCallCount[i]); + } + } + } + + if(g_MemStatsEnabled) + { + m_Stats.PrintMemStats(); + } +} + +bool Player::ValidateFunctionParameterCount(size_t lineNumber, const CsvSplit& csvSplit, size_t expectedParamCount, bool lastUnbound) +{ + bool ok; + if(lastUnbound) + ok = csvSplit.GetCount() >= FIRST_PARAM_INDEX + expectedParamCount - 1; + else + ok = csvSplit.GetCount() == FIRST_PARAM_INDEX + expectedParamCount; + + if(!ok) + { + if(IssueWarning()) + { + printf("Line %zu: Incorrect number of function parameters.\n", lineNumber); + } + } + + return ok; +} + +bool Player::PrepareUserData(size_t lineNumber, uint32_t allocCreateFlags, const StrRange& userDataColumn, const StrRange& wholeLine, void*& outUserData) +{ + if(!g_UserDataEnabled) + { + outUserData = nullptr; + return true; + } + + // String + if((allocCreateFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0) + { + const size_t len = wholeLine.end - userDataColumn.beg; + m_UserDataTmpStr.resize(len + 1); + memcpy(m_UserDataTmpStr.data(), userDataColumn.beg, len); + m_UserDataTmpStr[len] = '\0'; + outUserData = m_UserDataTmpStr.data(); + return true; + } + // Pointer + else + { + uint64_t pUserData = 0; + if(StrRangeToPtr(userDataColumn, pUserData)) + { + outUserData = (void*)(uintptr_t)pUserData; + return true; + } + } + + if(IssueWarning()) + { + printf("Line %zu: Invalid pUserData.\n", lineNumber); + } + outUserData = 0; + return false; +} + +void Player::UpdateMemStats() +{ + if(!g_MemStatsEnabled) + { + return; + } + + VmaStats stats; + vmaCalculateStats(m_Allocator, &stats); + m_Stats.UpdateMemStats(stats); +} + +void Player::ExecuteCreatePool(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::CreatePool); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 7, false)) + { + VmaPoolCreateInfo poolCreateInfo = {}; + uint64_t origPtr = 0; + + if(StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX), poolCreateInfo.memoryTypeIndex) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), poolCreateInfo.flags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), poolCreateInfo.blockSize) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 3), poolCreateInfo.minBlockCount) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 4), poolCreateInfo.maxBlockCount) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 5), poolCreateInfo.frameInUseCount) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 6), origPtr)) + { + m_Stats.RegisterCreatePool(); + + Pool poolDesc = {}; + VkResult res = vmaCreatePool(m_Allocator, &poolCreateInfo, &poolDesc.pool); + + if(origPtr) + { + if(res == VK_SUCCESS) + { + // Originally succeeded, currently succeeded. + // Just save pointer (done below). + } + else + { + // Originally succeeded, currently failed. + // Print warning. Save null pointer. + if(IssueWarning()) + { + printf("Line %zu: vmaCreatePool failed (%d), while originally succeeded.\n", lineNumber, res); + } + } + + const auto existingIt = m_Pools.find(origPtr); + if(existingIt != m_Pools.end()) + { + if(IssueWarning()) + { + printf("Line %zu: Pool %llX already exists.\n", lineNumber, origPtr); + } + } + m_Pools[origPtr] = poolDesc; + } + else + { + if(res == VK_SUCCESS) + { + // Originally failed, currently succeeded. + // Print warning, destroy the pool. + if(IssueWarning()) + { + printf("Line %zu: vmaCreatePool succeeded, originally failed.\n", lineNumber); + } + + vmaDestroyPool(m_Allocator, poolDesc.pool); + } + else + { + // Originally failed, currently failed. + // Print warning. + if(IssueWarning()) + { + printf("Line %zu: vmaCreatePool failed (%d), originally also failed.\n", lineNumber, res); + } + } + } + + UpdateMemStats(); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaCreatePool.\n", lineNumber); + } + } + } +} + +void Player::ExecuteDestroyPool(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::DestroyPool); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + if(origPtr != 0) + { + const auto it = m_Pools.find(origPtr); + if(it != m_Pools.end()) + { + vmaDestroyPool(m_Allocator, it->second.pool); + UpdateMemStats(); + m_Pools.erase(it); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Pool %llX not found.\n", lineNumber, origPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaDestroyPool.\n", lineNumber); + } + } + } +} + +void Player::ExecuteSetAllocationUserData(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::SetAllocationUserData); + + if(!g_UserDataEnabled) + { + return; + } + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 2, true)) + { + uint64_t origPtr = 0; + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + void* pUserData = nullptr; + if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 1) + { + PrepareUserData( + lineNumber, + it->second.allocationFlags, + csvSplit.GetRange(FIRST_PARAM_INDEX + 1), + csvSplit.GetLine(), + pUserData); + } + + vmaSetAllocationUserData(m_Allocator, it->second.allocation, pUserData); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaSetAllocationUserData.\n", lineNumber); + } + } + } +} + +void Player::ExecuteCreateBuffer(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::CreateBuffer); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 12, true)) + { + VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; + VmaAllocationCreateInfo allocCreateInfo = {}; + uint64_t origPool = 0; + uint64_t origPtr = 0; + + if(StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX), bufCreateInfo.flags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), bufCreateInfo.size) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), bufCreateInfo.usage) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 3), (uint32_t&)bufCreateInfo.sharingMode) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 4), allocCreateInfo.flags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 5), (uint32_t&)allocCreateInfo.usage) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 6), allocCreateInfo.requiredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 7), allocCreateInfo.preferredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 8), allocCreateInfo.memoryTypeBits) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 9), origPool) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 10), origPtr)) + { + FindPool(lineNumber, origPool, allocCreateInfo.pool); + + if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 11) + { + PrepareUserData( + lineNumber, + allocCreateInfo.flags, + csvSplit.GetRange(FIRST_PARAM_INDEX + 11), + csvSplit.GetLine(), + allocCreateInfo.pUserData); + } + + m_Stats.RegisterCreateBuffer(bufCreateInfo.usage); + + Allocation allocDesc = { }; + allocDesc.allocationFlags = allocCreateInfo.flags; + VkResult res = vmaCreateBuffer(m_Allocator, &bufCreateInfo, &allocCreateInfo, &allocDesc.buffer, &allocDesc.allocation, nullptr); + UpdateMemStats(); + AddAllocation(lineNumber, origPtr, res, "vmaCreateBuffer", std::move(allocDesc)); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaCreateBuffer.\n", lineNumber); + } + } + } +} + +void Player::DestroyAllocation(size_t lineNumber, const CsvSplit& csvSplit) +{ + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origAllocPtr = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origAllocPtr)) + { + if(origAllocPtr != 0) + { + const auto it = m_Allocations.find(origAllocPtr); + if(it != m_Allocations.end()) + { + Destroy(it->second); + UpdateMemStats(); + m_Allocations.erase(it); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origAllocPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaDestroyBuffer.\n", lineNumber); + } + } + } +} + +void Player::ExecuteCreateImage(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::CreateImage); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 21, true)) + { + VkImageCreateInfo imageCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO }; + VmaAllocationCreateInfo allocCreateInfo = {}; + uint64_t origPool = 0; + uint64_t origPtr = 0; + + if(StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX), imageCreateInfo.flags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), (uint32_t&)imageCreateInfo.imageType) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), (uint32_t&)imageCreateInfo.format) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 3), imageCreateInfo.extent.width) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 4), imageCreateInfo.extent.height) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 5), imageCreateInfo.extent.depth) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 6), imageCreateInfo.mipLevels) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 7), imageCreateInfo.arrayLayers) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 8), (uint32_t&)imageCreateInfo.samples) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 9), (uint32_t&)imageCreateInfo.tiling) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 10), imageCreateInfo.usage) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 11), (uint32_t&)imageCreateInfo.sharingMode) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 12), (uint32_t&)imageCreateInfo.initialLayout) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 13), allocCreateInfo.flags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 14), (uint32_t&)allocCreateInfo.usage) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 15), allocCreateInfo.requiredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 16), allocCreateInfo.preferredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 17), allocCreateInfo.memoryTypeBits) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 18), origPool) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 19), origPtr)) + { + FindPool(lineNumber, origPool, allocCreateInfo.pool); + + if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 20) + { + PrepareUserData( + lineNumber, + allocCreateInfo.flags, + csvSplit.GetRange(FIRST_PARAM_INDEX + 20), + csvSplit.GetLine(), + allocCreateInfo.pUserData); + } + + m_Stats.RegisterCreateImage(imageCreateInfo.usage, imageCreateInfo.tiling); + + Allocation allocDesc = {}; + allocDesc.allocationFlags = allocCreateInfo.flags; + VkResult res = vmaCreateImage(m_Allocator, &imageCreateInfo, &allocCreateInfo, &allocDesc.image, &allocDesc.allocation, nullptr); + UpdateMemStats(); + AddAllocation(lineNumber, origPtr, res, "vmaCreateImage", std::move(allocDesc)); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaCreateImage.\n", lineNumber); + } + } + } +} + +void Player::ExecuteCreateLostAllocation(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::CreateLostAllocation); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + Allocation allocDesc = {}; + vmaCreateLostAllocation(m_Allocator, &allocDesc.allocation); + UpdateMemStats(); + m_Stats.RegisterCreateAllocation(); + + AddAllocation(lineNumber, origPtr, VK_SUCCESS, "vmaCreateLostAllocation", std::move(allocDesc)); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaCreateLostAllocation.\n", lineNumber); + } + } + } +} + +void Player::ExecuteAllocateMemory(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::AllocateMemory); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 11, true)) + { + VkMemoryRequirements memReq = {}; + VmaAllocationCreateInfo allocCreateInfo = {}; + uint64_t origPool = 0; + uint64_t origPtr = 0; + + if(StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX), memReq.size) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), memReq.alignment) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), memReq.memoryTypeBits) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 3), allocCreateInfo.flags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 4), (uint32_t&)allocCreateInfo.usage) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 5), allocCreateInfo.requiredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 6), allocCreateInfo.preferredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 7), allocCreateInfo.memoryTypeBits) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 8), origPool) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 9), origPtr)) + { + FindPool(lineNumber, origPool, allocCreateInfo.pool); + + if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 10) + { + PrepareUserData( + lineNumber, + allocCreateInfo.flags, + csvSplit.GetRange(FIRST_PARAM_INDEX + 10), + csvSplit.GetLine(), + allocCreateInfo.pUserData); + } + + UpdateMemStats(); + m_Stats.RegisterCreateAllocation(); + + Allocation allocDesc = {}; + allocDesc.allocationFlags = allocCreateInfo.flags; + VkResult res = vmaAllocateMemory(m_Allocator, &memReq, &allocCreateInfo, &allocDesc.allocation, nullptr); + AddAllocation(lineNumber, origPtr, res, "vmaAllocateMemory", std::move(allocDesc)); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaAllocateMemory.\n", lineNumber); + } + } + } +} + +void Player::ExecuteAllocateMemoryForBufferOrImage(size_t lineNumber, const CsvSplit& csvSplit, OBJECT_TYPE objType) +{ + switch(objType) + { + case OBJECT_TYPE::BUFFER: + m_Stats.RegisterFunctionCall(VMA_FUNCTION::AllocateMemoryForBuffer); + break; + case OBJECT_TYPE::IMAGE: + m_Stats.RegisterFunctionCall(VMA_FUNCTION::AllocateMemoryForImage); + break; + default: assert(0); + } + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 13, true)) + { + VkMemoryRequirements memReq = {}; + VmaAllocationCreateInfo allocCreateInfo = {}; + bool requiresDedicatedAllocation = false; + bool prefersDedicatedAllocation = false; + uint64_t origPool = 0; + uint64_t origPtr = 0; + + if(StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX), memReq.size) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), memReq.alignment) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), memReq.memoryTypeBits) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 3), allocCreateInfo.flags) && + StrRangeToBool(csvSplit.GetRange(FIRST_PARAM_INDEX + 4), requiresDedicatedAllocation) && + StrRangeToBool(csvSplit.GetRange(FIRST_PARAM_INDEX + 5), prefersDedicatedAllocation) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 6), (uint32_t&)allocCreateInfo.usage) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 7), allocCreateInfo.requiredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 8), allocCreateInfo.preferredFlags) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 9), allocCreateInfo.memoryTypeBits) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 10), origPool) && + StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX + 11), origPtr)) + { + FindPool(lineNumber, origPool, allocCreateInfo.pool); + + if(csvSplit.GetCount() > FIRST_PARAM_INDEX + 12) + { + PrepareUserData( + lineNumber, + allocCreateInfo.flags, + csvSplit.GetRange(FIRST_PARAM_INDEX + 12), + csvSplit.GetLine(), + allocCreateInfo.pUserData); + } + + if(requiresDedicatedAllocation || prefersDedicatedAllocation) + { + allocCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; + } + + if(!m_AllocateForBufferImageWarningIssued) + { + if(IssueWarning()) + { + printf("Line %zu: vmaAllocateMemoryForBuffer or vmaAllocateMemoryForImage cannot be replayed accurately. Using vmaCreateAllocation instead.\n", lineNumber); + } + m_AllocateForBufferImageWarningIssued = true; + } + + UpdateMemStats(); + m_Stats.RegisterCreateAllocation(); + + Allocation allocDesc = {}; + allocDesc.allocationFlags = allocCreateInfo.flags; + VkResult res = vmaAllocateMemory(m_Allocator, &memReq, &allocCreateInfo, &allocDesc.allocation, nullptr); + AddAllocation(lineNumber, origPtr, res, "vmaAllocateMemory (called as vmaAllocateMemoryForBuffer or vmaAllocateMemoryForImage)", std::move(allocDesc)); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaAllocateMemoryForBuffer or vmaAllocateMemoryForImage.\n", lineNumber); + } + } + } +} + +void Player::ExecuteMapMemory(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::MapMemory); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + if(origPtr != 0) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + if(it->second.allocation) + { + void* pData; + VkResult res = vmaMapMemory(m_Allocator, it->second.allocation, &pData); + if(res != VK_SUCCESS) + { + printf("Line %zu: vmaMapMemory failed (%d)\n", lineNumber, res); + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Cannot call vmaMapMemory - allocation is null.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaMapMemory.\n", lineNumber); + } + } + } +} + +void Player::ExecuteUnmapMemory(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::UnmapMemory); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + if(origPtr != 0) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + if(it->second.allocation) + { + vmaUnmapMemory(m_Allocator, it->second.allocation); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Cannot call vmaUnmapMemory - allocation is null.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaMapMemory.\n", lineNumber); + } + } + } +} + +void Player::ExecuteFlushAllocation(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::FlushAllocation); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 3, false)) + { + uint64_t origPtr = 0; + uint64_t offset = 0; + uint64_t size = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), offset) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), size)) + { + if(origPtr != 0) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + if(it->second.allocation) + { + vmaFlushAllocation(m_Allocator, it->second.allocation, offset, size); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Cannot call vmaFlushAllocation - allocation is null.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaFlushAllocation.\n", lineNumber); + } + } + } +} + +void Player::ExecuteInvalidateAllocation(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::InvalidateAllocation); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 3, false)) + { + uint64_t origPtr = 0; + uint64_t offset = 0; + uint64_t size = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 1), offset) && + StrRangeToUint(csvSplit.GetRange(FIRST_PARAM_INDEX + 2), size)) + { + if(origPtr != 0) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + if(it->second.allocation) + { + vmaInvalidateAllocation(m_Allocator, it->second.allocation, offset, size); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Cannot call vmaInvalidateAllocation - allocation is null.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaInvalidateAllocation.\n", lineNumber); + } + } + } +} + +void Player::ExecuteTouchAllocation(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::TouchAllocation); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + if(it->second.allocation) + { + vmaTouchAllocation(m_Allocator, it->second.allocation); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Cannot call vmaTouchAllocation - allocation is null.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaTouchAllocation.\n", lineNumber); + } + } + } +} + +void Player::ExecuteGetAllocationInfo(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::GetAllocationInfo); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + const auto it = m_Allocations.find(origPtr); + if(it != m_Allocations.end()) + { + if(it->second.allocation) + { + VmaAllocationInfo allocInfo; + vmaGetAllocationInfo(m_Allocator, it->second.allocation, &allocInfo); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Cannot call vmaGetAllocationInfo - allocation is null.\n", lineNumber); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Allocation %llX not found.\n", lineNumber, origPtr); + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaGetAllocationInfo.\n", lineNumber); + } + } + } +} + +void Player::ExecuteMakePoolAllocationsLost(size_t lineNumber, const CsvSplit& csvSplit) +{ + m_Stats.RegisterFunctionCall(VMA_FUNCTION::MakePoolAllocationsLost); + + if(ValidateFunctionParameterCount(lineNumber, csvSplit, 1, false)) + { + uint64_t origPtr = 0; + + if(StrRangeToPtr(csvSplit.GetRange(FIRST_PARAM_INDEX), origPtr)) + { + if(origPtr != 0) + { + const auto it = m_Pools.find(origPtr); + if(it != m_Pools.end()) + { + vmaMakePoolAllocationsLost(m_Allocator, it->second.pool, nullptr); + UpdateMemStats(); + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Pool %llX not found.\n", lineNumber, origPtr); + } + } + } + } + else + { + if(IssueWarning()) + { + printf("Line %zu: Invalid parameters for vmaMakePoolAllocationsLost.\n", lineNumber); + } + } + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Main functions + +static void PrintCommandLineSyntax() +{ + printf( + "Command line syntax:\n" + " VmaReplay [Options] \n" + "Available options:\n" + " -v - Verbosity level:\n" + " 0 - Minimum verbosity. Prints only warnings and errors.\n" + " 1 - Default verbosity. Prints important messages and statistics.\n" + " 2 - Maximum verbosity. Prints a lot of information.\n" + " -i - Repeat playback given number of times (iterations)\n" + " Default is 1. Vulkan is reinitialized with every iteration.\n" + " --MemStats - 0 to disable or 1 to enable memory statistics.\n" + " Default is 0. Enabling it may negatively impact playback performance.\n" + " --DumpStatsAfterLine - Dump VMA statistics to JSON file after specified source file line finishes execution.\n" + " File is written to current directory with name: VmaReplay_Line####.json.\n" + " This parameter can be repeated.\n" + " --DumpDetailedStatsAfterLine - Like command above, but includes detailed map.\n" + " --Lines - Replay only limited set of lines from file\n" + " Ranges is comma-separated list of ranges, e.g. \"-10,15,18-25,31-\".\n" + " --PhysicalDevice - Choice of Vulkan physical device. Default: 0.\n" + " --UserData - 0 to disable or 1 to enable setting pUserData during playback.\n" + " Default is 1. Affects both creation of buffers and images, as well as calls to vmaSetAllocationUserData.\n" + " --VK_LAYER_LUNARG_standard_validation - 0 to disable or 1 to enable validation layers.\n" + " By default the layers are silently enabled if available.\n" + " --VK_KHR_dedicated_allocation - 0 to disable or 1 to enable this extension.\n" + " By default the extension is silently enabled if available.\n" + ); +} + +static int ProcessFile(size_t iterationIndex, const char* data, size_t numBytes, duration& outDuration) +{ + outDuration = duration::max(); + + const bool useLineRanges = !g_LineRanges.IsEmpty(); + const bool useDumpStatsAfterLine = !g_DumpStatsAfterLine.empty(); + + LineSplit lineSplit(data, numBytes); + StrRange line; + + if(!lineSplit.GetNextLine(line) || + !StrRangeEq(line, "Vulkan Memory Allocator,Calls recording")) + { + printf("ERROR: Incorrect file format.\n"); + return RESULT_ERROR_FORMAT; + } + + if(!lineSplit.GetNextLine(line) || !ParseFileVersion(line) || !ValidateFileVersion()) + { + printf("ERROR: Incorrect file format version.\n"); + return RESULT_ERROR_FORMAT; + } + + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf("Format version: %u,%u\n", + GetVersionMajor(g_FileVersion), + GetVersionMinor(g_FileVersion)); + } + + // Parse configuration + const bool configEnabled = g_FileVersion >= MakeVersion(1, 3); + ConfigurationParser configParser; + if(configEnabled) + { + if(!configParser.Parse(lineSplit)) + { + return RESULT_ERROR_FORMAT; + } + } + + Player player; + int result = player.Init(); + + if(configEnabled) + { + player.ApplyConfig(configParser); + } + + size_t executedLineCount = 0; + if(result == 0) + { + if(g_Verbosity > VERBOSITY::MINIMUM) + { + if(useLineRanges) + { + printf("Playing #%zu (limited range of lines)...\n", iterationIndex + 1); + } + else + { + printf("Playing #%zu...\n", iterationIndex + 1); + } + } + + const time_point timeBeg = std::chrono::high_resolution_clock::now(); + + while(lineSplit.GetNextLine(line)) + { + const size_t currLineNumber = lineSplit.GetNextLineIndex(); + + bool execute = true; + if(useLineRanges) + { + execute = g_LineRanges.Includes(currLineNumber); + } + + if(execute) + { + player.ExecuteLine(currLineNumber, line); + ++executedLineCount; + } + + while(useDumpStatsAfterLine && + g_DumpStatsAfterLineNextIndex < g_DumpStatsAfterLine.size() && + currLineNumber >= g_DumpStatsAfterLine[g_DumpStatsAfterLineNextIndex].line) + { + const size_t requestedLine = g_DumpStatsAfterLine[g_DumpStatsAfterLineNextIndex].line; + const bool detailed = g_DumpStatsAfterLine[g_DumpStatsAfterLineNextIndex].detailed; + + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf("Dumping %sstats after line %zu actual line %zu...\n", + detailed ? "detailed " : "", + requestedLine, + currLineNumber); + } + + player.DumpStats("VmaReplay_Line%04zu.json", requestedLine, detailed); + + ++g_DumpStatsAfterLineNextIndex; + } + } + + const duration playDuration = std::chrono::high_resolution_clock::now() - timeBeg; + outDuration = playDuration; + + // End stats. + if(g_Verbosity > VERBOSITY::MINIMUM) + { + std::string playDurationStr; + SecondsToFriendlyStr(ToFloatSeconds(playDuration), playDurationStr); + + printf("Done.\n"); + printf("Playback took: %s\n", playDurationStr.c_str()); + } + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf("File lines: %zu\n", lineSplit.GetNextLineIndex()); + printf("Executed %zu file lines\n", executedLineCount); + } + + player.PrintStats(); + } + + return result; +} + +static int ProcessFile() +{ + if(g_Verbosity > VERBOSITY::MINIMUM) + { + printf("Loading file \"%s\"...\n", g_FilePath.c_str()); + } + int result = 0; + + FILE* file = nullptr; + const errno_t err = fopen_s(&file, g_FilePath.c_str(), "rb"); + if(err == 0) + { + _fseeki64(file, 0, SEEK_END); + const size_t fileSize = (size_t)_ftelli64(file); + _fseeki64(file, 0, SEEK_SET); + + if(fileSize > 0) + { + std::vector fileContents(fileSize); + fread(fileContents.data(), 1, fileSize, file); + + // Begin stats. + if(g_Verbosity == VERBOSITY::MAXIMUM) + { + printf("File size: %zu B\n", fileSize); + } + + duration durationSum = duration::zero(); + for(size_t i = 0; i < g_IterationCount; ++i) + { + duration currDuration; + ProcessFile(i, fileContents.data(), fileContents.size(), currDuration); + durationSum += currDuration; + } + + if(g_IterationCount > 1) + { + std::string playDurationStr; + SecondsToFriendlyStr(ToFloatSeconds(durationSum / g_IterationCount), playDurationStr); + printf("Average playback time from %zu iterations: %s\n", g_IterationCount, playDurationStr.c_str()); + } + } + else + { + printf("ERROR: Source file is empty.\n"); + result = RESULT_ERROR_SOURCE_FILE; + } + + fclose(file); + } + else + { + printf("ERROR: Couldn't open file (%i).\n", err); + result = RESULT_ERROR_SOURCE_FILE; + } + + return result; +} + +static int main2(int argc, char** argv) +{ + CmdLineParser cmdLineParser(argc, argv); + + cmdLineParser.RegisterOpt(CMD_LINE_OPT_VERBOSITY, 'v', true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_ITERATIONS, 'i', true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_LINES, "Lines", true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_PHYSICAL_DEVICE, "PhysicalDevice", true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_USER_DATA, "UserData", true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_VK_KHR_DEDICATED_ALLOCATION, "VK_KHR_dedicated_allocation", true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_VK_LAYER_LUNARG_STANDARD_VALIDATION, VALIDATION_LAYER_NAME, true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_MEM_STATS, "MemStats", true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_DUMP_STATS_AFTER_LINE, "DumpStatsAfterLine", true); + cmdLineParser.RegisterOpt(CMD_LINE_OPT_DUMP_DETAILED_STATS_AFTER_LINE, "DumpDetailedStatsAfterLine", true); + + CmdLineParser::RESULT res; + while((res = cmdLineParser.ReadNext()) != CmdLineParser::RESULT_END) + { + switch(res) + { + case CmdLineParser::RESULT_OPT: + switch(cmdLineParser.GetOptId()) + { + case CMD_LINE_OPT_VERBOSITY: + { + uint32_t verbosityVal = UINT32_MAX; + if(StrRangeToUint(StrRange(cmdLineParser.GetParameter()), verbosityVal) && + verbosityVal < (uint32_t)VERBOSITY::COUNT) + { + g_Verbosity = (VERBOSITY)verbosityVal; + } + else + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + } + break; + case CMD_LINE_OPT_ITERATIONS: + if(!StrRangeToUint(StrRange(cmdLineParser.GetParameter()), g_IterationCount)) + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + break; + case CMD_LINE_OPT_LINES: + if(!g_LineRanges.Parse(StrRange(cmdLineParser.GetParameter()))) + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + break; + case CMD_LINE_OPT_PHYSICAL_DEVICE: + if(!StrRangeToUint(StrRange(cmdLineParser.GetParameter()), g_PhysicalDeviceIndex)) + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + break; + case CMD_LINE_OPT_USER_DATA: + if(!StrRangeToBool(StrRange(cmdLineParser.GetParameter()), g_UserDataEnabled)) + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + break; + case CMD_LINE_OPT_VK_KHR_DEDICATED_ALLOCATION: + { + bool newValue; + if(StrRangeToBool(StrRange(cmdLineParser.GetParameter()), newValue)) + { + g_VK_KHR_dedicated_allocation_request = newValue ? + VULKAN_EXTENSION_REQUEST::ENABLED : + VULKAN_EXTENSION_REQUEST::DISABLED; + } + else + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + } + break; + case CMD_LINE_OPT_VK_LAYER_LUNARG_STANDARD_VALIDATION: + { + bool newValue; + if(StrRangeToBool(StrRange(cmdLineParser.GetParameter()), newValue)) + { + g_VK_LAYER_LUNARG_standard_validation = newValue ? + VULKAN_EXTENSION_REQUEST::ENABLED : + VULKAN_EXTENSION_REQUEST::DISABLED; + } + else + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + } + break; + case CMD_LINE_OPT_MEM_STATS: + if(!StrRangeToBool(StrRange(cmdLineParser.GetParameter()), g_MemStatsEnabled)) + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + break; + case CMD_LINE_OPT_DUMP_STATS_AFTER_LINE: + case CMD_LINE_OPT_DUMP_DETAILED_STATS_AFTER_LINE: + { + size_t line; + if(StrRangeToUint(StrRange(cmdLineParser.GetParameter()), line)) + { + const bool detailed = + cmdLineParser.GetOptId() == CMD_LINE_OPT_DUMP_DETAILED_STATS_AFTER_LINE; + g_DumpStatsAfterLine.push_back({line, detailed}); + } + else + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + } + break; + default: + assert(0); + } + break; + case CmdLineParser::RESULT_PARAMETER: + if(g_FilePath.empty()) + { + g_FilePath = cmdLineParser.GetParameter(); + } + else + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + break; + case CmdLineParser::RESULT_ERROR: + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + break; + default: + assert(0); + } + } + + // Postprocess command line parameters. + + if(g_FilePath.empty()) + { + PrintCommandLineSyntax(); + return RESULT_ERROR_COMMAND_LINE; + } + + // Sort g_DumpStatsAfterLine and make unique. + std::sort(g_DumpStatsAfterLine.begin(), g_DumpStatsAfterLine.end()); + g_DumpStatsAfterLine.erase( + std::unique(g_DumpStatsAfterLine.begin(), g_DumpStatsAfterLine.end()), + g_DumpStatsAfterLine.end()); + + return ProcessFile(); +} + +int main(int argc, char** argv) +{ + try + { + return main2(argc, argv); + } + catch(const std::exception& e) + { + printf("ERROR: %s\n", e.what()); + return RESULT_EXCEPTION; + } + catch(...) + { + printf("UNKNOWN ERROR\n"); + return RESULT_EXCEPTION; + } +} diff --git a/src/VmaReplay/VmaUsage.cpp b/src/VmaReplay/VmaUsage.cpp new file mode 100644 index 0000000..d2d035b --- /dev/null +++ b/src/VmaReplay/VmaUsage.cpp @@ -0,0 +1,2 @@ +#define VMA_IMPLEMENTATION +#include "VmaUsage.h" diff --git a/src/VmaReplay/VmaUsage.h b/src/VmaReplay/VmaUsage.h new file mode 100644 index 0000000..182132b --- /dev/null +++ b/src/VmaReplay/VmaUsage.h @@ -0,0 +1,27 @@ +#pragma once + +#define NOMINMAX +#define WIN32_LEAN_AND_MEAN +#include +#define VK_USE_PLATFORM_WIN32_KHR + +#include + +//#define VMA_USE_STL_CONTAINERS 1 + +//#define VMA_HEAVY_ASSERT(expr) assert(expr) + +//#define VMA_DEDICATED_ALLOCATION 0 + +//#define VMA_DEBUG_MARGIN 16 +//#define VMA_DEBUG_DETECT_CORRUPTION 1 +//#define VMA_DEBUG_INITIALIZE_ALLOCATIONS 1 + +#pragma warning(push, 4) +#pragma warning(disable: 4127) // conditional expression is constant +#pragma warning(disable: 4100) // unreferenced formal parameter +#pragma warning(disable: 4189) // local variable is initialized but not referenced + +#include "../vk_mem_alloc.h" + +#pragma warning(pop) diff --git a/src/VmaUsage.h b/src/VmaUsage.h index 79daaf8..e788a30 100644 --- a/src/VmaUsage.h +++ b/src/VmaUsage.h @@ -25,6 +25,7 @@ include all public interface declarations. Example: //#define VMA_DEBUG_MARGIN 16 //#define VMA_DEBUG_DETECT_CORRUPTION 1 //#define VMA_DEBUG_INITIALIZE_ALLOCATIONS 1 +//#define VMA_RECORDING_ENABLED 0 #pragma warning(push, 4) #pragma warning(disable: 4127) // conditional expression is constant diff --git a/src/VulkanSample.cpp b/src/VulkanSample.cpp index 91f2bf2..d33861e 100644 --- a/src/VulkanSample.cpp +++ b/src/VulkanSample.cpp @@ -190,6 +190,18 @@ VKAPI_ATTR VkBool32 VKAPI_CALL MyDebugReportCallback( { return VK_FALSE; } + + /* + "Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used." + Ignoring because we map entire VkDeviceMemory blocks, where different types of + images and buffers may end up together, especially on GPUs with unified memory + like Intel. + */ + if(strstr(pMessage, "Mapping an image with layout") != nullptr && + strstr(pMessage, "can result in undefined behavior if this memory is used by the device") != nullptr) + { + return VK_FALSE; + } switch(flags) { diff --git a/src/vk_mem_alloc.h b/src/vk_mem_alloc.h index f0cb5ed..ce04a15 100644 --- a/src/vk_mem_alloc.h +++ b/src/vk_mem_alloc.h @@ -29,7 +29,7 @@ extern "C" { /** \mainpage Vulkan Memory Allocator -Version 2.1.0-alpha.3 (2018-06-14) +Version 2.1.0-alpha.4 (2018-08-22) Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. \n License: MIT @@ -67,6 +67,7 @@ Documentation of all members: vk_mem_alloc.h - [Memory initialization](@ref debugging_memory_usage_initialization) - [Margins](@ref debugging_memory_usage_margins) - [Corruption detection](@ref debugging_memory_usage_corruption_detection) + - \subpage record_and_replay - \subpage usage_patterns - [Simple patterns](@ref usage_patterns_simple) - [Advanced patterns](@ref usage_patterns_advanced) @@ -298,7 +299,7 @@ The library provides following functions for mapping of a specific #VmaAllocatio They are safer and more convenient to use than standard Vulkan functions. You can map an allocation multiple times simultaneously - mapping is reference-counted internally. You can also map different allocations simultaneously regardless of whether they use the same `VkDeviceMemory` block. -They way it's implemented is that the library always maps entire memory block, not just region of the allocation. +The way it's implemented is that the library always maps entire memory block, not just region of the allocation. For further details, see description of vmaMapMemory() function. Example: @@ -312,7 +313,7 @@ struct ConstantBuffer ConstantBuffer constantBufferData; VmaAllocator allocator; -VmaBuffer constantBuffer; +VkBuffer constantBuffer; VmaAllocation constantBufferAllocation; // You can map and fill your buffer using following code: @@ -323,6 +324,16 @@ memcpy(mappedData, &constantBufferData, sizeof(constantBufferData)); vmaUnmapMemory(allocator, constantBufferAllocation); \endcode +When mapping, you may see a warning from Vulkan validation layer similar to this one: + +Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used. + +It happens because the library maps entire `VkDeviceMemory` block, where different +types of images and buffers may end up together, especially on GPUs with unified memory like Intel. +You can safely ignore it if you are sure you access only memory of the intended +object that you wanted to map. + + \section memory_mapping_persistently_mapped_memory Persistently mapped memory Kepping your memory persistently mapped is generally OK in Vulkan. @@ -910,6 +921,52 @@ Margin validation (corruption detection) works only for memory types that are `HOST_VISIBLE` and `HOST_COHERENT`. +\page record_and_replay Record and replay + +\section record_and_replay_introduction Introduction + +While using the library, sequence of calls to its functions together with their +parameters can be recorded to a file and later replayed using standalone player +application. It can be useful to: + +- Test correctness - check if same sequence of calls will not cause crash or + failures on a target platform. +- Gather statistics - see number of allocations, peak memory usage, number of + calls etc. +- Benchmark performance - see how much time it takes to replay the whole + sequence. + +\section record_and_replay_usage Usage + +To record sequence of calls to a file: Fill in +VmaAllocatorCreateInfo::pRecordSettings member while creating #VmaAllocator +object. File is opened and written during whole lifetime of the allocator. + +To replay file: Use VmaReplay - standalone command-line program. +Precompiled binary can be found in "bin" directory. +Its source can be found in "src/VmaReplay" directory. +Its project is generated by Premake. +Command line syntax is printed when the program is launched without parameters. +Basic usage: + + VmaReplay.exe MyRecording.csv + +Documentation of file format can be found in file: "docs/Recording file format.md". +It's a human-readable, text file in CSV format (Comma Separated Values). + +\section record_and_replay_additional_considerations Additional considerations + +- Replaying file that was recorded on a different GPU (with different parameters + like `bufferImageGranularity`, `nonCoherentAtomSize`, and especially different + set of memory heaps and types) may give different performance and memory usage + results, as well as issue some warnings and errors. +- Current implementation of recording in VMA, as well as VmaReplay application, is + coded and tested only on Windows. Inclusion of recording code is driven by + `VMA_RECORDING_ENABLED` macro. Support for other platforms should be easy to + add. Contributions are welcomed. +- Currently calls to vmaDefragment() function are not recorded. + + \page usage_patterns Recommended usage patterns See also slides from talk: @@ -1150,6 +1207,23 @@ To learn more about this extension, see: threads at the same time if you pass the same #VmaAllocation object to these functions. +\section general_considerations_validation_layer_warnings Validation layer warnings + +When using this library, you can meet following types of warnings issued by +Vulkan validation layer. They don't necessarily indicate a bug, so you may need +to just ignore them. + +- *vkBindBufferMemory(): Binding memory to buffer 0xeb8e4 but vkGetBufferMemoryRequirements() has not been called on that buffer.* + - It happens when VK_KHR_dedicated_allocation extension is enabled. + `vkGetBufferMemoryRequirements2KHR` function is used instead, while validation layer seems to be unaware of it. +- *Mapping an image with layout VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL can result in undefined behavior if this memory is used by the device. Only GENERAL or PREINITIALIZED should be used.* + - It happens when you map a buffer or image, because the library maps entire + `VkDeviceMemory` block, where different types of images and buffers may end + up together, especially on GPUs with unified memory like Intel. +- *Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug.* + - It happens when you use lost allocations, and a new image or buffer is + created in place of an existing object that bacame lost. + \section general_considerations_allocation_algorithm Allocation algorithm The library uses following algorithm for allocation, in order: @@ -1171,7 +1245,7 @@ The library uses following algorithm for allocation, in order: Features deliberately excluded from the scope of this library: - Data transfer - issuing commands that transfer data between buffers or images, any usage of - `VkCommandList` or `VkCommandQueue` and related synchronization is responsibility of the user. + `VkCommandList` or `VkQueue` and related synchronization is responsibility of the user. - Allocations for imported/exported external memory. They tend to require explicit memory type index and dedicated allocation anyway, so they don't interact with main features of this library. Such special purpose allocations @@ -1290,6 +1364,46 @@ typedef struct VmaVulkanFunctions { #endif } VmaVulkanFunctions; +/// Flags to be used in VmaRecordSettings::flags. +typedef enum VmaRecordFlagBits { + /** \brief Enables flush after recording every function call. + + Enable it if you expect your application to crash, which may leave recording file truncated. + It may degrade performance though. + */ + VMA_RECORD_FLUSH_AFTER_CALL_BIT = 0x00000001, + + VMA_RECORD_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VmaRecordFlagBits; +typedef VkFlags VmaRecordFlags; + +/* +Define this macro to 0/1 to disable/enable support for recording functionality, +available through VmaAllocatorCreateInfo::pRecordSettings. +*/ +#ifndef VMA_RECORDING_ENABLED + #ifdef _WIN32 + #define VMA_RECORDING_ENABLED 1 + #else + #define VMA_RECORDING_ENABLED 0 + #endif +#endif + +/// Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings. +typedef struct VmaRecordSettings +{ + /// Flags for recording. Use #VmaRecordFlagBits enum. + VmaRecordFlags flags; + /** \brief Path to the file that should be written by the recording. + + Suggested extension: "csv". + If the file already exists, it will be overwritten. + It will be opened for the whole time #VmaAllocator object is alive. + If opening this file fails, creation of the whole allocator object fails. + */ + const char* pFilePath; +} VmaRecordSettings; + /// Description of a Allocator to be created. typedef struct VmaAllocatorCreateInfo { @@ -1360,6 +1474,13 @@ typedef struct VmaAllocatorCreateInfo e.g. fetched using `vkGetInstanceProcAddr()` and `vkGetDeviceProcAddr()`. */ const VmaVulkanFunctions* pVulkanFunctions; + /** \brief Parameters for recording of VMA calls. Can be null. + + If not null, it enables recording of calls to VMA functions to a file. + If support for recording is not enabled using `VMA_RECORDING_ENABLED` macro, + creation of the allocator object fails with `VK_ERROR_FEATURE_NOT_PRESENT`. + */ + const VmaRecordSettings* pRecordSettings; } VmaAllocatorCreateInfo; /// Creates Allocator object. @@ -2694,6 +2815,11 @@ inline T VmaRoundDiv(T x, T y) return (x + (y / (T)2)) / y; } +static inline bool VmaStrIsEmpty(const char* pStr) +{ + return pStr == VMA_NULL || *pStr == '\0'; +} + #ifndef VMA_SORT template @@ -4835,6 +4961,106 @@ public: uint32_t maxAllocationsToMove); }; +#if VMA_RECORDING_ENABLED + +class VmaRecorder +{ +public: + VmaRecorder(); + VkResult Init(const VmaRecordSettings& settings, bool useMutex); + void WriteConfiguration( + const VkPhysicalDeviceProperties& devProps, + const VkPhysicalDeviceMemoryProperties& memProps, + bool dedicatedAllocationExtensionEnabled); + ~VmaRecorder(); + + void RecordCreateAllocator(uint32_t frameIndex); + void RecordDestroyAllocator(uint32_t frameIndex); + void RecordCreatePool(uint32_t frameIndex, + const VmaPoolCreateInfo& createInfo, + VmaPool pool); + void RecordDestroyPool(uint32_t frameIndex, VmaPool pool); + void RecordAllocateMemory(uint32_t frameIndex, + const VkMemoryRequirements& vkMemReq, + const VmaAllocationCreateInfo& createInfo, + VmaAllocation allocation); + void RecordAllocateMemoryForBuffer(uint32_t frameIndex, + const VkMemoryRequirements& vkMemReq, + bool requiresDedicatedAllocation, + bool prefersDedicatedAllocation, + const VmaAllocationCreateInfo& createInfo, + VmaAllocation allocation); + void RecordAllocateMemoryForImage(uint32_t frameIndex, + const VkMemoryRequirements& vkMemReq, + bool requiresDedicatedAllocation, + bool prefersDedicatedAllocation, + const VmaAllocationCreateInfo& createInfo, + VmaAllocation allocation); + void RecordFreeMemory(uint32_t frameIndex, + VmaAllocation allocation); + void RecordSetAllocationUserData(uint32_t frameIndex, + VmaAllocation allocation, + const void* pUserData); + void RecordCreateLostAllocation(uint32_t frameIndex, + VmaAllocation allocation); + void RecordMapMemory(uint32_t frameIndex, + VmaAllocation allocation); + void RecordUnmapMemory(uint32_t frameIndex, + VmaAllocation allocation); + void RecordFlushAllocation(uint32_t frameIndex, + VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size); + void RecordInvalidateAllocation(uint32_t frameIndex, + VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size); + void RecordCreateBuffer(uint32_t frameIndex, + const VkBufferCreateInfo& bufCreateInfo, + const VmaAllocationCreateInfo& allocCreateInfo, + VmaAllocation allocation); + void RecordCreateImage(uint32_t frameIndex, + const VkImageCreateInfo& imageCreateInfo, + const VmaAllocationCreateInfo& allocCreateInfo, + VmaAllocation allocation); + void RecordDestroyBuffer(uint32_t frameIndex, + VmaAllocation allocation); + void RecordDestroyImage(uint32_t frameIndex, + VmaAllocation allocation); + void RecordTouchAllocation(uint32_t frameIndex, + VmaAllocation allocation); + void RecordGetAllocationInfo(uint32_t frameIndex, + VmaAllocation allocation); + void RecordMakePoolAllocationsLost(uint32_t frameIndex, + VmaPool pool); + +private: + struct CallParams + { + uint32_t threadId; + double time; + }; + + class UserDataString + { + public: + UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData); + const char* GetString() const { return m_Str; } + + private: + char m_PtrStr[17]; + const char* m_Str; + }; + + bool m_UseMutex; + VmaRecordFlags m_Flags; + FILE* m_File; + VMA_MUTEX m_FileMutex; + int64_t m_Freq; + int64_t m_StartCounter; + + void GetBasicParams(CallParams& outParams); + void Flush(); +}; + +#endif // #if VMA_RECORDING_ENABLED + // Main allocator object. struct VmaAllocator_T { @@ -4863,6 +5089,7 @@ public: VMA_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES]; VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo); + VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo); ~VmaAllocator_T(); const VkAllocationCallbacks* GetAllocationCallbacks() const @@ -4908,6 +5135,10 @@ public: return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; } +#if VMA_RECORDING_ENABLED + VmaRecorder* GetRecorder() const { return m_pRecorder; } +#endif + void GetBufferMemoryRequirements( VkBuffer hBuffer, VkMemoryRequirements& memReq, @@ -4954,6 +5185,7 @@ public: void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats); void SetCurrentFrameIndex(uint32_t frameIndex); + uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); } void MakePoolAllocationsLost( VmaPool hPool, @@ -4992,6 +5224,10 @@ private: VmaVulkanFunctions m_VulkanFunctions; +#if VMA_RECORDING_ENABLED + VmaRecorder* m_pRecorder; +#endif + void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions); VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex); @@ -5272,7 +5508,7 @@ void VmaJsonWriter::ContinueString(const char* pStr) for(size_t i = 0; i < strLen; ++i) { char ch = pStr[i]; - if(ch == '\'') + if(ch == '\\') { m_SB.Add("\\\\"); } @@ -9220,6 +9456,480 @@ bool VmaDefragmentator::MoveMakesSense( return false; } +//////////////////////////////////////////////////////////////////////////////// +// VmaRecorder + +#if VMA_RECORDING_ENABLED + +VmaRecorder::VmaRecorder() : + m_UseMutex(true), + m_Flags(0), + m_File(VMA_NULL), + m_Freq(INT64_MAX), + m_StartCounter(INT64_MAX) +{ +} + +VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex) +{ + m_UseMutex = useMutex; + m_Flags = settings.flags; + + QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq); + QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter); + + // Open file for writing. + errno_t err = fopen_s(&m_File, settings.pFilePath, "wb"); + if(err != 0) + { + return VK_ERROR_INITIALIZATION_FAILED; + } + + // Write header. + fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording"); + fprintf(m_File, "%s\n", "1,3"); + + return VK_SUCCESS; +} + +VmaRecorder::~VmaRecorder() +{ + if(m_File != VMA_NULL) + { + fclose(m_File); + } +} + +void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex); + Flush(); +} + +void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex); + Flush(); +} + +void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex, + createInfo.memoryTypeIndex, + createInfo.flags, + createInfo.blockSize, + createInfo.minBlockCount, + createInfo.maxBlockCount, + createInfo.frameInUseCount, + pool); + Flush(); +} + +void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex, + pool); + Flush(); +} + +void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex, + const VkMemoryRequirements& vkMemReq, + const VmaAllocationCreateInfo& createInfo, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + UserDataString userDataStr(createInfo.flags, createInfo.pUserData); + fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex, + vkMemReq.size, + vkMemReq.alignment, + vkMemReq.memoryTypeBits, + createInfo.flags, + createInfo.usage, + createInfo.requiredFlags, + createInfo.preferredFlags, + createInfo.memoryTypeBits, + createInfo.pool, + allocation, + userDataStr.GetString()); + Flush(); +} + +void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex, + const VkMemoryRequirements& vkMemReq, + bool requiresDedicatedAllocation, + bool prefersDedicatedAllocation, + const VmaAllocationCreateInfo& createInfo, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + UserDataString userDataStr(createInfo.flags, createInfo.pUserData); + 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, + vkMemReq.size, + vkMemReq.alignment, + vkMemReq.memoryTypeBits, + requiresDedicatedAllocation ? 1 : 0, + prefersDedicatedAllocation ? 1 : 0, + createInfo.flags, + createInfo.usage, + createInfo.requiredFlags, + createInfo.preferredFlags, + createInfo.memoryTypeBits, + createInfo.pool, + allocation, + userDataStr.GetString()); + Flush(); +} + +void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex, + const VkMemoryRequirements& vkMemReq, + bool requiresDedicatedAllocation, + bool prefersDedicatedAllocation, + const VmaAllocationCreateInfo& createInfo, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + UserDataString userDataStr(createInfo.flags, createInfo.pUserData); + 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, + vkMemReq.size, + vkMemReq.alignment, + vkMemReq.memoryTypeBits, + requiresDedicatedAllocation ? 1 : 0, + prefersDedicatedAllocation ? 1 : 0, + createInfo.flags, + createInfo.usage, + createInfo.requiredFlags, + createInfo.preferredFlags, + createInfo.memoryTypeBits, + createInfo.pool, + allocation, + userDataStr.GetString()); + Flush(); +} + +void VmaRecorder::RecordFreeMemory(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex, + VmaAllocation allocation, + const void* pUserData) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + UserDataString userDataStr( + allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0, + pUserData); + fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex, + allocation, + userDataStr.GetString()); + Flush(); +} + +void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordMapMemory(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex, + VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex, + allocation, + offset, + size); + Flush(); +} + +void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex, + VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex, + allocation, + offset, + size); + Flush(); +} + +void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex, + const VkBufferCreateInfo& bufCreateInfo, + const VmaAllocationCreateInfo& allocCreateInfo, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData); + 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, + bufCreateInfo.flags, + bufCreateInfo.size, + bufCreateInfo.usage, + bufCreateInfo.sharingMode, + allocCreateInfo.flags, + allocCreateInfo.usage, + allocCreateInfo.requiredFlags, + allocCreateInfo.preferredFlags, + allocCreateInfo.memoryTypeBits, + allocCreateInfo.pool, + allocation, + userDataStr.GetString()); + Flush(); +} + +void VmaRecorder::RecordCreateImage(uint32_t frameIndex, + const VkImageCreateInfo& imageCreateInfo, + const VmaAllocationCreateInfo& allocCreateInfo, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData); + 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, + imageCreateInfo.flags, + imageCreateInfo.imageType, + imageCreateInfo.format, + imageCreateInfo.extent.width, + imageCreateInfo.extent.height, + imageCreateInfo.extent.depth, + imageCreateInfo.mipLevels, + imageCreateInfo.arrayLayers, + imageCreateInfo.samples, + imageCreateInfo.tiling, + imageCreateInfo.usage, + imageCreateInfo.sharingMode, + imageCreateInfo.initialLayout, + allocCreateInfo.flags, + allocCreateInfo.usage, + allocCreateInfo.requiredFlags, + allocCreateInfo.preferredFlags, + allocCreateInfo.memoryTypeBits, + allocCreateInfo.pool, + allocation, + userDataStr.GetString()); + Flush(); +} + +void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordDestroyImage(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex, + VmaAllocation allocation) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex, + allocation); + Flush(); +} + +void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex, + VmaPool pool) +{ + CallParams callParams; + GetBasicParams(callParams); + + VmaMutexLock lock(m_FileMutex, m_UseMutex); + fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex, + pool); + Flush(); +} + +VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData) +{ + if(pUserData != VMA_NULL) + { + if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0) + { + m_Str = (const char*)pUserData; + } + else + { + sprintf_s(m_PtrStr, "%p", pUserData); + m_Str = m_PtrStr; + } + } + else + { + m_Str = ""; + } +} + +void VmaRecorder::WriteConfiguration( + const VkPhysicalDeviceProperties& devProps, + const VkPhysicalDeviceMemoryProperties& memProps, + bool dedicatedAllocationExtensionEnabled) +{ + fprintf(m_File, "Config,Begin\n"); + + fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion); + fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion); + fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID); + fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID); + fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType); + fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName); + + fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount); + fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity); + fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize); + + fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount); + for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i) + { + fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size); + fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags); + } + fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount); + for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i) + { + fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex); + fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags); + } + + fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0); + + fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0); + fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT); + fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN); + fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0); + fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0); + fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0); + fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY); + fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE); + fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE); + + fprintf(m_File, "Config,End\n"); +} + +void VmaRecorder::GetBasicParams(CallParams& outParams) +{ + outParams.threadId = GetCurrentThreadId(); + + LARGE_INTEGER counter; + QueryPerformanceCounter(&counter); + outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq; +} + +void VmaRecorder::Flush() +{ + if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0) + { + fflush(m_File); + } +} + +#endif // #if VMA_RECORDING_ENABLED + //////////////////////////////////////////////////////////////////////////////// // VmaAllocator_T @@ -9235,6 +9945,9 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) : m_CurrentFrameIndex(0), m_Pools(VmaStlAllocator(GetAllocationCallbacks())), m_NextPoolId(0) +#if VMA_RECORDING_ENABLED + ,m_pRecorder(VMA_NULL) +#endif { if(VMA_DEBUG_DETECT_CORRUPTION) { @@ -9314,8 +10027,44 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) : } } +VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo) +{ + VkResult res = VK_SUCCESS; + + if(pCreateInfo->pRecordSettings != VMA_NULL && + !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath)) + { +#if VMA_RECORDING_ENABLED + m_pRecorder = vma_new(this, VmaRecorder)(); + res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex); + if(res != VK_SUCCESS) + { + return res; + } + m_pRecorder->WriteConfiguration( + m_PhysicalDeviceProperties, + m_MemProps, + m_UseKhrDedicatedAllocation); + m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex()); +#else + VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1."); + return VK_ERROR_FEATURE_NOT_PRESENT; +#endif + } + + return res; +} + VmaAllocator_T::~VmaAllocator_T() { +#if VMA_RECORDING_ENABLED + if(m_pRecorder != VMA_NULL) + { + m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex()); + vma_delete(this, m_pRecorder); + } +#endif + VMA_ASSERT(m_Pools.empty()); for(size_t i = GetMemoryTypeCount(); i--; ) @@ -10623,32 +11372,6 @@ void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json) #endif // #if VMA_STATS_STRING_ENABLED -static VkResult AllocateMemoryForImage( - VmaAllocator allocator, - VkImage image, - const VmaAllocationCreateInfo* pAllocationCreateInfo, - VmaSuballocationType suballocType, - VmaAllocation* pAllocation) -{ - VMA_ASSERT(allocator && (image != VK_NULL_HANDLE) && pAllocationCreateInfo && pAllocation); - - VkMemoryRequirements vkMemReq = {}; - bool requiresDedicatedAllocation = false; - bool prefersDedicatedAllocation = false; - allocator->GetImageMemoryRequirements(image, vkMemReq, - requiresDedicatedAllocation, prefersDedicatedAllocation); - - return allocator->AllocateMemory( - vkMemReq, - requiresDedicatedAllocation, - prefersDedicatedAllocation, - VK_NULL_HANDLE, // dedicatedBuffer - image, // dedicatedImage - *pAllocationCreateInfo, - suballocType, - pAllocation); -} - //////////////////////////////////////////////////////////////////////////////// // Public interface @@ -10659,7 +11382,7 @@ VkResult vmaCreateAllocator( VMA_ASSERT(pCreateInfo && pAllocator); VMA_DEBUG_LOG("vmaCreateAllocator"); *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo); - return VK_SUCCESS; + return (*pAllocator)->Init(pCreateInfo); } void vmaDestroyAllocator( @@ -11004,12 +11727,21 @@ VkResult vmaCreatePool( VmaPool* pPool) { VMA_ASSERT(allocator && pCreateInfo && pPool); - + VMA_DEBUG_LOG("vmaCreatePool"); - + VMA_DEBUG_GLOBAL_MUTEX_LOCK - - return allocator->CreatePool(pCreateInfo, pPool); + + VkResult res = allocator->CreatePool(pCreateInfo, pPool); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool); + } +#endif + + return res; } void vmaDestroyPool( @@ -11017,15 +11749,22 @@ void vmaDestroyPool( VmaPool pool) { VMA_ASSERT(allocator); - + if(pool == VK_NULL_HANDLE) { return; } - + VMA_DEBUG_LOG("vmaDestroyPool"); - + VMA_DEBUG_GLOBAL_MUTEX_LOCK + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool); + } +#endif allocator->DestroyPool(pool); } @@ -11051,6 +11790,13 @@ void vmaMakePoolAllocationsLost( VMA_DEBUG_GLOBAL_MUTEX_LOCK +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool); + } +#endif + allocator->MakePoolAllocationsLost(pool, pLostAllocationCount); } @@ -11088,7 +11834,18 @@ VkResult vmaAllocateMemory( VMA_SUBALLOCATION_TYPE_UNKNOWN, pAllocation); - if(pAllocationInfo && result == VK_SUCCESS) +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordAllocateMemory( + allocator->GetCurrentFrameIndex(), + *pVkMemoryRequirements, + *pCreateInfo, + *pAllocation); + } +#endif + + if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS) { allocator->GetAllocationInfo(*pAllocation, pAllocationInfo); } @@ -11126,6 +11883,19 @@ VkResult vmaAllocateMemoryForBuffer( VMA_SUBALLOCATION_TYPE_BUFFER, pAllocation); +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordAllocateMemoryForBuffer( + allocator->GetCurrentFrameIndex(), + vkMemReq, + requiresDedicatedAllocation, + prefersDedicatedAllocation, + *pCreateInfo, + *pAllocation); + } +#endif + if(pAllocationInfo && result == VK_SUCCESS) { allocator->GetAllocationInfo(*pAllocation, pAllocationInfo); @@ -11147,13 +11917,35 @@ VkResult vmaAllocateMemoryForImage( VMA_DEBUG_GLOBAL_MUTEX_LOCK - VkResult result = AllocateMemoryForImage( - allocator, - image, - pCreateInfo, + VkMemoryRequirements vkMemReq = {}; + bool requiresDedicatedAllocation = false; + bool prefersDedicatedAllocation = false; + allocator->GetImageMemoryRequirements(image, vkMemReq, + requiresDedicatedAllocation, prefersDedicatedAllocation); + + VkResult result = allocator->AllocateMemory( + vkMemReq, + requiresDedicatedAllocation, + prefersDedicatedAllocation, + VK_NULL_HANDLE, // dedicatedBuffer + image, // dedicatedImage + *pCreateInfo, VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN, pAllocation); +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordAllocateMemoryForImage( + allocator->GetCurrentFrameIndex(), + vkMemReq, + requiresDedicatedAllocation, + prefersDedicatedAllocation, + *pCreateInfo, + *pAllocation); + } +#endif + if(pAllocationInfo && result == VK_SUCCESS) { allocator->GetAllocationInfo(*pAllocation, pAllocationInfo); @@ -11167,12 +11959,26 @@ void vmaFreeMemory( VmaAllocation allocation) { VMA_ASSERT(allocator); - VMA_DEBUG_LOG("vmaFreeMemory"); - VMA_DEBUG_GLOBAL_MUTEX_LOCK - if(allocation != VK_NULL_HANDLE) + + if(allocation == VK_NULL_HANDLE) { - allocator->FreeMemory(allocation); + return; } + + VMA_DEBUG_LOG("vmaFreeMemory"); + + VMA_DEBUG_GLOBAL_MUTEX_LOCK + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordFreeMemory( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + + allocator->FreeMemory(allocation); } void vmaGetAllocationInfo( @@ -11184,6 +11990,15 @@ void vmaGetAllocationInfo( VMA_DEBUG_GLOBAL_MUTEX_LOCK +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordGetAllocationInfo( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + allocator->GetAllocationInfo(allocation, pAllocationInfo); } @@ -11195,6 +12010,15 @@ VkBool32 vmaTouchAllocation( VMA_DEBUG_GLOBAL_MUTEX_LOCK +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordTouchAllocation( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + return allocator->TouchAllocation(allocation); } @@ -11208,6 +12032,16 @@ void vmaSetAllocationUserData( VMA_DEBUG_GLOBAL_MUTEX_LOCK allocation->SetUserData(allocator, pUserData); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordSetAllocationUserData( + allocator->GetCurrentFrameIndex(), + allocation, + pUserData); + } +#endif } void vmaCreateLostAllocation( @@ -11219,6 +12053,15 @@ void vmaCreateLostAllocation( VMA_DEBUG_GLOBAL_MUTEX_LOCK; allocator->CreateLostAllocation(pAllocation); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordCreateLostAllocation( + allocator->GetCurrentFrameIndex(), + *pAllocation); + } +#endif } VkResult vmaMapMemory( @@ -11230,7 +12073,18 @@ VkResult vmaMapMemory( VMA_DEBUG_GLOBAL_MUTEX_LOCK - return allocator->Map(allocation, ppData); + VkResult res = allocator->Map(allocation, ppData); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordMapMemory( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + + return res; } void vmaUnmapMemory( @@ -11241,6 +12095,15 @@ void vmaUnmapMemory( VMA_DEBUG_GLOBAL_MUTEX_LOCK +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordUnmapMemory( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + allocator->Unmap(allocation); } @@ -11253,6 +12116,15 @@ void vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDevi VMA_DEBUG_GLOBAL_MUTEX_LOCK allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordFlushAllocation( + allocator->GetCurrentFrameIndex(), + allocation, offset, size); + } +#endif } void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size) @@ -11264,6 +12136,15 @@ void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, V VMA_DEBUG_GLOBAL_MUTEX_LOCK allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordInvalidateAllocation( + allocator->GetCurrentFrameIndex(), + allocation, offset, size); + } +#endif } VkResult vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits) @@ -11354,8 +12235,8 @@ VkResult vmaCreateBuffer( allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq, requiresDedicatedAllocation, prefersDedicatedAllocation); - // Make sure alignment requirements for specific buffer usages reported - // in Physical Device Properties are included in alignment reported by memory requirements. + // Make sure alignment requirements for specific buffer usages reported + // in Physical Device Properties are included in alignment reported by memory requirements. if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0) { VMA_ASSERT(vkMemReq.alignment % @@ -11382,6 +12263,18 @@ VkResult vmaCreateBuffer( *pAllocationCreateInfo, VMA_SUBALLOCATION_TYPE_BUFFER, pAllocation); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordCreateBuffer( + allocator->GetCurrentFrameIndex(), + *pBufferCreateInfo, + *pAllocationCreateInfo, + *pAllocation); + } +#endif + if(res >= 0) { // 3. Bind buffer with memory. @@ -11396,6 +12289,7 @@ VkResult vmaCreateBuffer( { allocator->GetAllocationInfo(*pAllocation, pAllocationInfo); } + return VK_SUCCESS; } allocator->FreeMemory(*pAllocation); @@ -11417,12 +12311,30 @@ void vmaDestroyBuffer( VmaAllocation allocation) { VMA_ASSERT(allocator); + + if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE) + { + return; + } + VMA_DEBUG_LOG("vmaDestroyBuffer"); + VMA_DEBUG_GLOBAL_MUTEX_LOCK + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordDestroyBuffer( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + if(buffer != VK_NULL_HANDLE) { (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks()); } + if(allocation != VK_NULL_HANDLE) { allocator->FreeMemory(allocation); @@ -11459,7 +12371,33 @@ VkResult vmaCreateImage( VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR; // 2. Allocate memory using allocator. - res = AllocateMemoryForImage(allocator, *pImage, pAllocationCreateInfo, suballocType, pAllocation); + VkMemoryRequirements vkMemReq = {}; + bool requiresDedicatedAllocation = false; + bool prefersDedicatedAllocation = false; + allocator->GetImageMemoryRequirements(*pImage, vkMemReq, + requiresDedicatedAllocation, prefersDedicatedAllocation); + + res = allocator->AllocateMemory( + vkMemReq, + requiresDedicatedAllocation, + prefersDedicatedAllocation, + VK_NULL_HANDLE, // dedicatedBuffer + *pImage, // dedicatedImage + *pAllocationCreateInfo, + suballocType, + pAllocation); + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordCreateImage( + allocator->GetCurrentFrameIndex(), + *pImageCreateInfo, + *pAllocationCreateInfo, + *pAllocation); + } +#endif + if(res >= 0) { // 3. Bind image with memory. @@ -11474,6 +12412,7 @@ VkResult vmaCreateImage( { allocator->GetAllocationInfo(*pAllocation, pAllocationInfo); } + return VK_SUCCESS; } allocator->FreeMemory(*pAllocation); @@ -11495,8 +12434,25 @@ void vmaDestroyImage( VmaAllocation allocation) { VMA_ASSERT(allocator); + + if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE) + { + return; + } + VMA_DEBUG_LOG("vmaDestroyImage"); + VMA_DEBUG_GLOBAL_MUTEX_LOCK + +#if VMA_RECORDING_ENABLED + if(allocator->GetRecorder() != VMA_NULL) + { + allocator->GetRecorder()->RecordDestroyImage( + allocator->GetCurrentFrameIndex(), + allocation); + } +#endif + if(image != VK_NULL_HANDLE) { (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());