update example latest

Author: keptsecret

examples_tests

@@ -24,7 +24,6 @@ class ISPIRVOptimizer final : public core::IReferenceCounted
             EOP_SIMPLIFICATION,
             EOP_VECTOR_DCE,
             EOP_DEAD_INSERT_ELIM,
-            EOP_AGGRESSIVE_DCE,
             EOP_DEAD_BRANCH_ELIM,
             EOP_BLOCK_MERGE,
             EOP_LOCAL_MULTI_STORE_ELIM,
@@ -34,11 +33,13 @@ class ISPIRVOptimizer final : public core::IReferenceCounted
             EOP_REDUCE_LOAD_SIZE,
             EOP_STRENGTH_REDUCTION,
             EOP_IF_CONVERSION,
+            EOP_STRIP_DEBUG_INFO,
+            EOP_AGGRESSIVE_DCE,
 
             EOP_COUNT
         };
 
-        ISPIRVOptimizer(std::initializer_list<E_OPTIMIZER_PASS> _passes) : m_passes(std::move(_passes)) {}
+        ISPIRVOptimizer(std::span<const E_OPTIMIZER_PASS> _passes) : m_passes(_passes.begin(), _passes.end()) {}
 
         core::smart_refctd_ptr<ICPUBuffer> optimize(const uint32_t* _spirv, uint32_t _dwordCount, system::logger_opt_ptr logger) const;
         core::smart_refctd_ptr<ICPUBuffer> optimize(const ICPUBuffer* _spirv, system::logger_opt_ptr logger) const;
@@ -50,4 +51,4 @@ class ISPIRVOptimizer final : public core::IReferenceCounted
 
 }
 
-#endif
+#endif

include/nbl/asset/utils/ISPIRVOptimizer.h

@@ -33,7 +33,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 				{
 					system::path absolutePath = {};
 					std::string contents = {};
-					std::array<uint64_t, 4> hash = {}; // TODO: we're not yet using IFile::getPrecomputedHash(), so for builtins we can maybe use that in the future
+					core::blake3_hash_t hash = {}; // TODO: we're not yet using IFile::getPrecomputedHash(), so for builtins we can maybe use that in the future
 					// Could be used in the future for early rejection of cache hit
 					//nbl::system::IFileBase::time_point_t lastWriteTime = {};
 
@@ -183,9 +183,8 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 
 			public:
 				// Used to check compatibility of Caches before reading
-				constexpr static inline std::string_view VERSION = "1.0.0";
+				constexpr static inline std::string_view VERSION = "1.1.0";
 
-				using hash_t = std::array<uint64_t,4>;
 				static auto const SHADER_BUFFER_SIZE_BYTES = sizeof(uint64_t) / sizeof(uint8_t); // It's obviously 8
 
 				struct SEntry
@@ -196,11 +195,9 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 					{
 						public:
 							// Perf note: hashing while preprocessor lexing is likely to be slower than just hashing the whole array like this 
-							inline SPreprocessingDependency(const system::path& _requestingSourceDir, const std::string_view& _identifier, const std::string_view& _contents, bool _standardInclude, std::array<uint64_t, 4> _hash) :
-								requestingSourceDir(_requestingSourceDir), identifier(_identifier), contents(_contents), standardInclude(_standardInclude), hash(_hash)
-							{
-								assert(!_contents.empty());
-							}
+							inline SPreprocessingDependency(const system::path& _requestingSourceDir, const std::string_view& _identifier, bool _standardInclude, core::blake3_hash_t _hash) :
+								requestingSourceDir(_requestingSourceDir), identifier(_identifier), standardInclude(_standardInclude), hash(_hash)
+							{}
 
 							inline SPreprocessingDependency(SPreprocessingDependency&) = default;
 							inline SPreprocessingDependency& operator=(SPreprocessingDependency&) = delete;
@@ -218,11 +215,8 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 							// path or identifier
 							system::path requestingSourceDir = "";
 							std::string identifier = "";
-							// file contents
-							// TODO: change to `core::vector<uint8_t>` a compressed blob of LZMA, and store all contents together in the `SEntry`
-							std::string contents = ""; 
 							// hash of the contents - used to check against a found_t
-							std::array<uint64_t, 4> hash = {};
+							core::blake3_hash_t hash = {};
 							// If true, then `getIncludeStandard` was used to find, otherwise `getIncludeRelative`
 							bool standardInclude = false;
 					};
@@ -248,6 +242,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 						private:
 							friend class SCompilerArgs;
 							friend class SEntry;
+							friend class CCache;
 							friend void to_json(nlohmann::json&, const SPreprocessorArgs&);
 							friend void from_json(const nlohmann::json&, SPreprocessorArgs&);
 
@@ -271,7 +266,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 							std::string sourceIdentifier;
 							std::vector<SMacroDefinition> extraDefines;
 					};
