Merge branch 'master' into pipeline-exec-info

Author: karimsayedre

include/nbl/system/ILogger.h

@@ -61,20 +61,15 @@ class ILogger : public core::IReferenceCounted
 			using namespace std::chrono;
 			auto currentTime = std::chrono::system_clock::now();
 			const std::time_t t = std::chrono::system_clock::to_time_t(currentTime);
-			
-			// Since there is no real way in c++ to get current time with microseconds, this is my weird approach
-			auto time_since_epoch = duration_cast<microseconds>(system_clock::now().time_since_epoch());
-			auto time_since_epoch_s = duration_cast<seconds>(system_clock::now().time_since_epoch());
-			time_since_epoch -= duration_cast<microseconds>(time_since_epoch_s);
-
-			// This while is for the microseconds which are less that 6 digits long to be aligned with the others
-			while (time_since_epoch.count() / 100000 == 0) time_since_epoch *= 10;
 
 			auto time = std::localtime(&t);
 
+			// since there's no microseconds in `time`
+			const auto us_fraction = duration_cast<microseconds>(currentTime.time_since_epoch()) - duration_cast<microseconds>(duration_cast<seconds>(currentTime.time_since_epoch()));
+
 			constexpr size_t DATE_STR_LENGTH = 28;
 			std::string timeStr(DATE_STR_LENGTH, '\0');
-			sprintf(timeStr.data(), "[%02d.%02d.%d %02d:%02d:%02d:%d]", time->tm_mday, time->tm_mon + 1, 1900 + time->tm_year, time->tm_hour, time->tm_min, time->tm_sec, (int)time_since_epoch.count());
+			sprintf(timeStr.data(), "[%02d.%02d.%d %02d:%02d:%02d:%06d]", time->tm_mday, time->tm_mon + 1, 1900 + time->tm_year, time->tm_hour, time->tm_min, time->tm_sec, (int)us_fraction.count());
 
 			std::string messageTypeStr;
 			switch (logLevel)

include/nbl/video/IGPUAccelerationStructure.h

@@ -289,8 +289,9 @@ class IGPUBottomLevelAccelerationStructure : public asset::IBottomLevelAccelerat
 					totalPrims += buildRangeInfo.primitiveCount;
 					return true;
 				}
-
-				inline core::smart_refctd_ptr<const IReferenceCounted>* fillTracking(core::smart_refctd_ptr<const IReferenceCounted>* oit) const
+				
+				template<typename ForwardIterator> // TODO: requires
+				inline ForwardIterator fillTracking(ForwardIterator oit) const
 				{
 					*(oit++) = core::smart_refctd_ptr<const IReferenceCounted>(Base::scratch.buffer);
 					if (Base::isUpdate)
@@ -486,7 +487,8 @@ class IGPUTopLevelAccelerationStructure : public asset::ITopLevelAccelerationStr
 					return retval;
 				}
 
-				inline core::smart_refctd_ptr<const IReferenceCounted>* fillTracking(core::smart_refctd_ptr<const IReferenceCounted>* oit) const
+				template<typename ForwardIterator> // TODO: requires
+				inline ForwardIterator fillTracking(ForwardIterator oit) const
 				{
 					*(oit++) = core::smart_refctd_ptr<const IReferenceCounted>(Base::scratch.buffer);
 					if (Base::isUpdate)
@@ -713,8 +715,8 @@ class IGPUTopLevelAccelerationStructure : public asset::ITopLevelAccelerationStr
 				*(tracked++) = *(it++);
 		}
 		// Useful if TLAS got built externally as well
-		template<typename Iterator>
-		inline void insertTrackedBLASes(const Iterator begin, const Iterator end, const build_ver_t buildVer)
+		template<typename ForwardIterator>
+		inline void insertTrackedBLASes(ForwardIterator begin, const uint32_t count, const build_ver_t buildVer)
 		{
 			if (buildVer==0)
 				return;
@@ -725,14 +727,19 @@ class IGPUTopLevelAccelerationStructure : public asset::ITopLevelAccelerationStr
 			for (auto it=std::next(prev); it!=m_pendingBuilds.end()&&it->ordinal>buildVer; prev=it++) {}
 			auto inserted = m_pendingBuilds.emplace_after(prev);
 			// now fill the contents
-			inserted->BLASes.insert(begin,end);
+			inserted->BLASes.reserve(count);
+			for (auto i=0u; i<count; i++)
+			{
+				inserted->BLASes.insert(*begin);
+				++begin;
+			}
 			inserted->ordinal = buildVer;
 		}
