Merge remote-tracking branch 'upstream/master' into new-ref_ptr

Author: AnyOldName3

.github/workflows/ci.yml

@@ -9,19 +9,21 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        vulkan-version: [1.3.268.0]
+        # os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest]
+        vulkan-version: [1.4.341.1]
         build-shared: [OFF]
-        include:
-          - build-shared: ON
-            os: windows-latest
-            vulkan-version: 1.3.268.0
+        # include:
+        #   - build-shared: ON
+        #     os: windows-latest
+        #     vulkan-version: 1.4.341.1
+
     continue-on-error: ${{ matrix.vulkan-version == 'latest' }}
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Setup cmake
-      uses: jwlawson/actions-setup-cmake@v1.12
+      uses: jwlawson/actions-setup-cmake@v2.2.0
       with:
         cmake-version: ${{ env.CMakeVersion }}
     - name: Install Vulkan SDK
@@ -30,7 +32,7 @@ jobs:
         version: ${{ matrix.vulkan-version }}
         cache: true
     - name: Add MSBuild to PATH
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v3
       if: startsWith(matrix.os, 'windows')
     - name: Build and Install VSG
       shell: bash

include/vsg/app/CompileManager.h

@@ -39,6 +39,18 @@ namespace vsg
         bool requiresViewerUpdate() const;
     };
 
