Added ability to query available memory

Author: robertosfield

include/vsg/app/CompileManager.h

@@ -65,13 +65,19 @@ namespace vsg
 
         using ContextSelectionFunction = std::function<bool(vsg::Context&)>;
 
+        /// return the smallest available memory on the associated devices
+        VkDeviceSize availableMemory(ContextSelectionFunction contextSelection = {}) const;
+
         /// compile object
         CompileResult compile(ref_ptr<Object> object, ContextSelectionFunction contextSelection = {});
 
         /// compile all the command graphs in a task
         CompileResult compileTask(ref_ptr<RecordAndSubmitTask> task, const ResourceRequirements& resourceRequirements = {});
 
     protected:
+
+        std::list<ref_ptr<Context>> contexts;
+
         using CompileTraversals = ThreadSafeQueue<ref_ptr<CompileTraversal>>;
         size_t numCompileTraversals = 0;
         ref_ptr<CompileTraversals> compileTraversals;

include/vsg/vk/Device.h

@@ -84,6 +84,9 @@ namespace vsg
         /// return true if Device was created with specified extension
         bool supportsDeviceExtension(const char* extensionName) const;
 
+        /// return the amount of memory available in deviceMemoryBufferPools and allocatable on device
+        VkDeviceSize availableMemory() const;
+
         // provide observer_ptr to memory buffer and descriptor pools so that these can be accessed when required
         observer_ptr<MemoryBufferPools> deviceMemoryBufferPools;
         observer_ptr<MemoryBufferPools> stagingMemoryBufferPools;

src/vsg/app/CompileManager.cpp

@@ -82,6 +82,8 @@ CompileManager::CompileManager(Viewer& viewer, ref_ptr<ResourceHints> hints)
 #else
     numCompileTraversals = 1;
 #endif
+
+    contexts = ct->contexts;
 }
 
 CompileManager::CompileTraversals::container_type CompileManager::takeCompileTraversals(size_t count)
@@ -106,6 +108,8 @@ void CompileManager::add(ref_ptr<Device> device, const ResourceRequirements& res
     {
         ct->add(device, resourceRequirements);
 
+        contexts = ct->contexts;
+
         compileTraversals->add(ct);
     }
 }
@@ -117,6 +121,8 @@ void CompileManager::add(Window& window, ref_ptr<ViewportState> viewport, const
     {
         ct->add(window, viewport, resourceRequirements);
 
+        contexts = ct->contexts;
+
         compileTraversals->add(ct);
     }
 }
@@ -128,6 +134,8 @@ void CompileManager::add(Window& window, ref_ptr<View> view, const ResourceRequi
     {
         ct->add(window, view, resourceRequirements);
 
+        contexts = ct->contexts;
+
         compileTraversals->add(ct);
     }
 }
@@ -139,6 +147,8 @@ void CompileManager::add(Framebuffer& framebuffer, ref_ptr<View> view, const Res
     {
         ct->add(framebuffer, view, resourceRequirements);
 
+        contexts = ct->contexts;
+
         compileTraversals->add(ct);
     }
 }
@@ -150,6 +160,8 @@ void CompileManager::add(const Viewer& viewer, const ResourceRequirements& resou
     {
         ct->add(viewer, resourceRequirements);
 
+        contexts = ct->contexts;
+
         compileTraversals->add(ct);
     }
 }
@@ -165,6 +177,30 @@ void CompileManager::assignInstrumentation(ref_ptr<Instrumentation> in_instrumen
     }
 }
 
+VkDeviceSize CompileManager::availableMemory(ContextSelectionFunction contextSelection) const
+{
+    VkDeviceSize minAvailable = std::numeric_limits<VkDeviceSize>::max();
+
+    if (contextSelection)
+    {
+        for (auto& context : contexts)
+        {
+            if (contextSelection(*context)) minAvailable = std::min(minAvailable, context->device->availableMemory());
+        }
+    }
+    else
+    {
+        for (auto& context : contexts)
+        {
+            minAvailable = std::min(minAvailable, context->device->availableMemory());
+        }
+    }
+
+    vsg::info("CompileManager::availableMemory() = ", minAvailable);
+
+    return minAvailable;
+}
+
 CompileResult CompileManager::compile(ref_ptr<Object> object, ContextSelectionFunction contextSelection)
 {
     vsg::debug("CompileManager::compile(", object, ", ..)");
@@ -241,18 +277,18 @@ CompileResult CompileManager::compile(ref_ptr<Object> object, ContextSelectionFu
 
     if (contextSelection)
     {
-        std::list<ref_ptr<Context>> contexts;
+        std::list<ref_ptr<Context>> activeContexts;
 
         for (auto& context : compileTraversal->contexts)
         {
-            if (contextSelection(*context)) contexts.push_back(context);
+            if (contextSelection(*context)) activeContexts.push_back(context);
         }
 
-        compileTraversal->contexts.swap(contexts);
+        compileTraversal->contexts.swap(activeContexts);
 
         run_compile_traversal();
 
-        compileTraversal->contexts.swap(contexts);
+        compileTraversal->contexts.swap(activeContexts);
     }
     else
     {

src/vsg/vk/Device.cpp

@@ -205,3 +205,25 @@ bool Device::supportsDeviceExtension(const char* extensionName) const
     auto compare = [&](const char* rhs) { return strcmp(extensionName, rhs) == 0; };
     return (std::find_if(enabledExtensions.begin(), enabledExtensions.end(), compare) != enabledExtensions.end());
 }
+
+VkDeviceSize Device::availableMemory() const
+{
+    VkDeviceSize available = 0;
+#if 0
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT memoryBudget;
+    memoryBudget.sType =  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
+    memoryBudget.pNext = nullptr;
+
+    VkPhysicalDeviceMemoryProperties2 memoryProperties;
+    memoryProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+    memoryProperties.pNext = &memoryBudget;
+
+    vkGetPhysicalDeviceMemoryProperties2(*(device->getPhysicalDevice()), &memoryProperties);
+#endif
+    if (auto pool = deviceMemoryBufferPools.ref_ptr())
+    {
+        available += pool->computeMemoryTotalAvailable();
+    }
+
+    return available;
+}