Further development of budget management

Author: adam-sawicki-a

src/Tests.cpp

@@ -3863,13 +3863,15 @@ static void TestBudget()
 
     uint32_t memTypeIndex = UINT32_MAX;
 
-    static const VkDeviceSize BUF_SIZE = 0x10000;
-    static const uint32_t BUF_COUNT = 32;
+    static const VkDeviceSize BUF_SIZE = 100ull * 1024 * 1024;
+    static const uint32_t BUF_COUNT = 4;
 
     for(uint32_t testIndex = 0; testIndex < 2; ++testIndex)
     {
-        VmaBudget budgetBeg = {};
-        vmaGetBudget(g_hAllocator, &budgetBeg);
+        vmaSetCurrentFrameIndex(g_hAllocator, ++g_FrameIndex);
+
+        VmaBudget budgetBeg[VK_MAX_MEMORY_HEAPS] = {};
+        vmaGetBudget(g_hAllocator, budgetBeg);
 
         VkBufferCreateInfo bufInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
         bufInfo.size = BUF_SIZE;
@@ -3902,36 +3904,85 @@ static void TestBudget()
             }
         }
 
-        VmaBudget budgetWithBufs = {};
-        vmaGetBudget(g_hAllocator, &budgetWithBufs);
+        VmaBudget budgetWithBufs[VK_MAX_MEMORY_HEAPS] = {};
+        vmaGetBudget(g_hAllocator, budgetWithBufs);
 
         // DESTROY BUFFERS
         for(size_t bufIndex = BUF_COUNT; bufIndex--; )
         {
             vmaDestroyBuffer(g_hAllocator, bufInfos[bufIndex].Buffer, bufInfos[bufIndex].Allocation);
         }
 
-        VmaBudget budgetEnd = {};
-        vmaGetBudget(g_hAllocator, &budgetEnd);
+        VmaBudget budgetEnd[VK_MAX_MEMORY_HEAPS] = {};
+        vmaGetBudget(g_hAllocator, budgetEnd);
 
         // CHECK
         for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
         {
-            TEST(budgetEnd.allocationBytes[i] <= budgetEnd.blockBytes[i]);
+            TEST(budgetEnd[i].allocationBytes <= budgetEnd[i].blockBytes);
             if(i == heapIndex)
             {
-                TEST(budgetEnd.allocationBytes[i] == budgetBeg.allocationBytes[i]);
-                TEST(budgetWithBufs.allocationBytes[i] == budgetBeg.allocationBytes[i] + BUF_SIZE * BUF_COUNT);
-                TEST(budgetWithBufs.blockBytes[i] >= budgetEnd.blockBytes[i]);
+                TEST(budgetEnd[i].allocationBytes == budgetBeg[i].allocationBytes);
+                TEST(budgetWithBufs[i].allocationBytes == budgetBeg[i].allocationBytes + BUF_SIZE * BUF_COUNT);
+                TEST(budgetWithBufs[i].blockBytes >= budgetEnd[i].blockBytes);
+            }
+            else
+            {
+                TEST(budgetEnd[i].allocationBytes == budgetEnd[i].allocationBytes &&
+                    budgetEnd[i].allocationBytes == budgetWithBufs[i].allocationBytes);
+                TEST(budgetEnd[i].blockBytes == budgetEnd[i].blockBytes &&
+                    budgetEnd[i].blockBytes == budgetWithBufs[i].blockBytes);
+            }
+        }
+    }
+
+    // DELME
+
+    {
+        std::vector<BufferInfo> buffers;
+
+        for(uint32_t i = 0; i < 160; ++i)
+        {
+            //vmaSetCurrentFrameIndex(g_hAllocator, ++g_FrameIndex);
+
+            VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+            bufCreateInfo.size = 50ull * 1024 * 1024;
+            bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+            VmaAllocationCreateInfo allocCreateInfo = {};
+            //allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
+            allocCreateInfo.memoryTypeBits = 1;
+            //allocCreateInfo.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT;
+
+            BufferInfo bufInfo = {};
+            VkResult res = vmaCreateBuffer(g_hAllocator, &bufCreateInfo, &allocCreateInfo, &bufInfo.Buffer, &bufInfo.Allocation, nullptr);
+            if(res == VK_SUCCESS)
+            {
+                buffers.push_back(std::move(bufInfo));
             }
             else
             {
-                TEST(budgetEnd.allocationBytes[i] == budgetEnd.allocationBytes[i] &&
-                    budgetEnd.allocationBytes[i] == budgetWithBufs.allocationBytes[i]);
-                TEST(budgetEnd.blockBytes[i] == budgetEnd.blockBytes[i] &&
-                    budgetEnd.blockBytes[i] == budgetWithBufs.blockBytes[i]);
+                break;
             }
         }
+
+        char* statsString;
+        vmaBuildStatsString(g_hAllocator, &statsString, VK_TRUE);
+        printf("%s\n", statsString);
+        vmaFreeStatsString(g_hAllocator, statsString);
+
+        VmaBudget budget1[VK_MAX_MEMORY_HEAPS];
+        vmaGetBudget(g_hAllocator, budget1);
+
+        vmaSetCurrentFrameIndex(g_hAllocator, ++g_FrameIndex);
+
+        VmaBudget budget2[VK_MAX_MEMORY_HEAPS];
+        vmaGetBudget(g_hAllocator, budget2);
+
+        for(size_t i = buffers.size(); i--; )
+        {
+            vmaDestroyBuffer(g_hAllocator, buffers[i].Buffer, buffers[i].Allocation);
+        }
     }
 }
 