+    /// ResourceScavenger provides a mechanism for releasing and reusing unused resources when allocation of required GPU memory fails.
+    class VSG_DECLSPEC ResourceScavenger : public Inherit<Object, ResourceScavenger>
+    {
+    public:
+        explicit ResourceScavenger(ref_ptr<DatabasePager> in_databasePager);
+
+        virtual bool scavenge(ResourceRequirements& resourceRequirements);
+
+        uint64_t sleepDuration = 16 * 5; /// milliseconds sleep to make after adjusting load targets to allow other threads to free up space, default to 5 frames at 60fps
+        observer_ptr<DatabasePager> databasePager;
+    };
+
     /// CompileManager is a helper class that compiles subgraphs for the windows/framebuffers associated with the CompileManager.
     class VSG_DECLSPEC CompileManager : public Inherit<Object, CompileManager>
     {
@@ -71,7 +83,15 @@ namespace vsg
         /// compile all the command graphs in a task
         CompileResult compileTask(ref_ptr<RecordAndSubmitTask> task, const ResourceRequirements& resourceRequirements = {});
 
+        /// mechanism for releasing and reusing used resources
+        ref_ptr<ResourceScavenger> resourceScavenger;
+
+        std::atomic_uint successfulCompileCount{0};
+        std::atomic_uint failedCompileCount{0};
+
     protected:
+        ~CompileManager();
+
         using CompileTraversals = ThreadSafeQueue<ref_ptr<CompileTraversal>>;
         size_t numCompileTraversals = 0;
         ref_ptr<CompileTraversals> compileTraversals;

include/vsg/core/Exception.h

@@ -12,14 +12,16 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 </editor-fold> */
 
+#include <vsg/core/Export.h>
+
 #include <string>
 
 namespace vsg
 {
 
     /// Exception object that can be thrown from VSG code, such as failed Vulkan calls where the result value will be the VkResult value
     /// returned from failed Vulkan call.
-    struct Exception
+    struct VSG_DECLSPEC Exception
     {
         std::string message;
         int result = 0;

include/vsg/core/MemorySlots.h

@@ -31,6 +31,9 @@ namespace vsg
         MEMORY_TRACKING_DEFAULT = MEMORY_TRACKING_NO_CHECKS
     };
 
+    // forward declare
+    struct LogOutput;
+
     /** class used internally by vsg::Allocator, vsg::DeviceMemory and vsg::Buffer to manage suballocation within a block of CPU or GPU memory.*/
     class VSG_DECLSPEC MemorySlots
     {
@@ -52,7 +55,8 @@ namespace vsg
         size_t totalMemorySize() const { return _totalMemorySize; }
 
         // debug facilities
-        void report(std::ostream& out) const;
+        void report(LogOutput& log) const;
+
         bool check() const;
 
         mutable int memoryTracking = MEMORY_TRACKING_DEFAULT;

include/vsg/core/observer_ptr.h

@@ -223,6 +223,9 @@ namespace vsg
             }
         }
 
+        /// We strongly recommend access via ref_ptr<> rather than get(). Only use get() to get access to the raw C pointer when it's know that the object pointed to will remain in memory through use of that raw C pointer.
+        T* get() const noexcept { return _ptr; }
+
     protected:
         template<class R>
         friend class observer_ptr;

include/vsg/core/type_name.h

@@ -49,7 +49,7 @@ namespace vsg
         template<> constexpr const char* vsg::type_name<T>() noexcept { return #T; } \
         template<> constexpr const char* vsg::type_name<const T>() noexcept { return "const "#T; }
 
-    /// convinience function for adding a space in front of the type_name string.
+    /// convenience function for adding a space in front of the type_name string.
     template<typename T>
     std::string space_type_name(const T&) { return std::string(" ") + type_name<T>(); }
 

include/vsg/io/DatabasePager.h

@@ -104,7 +104,10 @@ namespace vsg
 
         void add(ref_ptr<PagedLOD> plod, const CompileResult& cr);
 
-        ref_ptr<PagedLOD> take_when_available();
+        /// prune entries older than specified frameCount
+        uint32_t prune(uint64_t frameCount);
+
+        ref_ptr<PagedLOD> take_when_available(uint64_t frameCount);
 
         Nodes take_all(CompileResult& result);
 
@@ -138,13 +141,16 @@ namespace vsg
         ref_ptr<CompileManager> compileManager;
 
         std::atomic_uint numActiveRequests{0};
-        std::atomic_uint64_t frameCount;
+        std::atomic_uint64_t frameCount{0};
 
         ref_ptr<CulledPagedLODs> culledPagedLODs;
 
         /// for systems with smaller GPU memory limits you may need to reduce the targetMaxNumPagedLODWithHighResSubgraphs to keep memory usage within available limits.
         uint32_t targetMaxNumPagedLODWithHighResSubgraphs = 1500;
 
+        /// number of frames before a PagedLOD with a failed load/compile is attempted to be loaded/compiled again.
+        uint64_t delayBeforeNextLoadAttempt = 60;
+
         std::mutex pendingPagedLODMutex;
 
         ref_ptr<PagedLODContainer> pagedLODContainer;
@@ -158,16 +164,16 @@ namespace vsg
         /// read and delete threads created by start()
         std::list<std::thread> threads;
 
+        ref_ptr<ActivityStatus> status;
+        ref_ptr<DeleteQueue> deleteQueue;
+
     protected:
         virtual ~DatabasePager();
 
         void requestDiscarded(PagedLOD* plod);
 
-        ref_ptr<ActivityStatus> _status;
-
         ref_ptr<DatabaseQueue> _requestQueue;
         ref_ptr<DatabaseQueue> _toMergeQueue;
-        ref_ptr<DeleteQueue> _deleteQueue;
     };
     VSG_type_name(vsg::DatabasePager);
 

include/vsg/io/stream.h

@@ -29,6 +29,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #include <istream>
 #include <ostream>
+#include <set>
 #include <sstream>
 
 namespace vsg
@@ -333,4 +334,29 @@ namespace vsg
         return output;
     }
 
+    template<typename T>
+    std::ostream& operator<<(std::ostream& output, const std::set<T>& values)
+    {
+        if (values.empty())
+            output << "{}";
+        else
+        {
+            output << "{ ";
+
+            bool first = true;
+            for (const auto& v : values)
+            {
+                if (!first)
+                    output << ", ";
+                else
+                    first = false;
+
+                output << v;
+            }
+
+            output << " }";
+        }
+        return output;
+    }
+
 } // namespace vsg

include/vsg/nodes/InstanceNode.h

@@ -21,10 +21,10 @@ namespace vsg
 {
 
     /// InstanceNode provides a mechanism for specifying the translations, rotations and scales (transform arrays) of subgraph
-    /// that contains InstanceDraw leaf node(s) that utlize the InstanceNode's per instance transform arrays combined with the
+    /// that contains InstanceDraw leaf node(s) that utilize the InstanceNode's per instance transform arrays combined with the
     /// InstanceDraw nodes per vertex arrays.
     ///
-    /// InstanceNode only work correctly when the child subgraphs that obey these contraints:
+    /// InstanceNode only work correctly when the child subgraphs that obey these constraints:
     /// 1. Do not contain any Transform nodes
     /// 2. Do not contain any Culling nodes
     /// 3. Do not contain any InstanceNode nodes

include/vsg/nodes/PagedLOD.h

@@ -89,6 +89,9 @@ namespace vsg
         mutable std::atomic_uint64_t frameHighResLastUsed{0};
         mutable std::atomic_uint requestCount{0};
 
+        mutable std::atomic_uint64_t frameNextLoadAttempt{0};
+        mutable std::atomic_uint64_t loadAttempts{0};
+
         enum RequestStatus : unsigned int
         {
             NoRequest = 0,