Merge branch 'master' into MemoryBudget

Author: adam-sawicki-a

docs/Recording file format.md

@@ -23,7 +23,7 @@ Formats with only minor version incremented are backward compatible.
 VmaReplay application supports all older versions.
 Current version is:
 
-    1,6
+    1,7
 
 # Configuration
 
@@ -243,6 +243,11 @@ No parameters.
 
 - context : pointer
 
+**vmaSetPoolName** (min format version: 1.7)
+
+- pool : pointer
+- pName : string (may contain additional commas)
+
 # Data types
 
 **bool**
@@ -271,7 +276,7 @@ An ordered sequence of values of some type, separated by single space.
 # Example file
 
     Vulkan Memory Allocator,Calls recording
-    1,6
+    1,7
     Config,Begin
     PhysicalDevice,apiVersion,4198477
     PhysicalDevice,driverVersion,8388653

src/Doxyfile

@@ -1988,8 +1988,8 @@ static void TestBasics()
 
 void TestHeapSizeLimit()
 {
-    const VkDeviceSize HEAP_SIZE_LIMIT = 1ull * 1024 * 1024 * 1024; // 1 GB
-    const VkDeviceSize BLOCK_SIZE      = 128ull * 1024 * 1024;      // 128 MB
+    const VkDeviceSize HEAP_SIZE_LIMIT = 200ull * 1024 * 1024; // 200 MB
+    const VkDeviceSize BLOCK_SIZE      =  20ull * 1024 * 1024; // 20 MB
 
     VkDeviceSize heapSizeLimit[VK_MAX_MEMORY_HEAPS];
     for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
@@ -3111,6 +3111,18 @@ static void TestPool_SameSize()
     res = vmaCreatePool(g_hAllocator, &poolCreateInfo, &pool);
     TEST(res == VK_SUCCESS);
 
+    // Test pool name
+    {
+        static const char* const POOL_NAME = "Pool name";
+        vmaSetPoolName(g_hAllocator, pool, POOL_NAME);
+
+        const char* fetchedPoolName = nullptr;
+        vmaGetPoolName(g_hAllocator, pool, &fetchedPoolName);
+        TEST(strcmp(fetchedPoolName, POOL_NAME) == 0);
+
+        vmaSetPoolName(g_hAllocator, pool, nullptr);
+    }
+
     vmaSetCurrentFrameIndex(g_hAllocator, 1);
 
     VmaAllocationCreateInfo allocInfo = {};

src/Tests.cpp

@@ -173,9 +173,16 @@ class CsvSplit
     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] };
+        if(index < m_Count)
+        {
+            return StrRange {
+                m_Line.beg + m_Ranges[index * 2],
+                m_Line.beg + m_Ranges[index * 2 + 1] };
+        }
+        else
+        {
+            return StrRange{0, 0};
+        }
     }
 
 private:

src/VmaReplay/Common.h

@@ -54,6 +54,7 @@ const char* VMA_FUNCTION_NAMES[] = {
     "vmaResizeAllocation",
     "vmaDefragmentationBegin",
     "vmaDefragmentationEnd",
+    "vmaSetPoolName",
 };
 static_assert(
     _countof(VMA_FUNCTION_NAMES) == (size_t)VMA_FUNCTION::Count,

src/VmaReplay/Constants.cpp

@@ -87,6 +87,7 @@ enum class VMA_FUNCTION
     ResizeAllocation,
     DefragmentationBegin,
     DefragmentationEnd,
+    SetPoolName,
     Count
 };
 extern const char* VMA_FUNCTION_NAMES[];

src/VmaReplay/Constants.h

@@ -688,7 +688,7 @@ static size_t g_DefragmentAfterLineNextIndex = 0;
 static bool ValidateFileVersion()
 {
     if(GetVersionMajor(g_FileVersion) == 1 &&
-        GetVersionMinor(g_FileVersion) <= 6)
+        GetVersionMinor(g_FileVersion) <= 7)
     {
         return true;
     }
@@ -1665,6 +1665,7 @@ class Player
     void ExecuteResizeAllocation(size_t lineNumber, const CsvSplit& csvSplit);
     void ExecuteDefragmentationBegin(size_t lineNumber, const CsvSplit& csvSplit);
     void ExecuteDefragmentationEnd(size_t lineNumber, const CsvSplit& csvSplit);
+    void ExecuteSetPoolName(size_t lineNumber, const CsvSplit& csvSplit);
 
     void DestroyAllocation(size_t lineNumber, const CsvSplit& csvSplit, const char* functionName);
 
@@ -1819,6 +1820,8 @@ void Player::ExecuteLine(size_t lineNumber, const StrRange& line)
             ExecuteDefragmentationBegin(lineNumber, csvSplit);
         else if(StrRangeEq(functionName, VMA_FUNCTION_NAMES[(uint32_t)VMA_FUNCTION::DefragmentationEnd]))
             ExecuteDefragmentationEnd(lineNumber, csvSplit);