-		template<typename Iterator>
-		inline build_ver_t pushTrackedBLASes(const Iterator begin, const Iterator end)
+		template<typename ForwardIterator>
+		inline build_ver_t pushTrackedBLASes(const ForwardIterator begin, const uint32_t count)
 		{
 			const auto buildVer = registerNextBuildVer();
-			insertTrackedBLASes<Iterator>(begin,end,buildVer);
+			insertTrackedBLASes<ForwardIterator>(begin,count,buildVer);
 			return buildVer;
 		}
 		// a little utility to make sure nothing from before this build version gets tracked
@@ -750,18 +757,9 @@ class IGPUTopLevelAccelerationStructure : public asset::ITopLevelAccelerationStr
 		const uint32_t m_maxInstanceCount;
 
 	private:
-		struct DynamicUpCastingSpanIterator
-		{
-			inline bool operator!=(const DynamicUpCastingSpanIterator& other) const {return ptr!=other.ptr;}
-
-			inline DynamicUpCastingSpanIterator operator++() {return {ptr++};}
-
-			inline const IGPUBottomLevelAccelerationStructure* operator*() const {return dynamic_cast<const IGPUBottomLevelAccelerationStructure*>(ptr->get());}
-
-			std::span<const core::smart_refctd_ptr<const core::IReferenceCounted>>::iterator ptr;
-		};
 		friend class ILogicalDevice;
 		friend class IQueue;
+
 		inline const core::unordered_set<blas_smart_ptr_t>* getPendingBuildTrackedBLASes(const build_ver_t buildVer) const
 		{
 			const auto found = std::find_if(m_pendingBuilds.begin(),m_pendingBuilds.end(),[buildVer](const auto& item)->bool{return item.ordinal==buildVer;});

include/nbl/video/IGPUCommandBuffer.h

@@ -552,9 +552,12 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
         {
             auto oit = reserveReferences(std::distance(begin,end));
             if (oit)
-            while (begin!=end)
-                *(oit++) = core::smart_refctd_ptr<const core::IReferenceCounted>(*(begin++));
-            return oit;
+            {
+                while (begin!=end)
+                    *(oit++) = core::smart_refctd_ptr<const core::IReferenceCounted>(*(begin++));
+                return true;
+            }
+            return false;
         }
         inline bool recordReferences(const std::span<const IReferenceCounted*> refs) {return recordReferences(refs.begin(),refs.end());}
 
@@ -569,8 +572,9 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
                 m_TLASTrackingOps.emplace_back(TLASTrackingWrite{.src={oit,size},.dst=tlas});
                 while (beginBLASes!=endBLASes)
                     *(oit++) = core::smart_refctd_ptr<const core::IReferenceCounted>(*(beginBLASes++));
+                return true;
             }
-            return oit;
+            return false;
         }
 
         virtual bool insertDebugMarker(const char* name, const core::vector4df_SIMD& color = core::vector4df_SIMD(1.0, 1.0, 1.0, 1.0)) = 0;
@@ -885,7 +889,7 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
         template<typename IndirectCommand> requires nbl::is_any_of_v<IndirectCommand, hlsl::DrawArraysIndirectCommand_t, hlsl::DrawElementsIndirectCommand_t>
         bool invalidDrawIndirectCount(const asset::SBufferBinding<const IGPUBuffer>& indirectBinding, const asset::SBufferBinding<const IGPUBuffer>& countBinding, const uint32_t maxDrawCount, const uint32_t stride);
 
-        core::smart_refctd_ptr<const core::IReferenceCounted>* reserveReferences(const uint32_t size);
+        IGPUCommandPool::CTrackedIterator reserveReferences(const uint32_t size);
 
         // This bound descriptor set record doesn't include the descriptor sets whose layout has _any_ one of its bindings
         // created with IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_UPDATE_AFTER_BIND_BIT
@@ -896,7 +900,9 @@ class NBL_API2 IGPUCommandBuffer : public IBackendObject
         // The Command Pool already tracks resources referenced in the Build Infos or Copies From Memory (Deserializations), so we only need pointers into those records.
         struct TLASTrackingWrite
         {
-            std::span<const core::smart_refctd_ptr<const IReferenceCounted>> src;
+            // TODO: pack a little more efficiently so we can recover `CTrackedIterator` more easily
+            IGPUCommandPool::CTrackedIterator srcBegin;
+            uint32_t count;
             IGPUTopLevelAccelerationStructure* dst;
         };
         struct TLASTrackingCopy