-					// TODO: SPreprocessorArgs could just be folded into `SCompilerArgs` to have less classes and operators
+					// TODO: SPreprocessorArgs could just be folded into `SCompilerArgs` to have less classes and decompressShader
 					struct SCompilerArgs final
 					{
 						public:
@@ -290,6 +285,7 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 
 						private:
 							friend class SEntry;
+							friend class CCache;
 							friend void to_json(nlohmann::json&, const SCompilerArgs&);
 							friend void from_json(const nlohmann::json&, SCompilerArgs&);
 
@@ -351,33 +347,40 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 
 						// Now add the mainFileContents and produce both lookup and early equality rejection hashes
 						hashable.insert(hashable.end(), mainFileContents.begin(), mainFileContents.end());
-						hash = nbl::core::XXHash_256(hashable.data(), hashable.size());
-						lookupHash = hash[0];
-						for (auto i = 1u; i < 4; i++) {
-							core::hash_combine<uint64_t>(lookupHash, hash[i]);
-						}
+
+						core::blake3_hasher hasher;
+						hasher.update(hashable.data(), hashable.size());
+						hash = static_cast<core::blake3_hash_t>(hasher);
+						lookupHash = std::hash<core::blake3_hash_t>{}(hash);
 					}
 
 					// Needed to get the vector deserialization automatically
 					inline SEntry() {}
 
 					// Making the copy constructor deep-copy everything but the shader 
-					inline SEntry(const SEntry& other) 
-						: mainFileContents(other.mainFileContents), compilerArgs(other.compilerArgs), hash(other.hash), lookupHash(other.lookupHash), 
-						  dependencies(other.dependencies), cpuShader(other.cpuShader) {}
+					inline SEntry(const SEntry& other)
+						: mainFileContents(other.mainFileContents), compilerArgs(other.compilerArgs), hash(other.hash),
+						lookupHash(other.lookupHash), dependencies(other.dependencies), spirv(other.spirv),
+						uncompressedContentHash(other.uncompressedContentHash), uncompressedSize(other.uncompressedSize) {}
 
 					inline SEntry& operator=(SEntry& other) = delete;
 					inline SEntry(SEntry&& other) = default;
 					// Used for late initialization while looking up a cache, so as not to always initialize an entry even if caching was not requested
 					inline SEntry& operator=(SEntry&& other) = default;
 
+					bool setContent(const asset::ICPUBuffer* uncompressedSpirvBuffer, dependency_container_t&& dependencies);
+
+					core::smart_refctd_ptr<ICPUShader> decompressShader() const;
+
 					// TODO: make some of these private
 					std::string mainFileContents;
 					SCompilerArgs compilerArgs;
-					std::array<uint64_t,4> hash;
+					core::blake3_hash_t hash;
 					size_t lookupHash;
 					dependency_container_t dependencies;
-					core::smart_refctd_ptr<asset::ICPUShader> cpuShader;
+					core::smart_refctd_ptr<asset::ICPUBuffer> spirv;
+					core::blake3_hash_t uncompressedContentHash;
+					size_t uncompressedSize;
 				};
 
 				inline void insert(SEntry&& entry)