src/VulkanSample.cpp

@@ -46,8 +46,10 @@ bool g_MemoryAliasingWarningEnabled = true;
 
 static bool g_EnableValidationLayer = true;
 static bool VK_KHR_get_memory_requirements2_enabled = false;
+static bool VK_KHR_get_physical_device_properties2_enabled = false;
 static bool VK_KHR_dedicated_allocation_enabled = false;
 static bool VK_KHR_bind_memory2_enabled = false;
+static bool VK_EXT_memory_budget_enabled = false;
 bool g_SparseBindingEnabled = false;
 
 static HINSTANCE g_hAppInstance;
@@ -1115,15 +1117,32 @@ static void InitializeApplication()
         }
     }
 
-    std::vector<const char*> instanceExtensions;
-    instanceExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
-    instanceExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+    uint32_t availableInstanceExtensionCount = 0;
+    ERR_GUARD_VULKAN( vkEnumerateInstanceExtensionProperties(nullptr, &availableInstanceExtensionCount, nullptr) );
+    std::vector<VkExtensionProperties> availableInstanceExtensions(availableInstanceExtensionCount);
+    if(availableInstanceExtensionCount > 0)
+    {
+        ERR_GUARD_VULKAN( vkEnumerateInstanceExtensionProperties(nullptr, &availableInstanceExtensionCount, availableInstanceExtensions.data()) );
+    }
+
+    std::vector<const char*> enabledInstanceExtensions;
+    enabledInstanceExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
+    enabledInstanceExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 
     std::vector<const char*> instanceLayers;
     if(g_EnableValidationLayer == true)
     {
         instanceLayers.push_back(VALIDATION_LAYER_NAME);
-        instanceExtensions.push_back("VK_EXT_debug_report");
+        enabledInstanceExtensions.push_back("VK_EXT_debug_report");
+    }
+
+    for(const auto& extensionProperties : availableInstanceExtensions)
+    {
+        if(strcmp(extensionProperties.extensionName, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) == 0)
+        {
+            enabledInstanceExtensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+            VK_KHR_get_physical_device_properties2_enabled = true;
+        }
     }
 
     VkApplicationInfo appInfo = { VK_STRUCTURE_TYPE_APPLICATION_INFO };
@@ -1135,8 +1154,8 @@ static void InitializeApplication()
 
     VkInstanceCreateInfo instInfo = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
     instInfo.pApplicationInfo = &appInfo;
-    instInfo.enabledExtensionCount = static_cast<uint32_t>(instanceExtensions.size());
-    instInfo.ppEnabledExtensionNames = instanceExtensions.data();
+    instInfo.enabledExtensionCount = static_cast<uint32_t>(enabledInstanceExtensions.size());
+    instInfo.ppEnabledExtensionNames = enabledInstanceExtensions.data();
     instInfo.enabledLayerCount = static_cast<uint32_t>(instanceLayers.size());
     instInfo.ppEnabledLayerNames = instanceLayers.data();
 
@@ -1282,6 +1301,11 @@ static void InitializeApplication()
                     enabledDeviceExtensions.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
                     VK_KHR_bind_memory2_enabled = true;
                 }
+                else if(strcmp(properties[i].extensionName, VK_EXT_MEMORY_BUDGET_EXTENSION_NAME) == 0)
+                {
+                    enabledDeviceExtensions.push_back(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME);
+                    VK_EXT_memory_budget_enabled = true;
+                }
             }
         }
     }
@@ -1302,6 +1326,7 @@ static void InitializeApplication()
     VmaAllocatorCreateInfo allocatorInfo = {};
     allocatorInfo.physicalDevice = g_hPhysicalDevice;
     allocatorInfo.device = g_hDevice;
+    allocatorInfo.instance = g_hVulkanInstance;
 
     if(VK_KHR_dedicated_allocation_enabled)
     {
@@ -1322,6 +1347,10 @@ static void InitializeApplication()
     {
         allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT;
     }
+    if(VK_EXT_memory_budget_enabled && VK_KHR_get_physical_device_properties2_enabled)
+    {
+        allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT;
+    }
 
     if(USE_CUSTOM_CPU_ALLOCATION_CALLBACKS)
     {
@@ -1341,7 +1370,7 @@ static void InitializeApplication()
     /*
     std::array<VkDeviceSize, VK_MAX_MEMORY_HEAPS> heapSizeLimit;
     std::fill(heapSizeLimit.begin(), heapSizeLimit.end(), VK_WHOLE_SIZE);
-    heapSizeLimit[0] = 100ull * 1024 * 1024;
+    heapSizeLimit[0] = 512ull * 1024 * 1024;
     allocatorInfo.pHeapSizeLimit = heapSizeLimit.data();
     */