+        else if(StrRangeEq(functionName, VMA_FUNCTION_NAMES[(uint32_t)VMA_FUNCTION::SetPoolName]))
+            ExecuteSetPoolName(lineNumber, csvSplit);
         else
         {
             if(IssueWarning())
@@ -3863,6 +3866,48 @@ void Player::ExecuteDefragmentationEnd(size_t lineNumber, const CsvSplit& csvSpl
     }
 }
 
+void Player::ExecuteSetPoolName(size_t lineNumber, const CsvSplit& csvSplit)
+{
+    m_Stats.RegisterFunctionCall(VMA_FUNCTION::SetPoolName);
+
+    if(!g_UserDataEnabled)
+    {
+        return;
+    }
+
+    if(ValidateFunctionParameterCount(lineNumber, csvSplit, 2, true))
+    {
+        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())
+                {
+                    std::string poolName;
+                    csvSplit.GetRange(FIRST_PARAM_INDEX + 1).to_str(poolName);
+                    vmaSetPoolName(m_Allocator, it->second.pool, !poolName.empty() ? poolName.c_str() : nullptr);
+                }
+                else
+                {
+                    if(IssueWarning())
+                    {
+                        printf("Line %zu: Pool %llX not found.\n", lineNumber, origPtr);
+                    }
+                }
+            }
+        }
+        else
+        {
+            if(IssueWarning())
+            {
+                printf("Line %zu: Invalid parameters for vmaSetPoolName.\n", lineNumber);
+            }
+        }
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Main functions
 

src/VmaReplay/VmaReplay.cpp

@@ -26,6 +26,7 @@
 #include "Tests.h"
 #include "VmaUsage.h"
 #include "Common.h"
+#include <atomic>
 
 static const char* const SHADER_PATH1 = "./";
 static const char* const SHADER_PATH2 = "../bin/";
@@ -37,7 +38,7 @@ static const wchar_t* const APP_TITLE_W = L"Vulkan Memory Allocator Sample 2.3.0
 static const bool VSYNC = true;
 static const uint32_t COMMAND_BUFFER_COUNT = 2;
 static void* const CUSTOM_CPU_ALLOCATION_CALLBACK_USER_DATA = (void*)(intptr_t)43564544;
-static const bool USE_CUSTOM_CPU_ALLOCATION_CALLBACKS = false;
+static const bool USE_CUSTOM_CPU_ALLOCATION_CALLBACKS = true;
 
 VkPhysicalDevice g_hPhysicalDevice;
 VkDevice g_hDevice;
@@ -111,26 +112,47 @@ static VkImage g_hTextureImage;
 static VmaAllocation g_hTextureImageAlloc;
 static VkImageView g_hTextureImageView;
 
+static std::atomic_uint32_t g_CpuAllocCount;
+
 static void* CustomCpuAllocation(
     void* pUserData, size_t size, size_t alignment,
     VkSystemAllocationScope allocationScope)
 {
     assert(pUserData == CUSTOM_CPU_ALLOCATION_CALLBACK_USER_DATA);
-    return _aligned_malloc(size, alignment);
+    void* const result = _aligned_malloc(size, alignment);
+    if(result)
+    {
+        ++g_CpuAllocCount;
+    }
+    return result;
 }
 
 static void* CustomCpuReallocation(
     void* pUserData, void* pOriginal, size_t size, size_t alignment,
     VkSystemAllocationScope allocationScope)
 {
     assert(pUserData == CUSTOM_CPU_ALLOCATION_CALLBACK_USER_DATA);
-    return _aligned_realloc(pOriginal, size, alignment);
+    void* const result = _aligned_realloc(pOriginal, size, alignment);
+    if(pOriginal && !result)
+    {
+        --g_CpuAllocCount;
+    }
+    else if(!pOriginal && result)
+    {
+        ++g_CpuAllocCount;
+    }
+    return result;
 }
 
 static void CustomCpuFree(void* pUserData, void* pMemory)
 {
     assert(pUserData == CUSTOM_CPU_ALLOCATION_CALLBACK_USER_DATA);
-    _aligned_free(pMemory);
+    if(pMemory)
+    {
+        const uint32_t oldAllocCount = g_CpuAllocCount.fetch_sub(1);
+        TEST(oldAllocCount > 0);
+        _aligned_free(pMemory);
+    }
 }
 
 static const VkAllocationCallbacks g_CpuAllocationCallbacks = {
@@ -1873,6 +1895,8 @@ int main()
             DrawFrame();
     }
 
+    TEST(g_CpuAllocCount.load() == 0);
+
     return 0;
 }