@@ -429,52 +432,13 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 
 				};
 
-				using EntrySet = core::unordered_multiset<SEntry, Hash, KeyEqual>;
+				using EntrySet = core::unordered_set<SEntry, Hash, KeyEqual>;
 				EntrySet m_container;
 
 				NBL_API2 EntrySet::const_iterator find_impl(const SEntry& mainFile, const CIncludeFinder* finder) const;
 		};
 
-		inline core::smart_refctd_ptr<ICPUShader> compileToSPIRV(const std::string_view code, const SCompilerOptions& options) const
-		{
-			CCache::SEntry entry;
-			std::vector<CCache::SEntry::SPreprocessingDependency> dependencies;
-			if (options.readCache || options.writeCache)
-				entry = std::move(CCache::SEntry(code, options));
-			
-			if (options.readCache)
-			{
-				auto found = options.readCache->find_impl(entry, options.preprocessorOptions.includeFinder);
-				if (found != options.readCache->m_container.end())
-				{
-					if (options.writeCache)
-					{
-						CCache::SEntry writeEntry = *found;
-						options.writeCache->insert(std::move(writeEntry));
-					}
-					return found->cpuShader;
-				}
-			}
-
-			auto retVal = compileToSPIRV_impl(code, options, options.writeCache ? &dependencies : nullptr);
-
-			if (!retVal)
-				return nullptr;
-
-			// compute the SPIR-V shader content hash
-			{
-				auto backingBuffer = retVal->getContent();
-				const_cast<ICPUBuffer*>(backingBuffer)->setContentHash(backingBuffer->computeContentHash());
-			}
-
-			if (options.writeCache)
-			{
-				entry.dependencies = std::move(dependencies);
-				entry.cpuShader = retVal;
-				options.writeCache->insert(std::move(entry));
-			}
-			return retVal;
-		}
+		core::smart_refctd_ptr<ICPUShader> compileToSPIRV(const std::string_view code, const SCompilerOptions& options) const;
 
 		inline core::smart_refctd_ptr<ICPUShader> compileToSPIRV(const char* code, const SCompilerOptions& options) const
 		{

include/nbl/asset/utils/IShaderCompiler.h

@@ -20,8 +20,14 @@ class CVulkanSwapchain final : public ISwapchain
 
         void setObjectDebugName(const char* label) const override;
 
-        inline const void* getNativeHandle() const {return &m_vkSwapchainKHR;}
+        inline const void* getNativeHandle() const override {return &m_vkSwapchainKHR;}
         inline VkSwapchainKHR getInternalObject() const {return m_vkSwapchainKHR;}
+        
+        // returns the maximum number of time acquire can be called without releasing the image index through present.
+        inline uint8_t getMaxBlockingAcquiresBeforePresent() const override { return m_maxBlockingAcquiresBeforePresent; }
+        
+        // returns the maximum number of acquires you can request without waiting for previous acquire semaphores to signal.
+        uint8_t getMaxAcquiresInFlight() const override { return getImageCount(); }
 
     private:
         CVulkanSwapchain(
@@ -32,7 +38,8 @@ class CVulkanSwapchain final : public ISwapchain
             const VkSwapchainKHR swapchain,
             const VkSemaphore* const _acquireAdaptorSemaphores,
             const VkSemaphore* const _prePresentSemaphores,
-            const VkSemaphore* const _presentAdaptorSemaphores
+            const VkSemaphore* const _presentAdaptorSemaphores,
+            const uint8_t maxAcquiresBeforePresent
         );
         ~CVulkanSwapchain();
 
@@ -51,6 +58,7 @@ class CVulkanSwapchain final : public ISwapchain
         uint64_t m_perImageAcquireCount[ISwapchain::MaxImages] = { 0 };
         // nasty way to fight UB of the Vulkan spec
         bool m_needToWaitIdle = true;
+        uint8_t m_maxBlockingAcquiresBeforePresent = 0u;
 };
 
 }

include/nbl/video/CVulkanSwapchain.h

@@ -464,15 +464,21 @@ class ISwapchain : public IBackendObject
         // Vulkan: const VkSwapchainKHR*
         virtual const void* getNativeHandle() const = 0;
 
-		// only public because MultiTimelineEventHandlerST needs to know about it
-		class DeferredFrameSemaphoreDrop final
-		{
+        // returns the maximum number of time acquires with infinite timeout which can be called before releasing the image index through present.
+        virtual uint8_t getMaxBlockingAcquiresBeforePresent() const = 0u;
+
+        // returns the maximum number of acquires you can request without waiting for previous acquire semaphores to signal.
+        virtual uint8_t getMaxAcquiresInFlight() const = 0u;
+
+        // only public because MultiTimelineEventHandlerST needs to know about it
+        class DeferredFrameSemaphoreDrop final
+        {
                 using sema_refctd_ptr = core::smart_refctd_ptr<ISemaphore>;
-				core::smart_refctd_dynamic_array<sema_refctd_ptr> m_otherSemaphores = nullptr;
+                core::smart_refctd_dynamic_array<sema_refctd_ptr> m_otherSemaphores = nullptr;
 
-			public:
-				inline DeferredFrameSemaphoreDrop(const std::span<const IQueue::SSubmitInfo::SSemaphoreInfo> _semaphores)
-				{
+            public:
+                inline DeferredFrameSemaphoreDrop(const std::span<const IQueue::SSubmitInfo::SSemaphoreInfo> _semaphores)
+                {
                     const auto otherCount = _semaphores.size()-1;
                     // first semaphore always serves as the timeline and will be refcounted in the event handler
                     if (otherCount==0)
@@ -481,34 +487,34 @@ class ISwapchain : public IBackendObject
 
                     for (auto i=0ull; i<otherCount; i++)
                         m_otherSemaphores->operator[](i) = sema_refctd_ptr(_semaphores[i].semaphore);
-				}
+                }
                 DeferredFrameSemaphoreDrop(const DeferredFrameSemaphoreDrop& other) = delete;
-				inline DeferredFrameSemaphoreDrop(DeferredFrameSemaphoreDrop&& other) : m_otherSemaphores(nullptr)
-				{
-					this->operator=(std::move(other));
-				}
+                inline DeferredFrameSemaphoreDrop(DeferredFrameSemaphoreDrop&& other) : m_otherSemaphores(nullptr)
+                {
+                    this->operator=(std::move(other));
+                }
 
                 DeferredFrameSemaphoreDrop& operator=(const DeferredFrameSemaphoreDrop& other) = delete;
-				inline DeferredFrameSemaphoreDrop& operator=(DeferredFrameSemaphoreDrop&& other)
-				{
+                inline DeferredFrameSemaphoreDrop& operator=(DeferredFrameSemaphoreDrop&& other)
+                {
                     m_otherSemaphores = std::move(other.m_otherSemaphores);
-					other.m_otherSemaphores = nullptr;
-					return *this;
-				}
-
-				struct single_poll_t {};
-				static inline single_poll_t single_poll;
-				inline bool operator()(single_poll_t _single_poll)
-				{
-					operator()();
-					return true;
-				}
+                    other.m_otherSemaphores = nullptr;
+                    return *this;
+                }
+
+                struct single_poll_t {};
+                static inline single_poll_t single_poll;
+                inline bool operator()(single_poll_t _single_poll)
+                {
+                    operator()();
+                    return true;
+                }
 
                 inline void operator()()
                 {
                     m_otherSemaphores = nullptr;
                 }
-		};
+        };
 
     protected:
         ISwapchain(core::smart_refctd_ptr<const ILogicalDevice>&& dev, SCreationParams&& params, const uint8_t imageCount, core::smart_refctd_ptr<ISwapchain>&& oldSwapchain);