Nuke code that won't be used (for now)

Author: deprilula28

include/nbl/builtin/hlsl/property_pool/copy.comp.hlsl

@@ -3,10 +3,10 @@
 #include "nbl/builtin/hlsl/property_pool/transfer.hlsl"
 
 // https://github.com/microsoft/DirectXShaderCompiler/issues/6144
-template<typename capability_traits=nbl::hlsl::jit::device_capabilities_traits>
-uint32_t3 nbl::hlsl::glsl::gl_WorkGroupSize() {
-    return uint32_t3(capability_traits::maxOptimallyResidentWorkgroupInvocations, 1, 1);
-}
+// template<typename capability_traits=nbl::hlsl::jit::device_capabilities_traits>
+// uint32_t3 nbl::hlsl::glsl::gl_WorkGroupSize() {
+//     return uint32_t3(capability_traits::maxOptimallyResidentWorkgroupInvocations, 1, 1);
+// }
 
 [[numthreads(1, 1, 1)]
 void main(uint32_t3 dispatchId : SV_DispatchThreadID)

include/nbl/builtin/hlsl/property_pool/transfer.hlsl

@@ -1,3 +1,6 @@
+#ifndef _NBL_BUILTIN_HLSL_GLSL_PROPERTY_POOLS_TRANSFER_
+#define _NBL_BUILTIN_HLSL_GLSL_PROPERTY_POOLS_TRANSFER_
+
 namespace nbl
 {
 namespace hlsl
@@ -30,7 +33,9 @@ struct GlobalPushContants
     // BDA address (GPU pointer) into the transfer commands buffer
     uint64_t transferCommandsAddress;
 };
-
 }
 }
 }
+
+#endif
+

include/nbl/scene/ITransformTreeManager.h

@@ -253,6 +253,7 @@ class ITransformTreeManager : public virtual core::IReferenceCounted
 			return true;
 		}
 
+#if 0 // TODO: upstreaming cpropertypoolhandler
 		//
 		struct UpstreamRequestBase : RequestBase
 		{
@@ -496,6 +497,7 @@ class ITransformTreeManager : public virtual core::IReferenceCounted
 				waitSemaphoreCount,semaphoresToWaitBeforeOverwrite,stagesToWaitForPerSemaphore,request.logger,maxWaitPoint
 			);
 		}
+#endif
 
 
 

include/nbl/video/utilities/CPropertyPoolHandler.h

@@ -12,16 +12,15 @@
 #include "nbl/video/utilities/IDescriptorSetCache.h"
 #include "nbl/video/utilities/IPropertyPool.h"
 
+#include "glm/glm/glm.hpp"
+#include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
+#include <nbl/builtin/hlsl/cpp_compat/vector.hlsl>
+#include "nbl/builtin/hlsl/property_pool/transfer.hlsl"
 
 namespace nbl::video
 {
 
-#define int int32_t
-#define uint uint32_t
-#include "nbl/builtin/glsl/property_pool/transfer.glsl"
-#undef uint
-#undef int
-static_assert(NBL_BUILTIN_PROPERTY_POOL_INVALID==IPropertyPool::invalid);
+//static_assert(NBL_BUILTIN_PROPERTY_POOL_INVALID==IPropertyPool::invalid);
 
 // property pool factory is externally synchronized
 // TODO: could rename to CSparseStreamingSystem/CSparseStreamingHandler
@@ -36,30 +35,22 @@ class NBL_API2 CPropertyPoolHandler final : public core::IReferenceCounted, publ
 		//
 		inline ILogicalDevice* getDevice() {return m_device.get();}
 
-		//
-		inline const uint32_t getMaxPropertiesPerTransferDispatch() {return m_maxPropertiesPerPass;}
-
-		//
-		inline uint32_t getMaxScratchSize() const {return sizeof(nbl_glsl_property_pool_transfer_t)*m_maxPropertiesPerPass;}
-
         //
 		inline IGPUComputePipeline* getPipeline() {return m_pipeline.get();}
 		inline const IGPUComputePipeline* getPipeline() const {return m_pipeline.get();}
 
-        //
-		inline const IGPUDescriptorSetLayout* getCanonicalLayout() const { return m_dsCache->getCanonicalLayout(); }
-
         //
 		struct TransferRequest
 		{
 			//
 			enum E_FLAG : uint16_t
 			{
 				EF_NONE=0,
-				EF_DOWNLOAD=NBL_BUILTIN_PROPERTY_POOL_TRANSFER_EF_DOWNLOAD,
+				// this wasn't used anywhere in the hlsl
+				EF_DOWNLOAD=1,
 				// this flag will make the `srcAddresses ? srcAddresses[0]:0` be used as the source address for all reads, effectively "filling" with uniform value
-				EF_FILL=NBL_BUILTIN_PROPERTY_POOL_TRANSFER_EF_SRC_FILL,
-				EF_BIT_COUNT=NBL_BUILTIN_PROPERTY_POOL_TRANSFER_EF_BIT_COUNT
+				EF_FILL=2,
+				EF_BIT_COUNT=3
 			};
 			//
 			static inline constexpr uint32_t invalid_offset = ~0u;
@@ -71,9 +62,6 @@ class NBL_API2 CPropertyPoolHandler final : public core::IReferenceCounted, publ
 				elementSize = pool->getPropertySize(propertyID);
 			}
 
-			//
-			inline bool isDownload() const {return flags&EF_DOWNLOAD;}
-
 			//
 			inline uint32_t getSourceElementCount() const
 			{
@@ -101,6 +89,7 @@ class NBL_API2 CPropertyPoolHandler final : public core::IReferenceCounted, publ
 			system::logger_opt_ptr logger, const uint32_t baseDWORD=0u, const uint32_t endDWORD=~0ull
 		);
 
+#if 0 // TODO: Up streaming requests
 		//
 		struct UpStreamingRequest
 		{
@@ -189,7 +178,9 @@ class NBL_API2 CPropertyPoolHandler final : public core::IReferenceCounted, publ
 			uint32_t& waitSemaphoreCount, IGPUSemaphore* const*& semaphoresToWaitBeforeOverwrite, const asset::E_PIPELINE_STAGE_FLAGS*& stagesToWaitForPerSemaphore,
 			system::logger_opt_ptr logger, const std::chrono::steady_clock::time_point& maxWaitPoint=std::chrono::steady_clock::now()+std::chrono::microseconds(500u)
 		);
+#endif
 
+#if 0 // TODO: freeing properties
 		// utility to help you fill out the tail move scatter request after the free, properly, returns if you actually need to transfer anything
 		static inline bool freeProperties(IPropertyPool* pool, UpStreamingRequest* requests, const uint32_t* indicesBegin, const uint32_t* indicesEnd, uint32_t* srcAddresses, uint32_t* dstAddresses)
 		{
@@ -210,31 +201,18 @@ class NBL_API2 CPropertyPoolHandler final : public core::IReferenceCounted, publ
 			}
 			return false;
 		}
+#endif
 
     protected:
 		~CPropertyPoolHandler() {}
 
-		static inline constexpr auto MaxPropertiesPerDispatch = NBL_BUILTIN_PROPERTY_POOL_MAX_PROPERTIES_PER_DISPATCH;
+		static inline constexpr auto MaxPropertiesPerDispatch = 0u; // TODO
 		static inline constexpr auto DescriptorCacheSize = 128u;
 
 
 		core::smart_refctd_ptr<ILogicalDevice> m_device;
 		core::smart_refctd_ptr<IGPUComputePipeline> m_pipeline;
-		// TODO: investigate using Push Descriptors for this
-		class TransferDescriptorSetCache : public IDescriptorSetCache
-		{
-			public:
-				using IDescriptorSetCache::IDescriptorSetCache;
-
-				//
-				uint32_t acquireSet(
-					CPropertyPoolHandler* handler, const asset::SBufferBinding<video::IGPUBuffer>& scratch, const asset::SBufferBinding<video::IGPUBuffer>& addresses,
-					const TransferRequest* requests, const uint32_t propertyCount
-				);
-		};
-		core::smart_refctd_ptr<TransferDescriptorSetCache> m_dsCache;
 
-		uint16_t m_maxPropertiesPerPass;
 		uint32_t m_alignment;
 };
 

include/nbl/video/utilities/IPropertyPool.h

@@ -11,6 +11,11 @@
 #include "nbl/video/ILogicalDevice.h"
 #include "nbl/video/IGPUDescriptorSetLayout.h"
 
+#include "glm/glm/glm.hpp"
+#include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
+#include <nbl/builtin/hlsl/cpp_compat/vector.hlsl>
+#include "nbl/builtin/hlsl/property_pool/transfer.hlsl"
+
 namespace nbl::video
 {
 
@@ -21,8 +26,7 @@ class NBL_API2 IPropertyPool : public core::IReferenceCounted
 	public:
 		using PropertyAddressAllocator = core::PoolAddressAllocatorST<uint32_t>;
 
-        static inline constexpr auto invalid = PropertyAddressAllocator::invalid_address;
-
+        static inline constexpr uint64_t invalid = 0; 
 		//
         virtual const asset::SBufferRange<IGPUBuffer>& getPropertyMemoryBlock(uint32_t ix) const =0;
 
@@ -34,19 +38,19 @@ class NBL_API2 IPropertyPool : public core::IReferenceCounted
         inline bool isContiguous() const {return m_indexToAddr;}
 
         //
-        inline uint32_t getAllocated() const
+        inline uint64_t getAllocated() const
         {
             return indexAllocator.get_allocated_size();
         }
 
         //
-        inline uint32_t getFree() const
+        inline uint64_t getFree() const
         {
             return indexAllocator.get_free_size();
         }
 
         //
-        inline uint32_t getCapacity() const
+        inline uint64_t getCapacity() const
         {
             // special case allows us to use `get_total_size`, because the pool allocator has no added offsets
             return indexAllocator.get_total_size();
@@ -217,8 +221,8 @@ class NBL_API2 IPropertyPool : public core::IReferenceCounted
         static bool validateBlocks(const ILogicalDevice* device, const uint32_t propertyCount, const size_t* propertySizes, const uint32_t capacity, const asset::SBufferRange<IGPUBuffer>* _memoryBlocks);
 
         PropertyAddressAllocator indexAllocator;
-        uint32_t* m_indexToAddr;
-        uint32_t* m_addrToIndex;
+        uint64_t* m_indexToAddr;
+        uint64_t* m_addrToIndex;
 };
 
 

src/nbl/video/utilities/CPropertyPoolHandler.cpp

@@ -6,9 +6,32 @@ using namespace nbl;
 using namespace video;
 
 //
-CPropertyPoolHandler::CPropertyPoolHandler(core::smart_refctd_ptr<ILogicalDevice>&& device) : m_device(std::move(device)), m_dsCache()
+CPropertyPoolHandler::CPropertyPoolHandler(core::smart_refctd_ptr<ILogicalDevice>&& device) : m_device(std::move(device))
 {
-	// TODO: rewrite in HLSL!
+	auto system = m_device->getPhysicalDevice()->getSystem();
+	// TODO: Reuse asset manager from elsewhere?
+	auto assetManager = core::make_smart_refctd_ptr<asset::IAssetManager>(core::smart_refctd_ptr<system::ISystem>(system));
+
+	video::IGPUObjectFromAssetConverter CPU2GPU;
+	video::IGPUObjectFromAssetConverter::SParams cpu2gpuParams;
+	cpu2gpuParams.assetManager = assetManager.get();
+	cpu2gpuParams.device = m_device.get();
+	
+	auto loadShader = [&](const char* path)
+	{
+		asset::IAssetLoader::SAssetLoadParams params = {};
+		auto shader = core::smart_refctd_ptr_static_cast<asset::ICPUSpecializedShader>(*assetManager->getAsset(path, params).getContents().begin());
+		shader->setSpecializationInfo(asset::ISpecializedShader::SInfo(nullptr, nullptr, "main"));
+		assert(shader);
+
+		auto gpuShaders = CPU2GPU.getGPUObjectsFromAssets(&shader, &shader + 1u, cpu2gpuParams);
+		auto gpuShader = gpuShaders->begin()[0u];
+		assert(gpuShader);
+
+		return gpuShader;
+	};
+	auto shader = loadShader("../../../include/nbl/builtin/hlsl/property_pool/copy.comp.hlsl");
+
 #if 0
 	const auto& deviceLimits = m_device->getPhysicalDevice()->getLimits();
 	m_maxPropertiesPerPass = core::min<uint32_t>((deviceLimits.maxPerStageDescriptorSSBOs-2u)/2u,MaxPropertiesPerDispatch);
@@ -66,6 +89,7 @@ bool CPropertyPoolHandler::transferProperties(
 	system::logger_opt_ptr logger, const uint32_t baseDWORD, const uint32_t endDWORD
 )
 {
+#if 0
 	if (requestsBegin==requestsEnd)
 		return true;
 	if (!scratch.buffer || !scratch.buffer->getCreationParams().usage.hasFlags(IGPUBuffer::EUF_INLINE_UPDATE_VIA_CMDBUF))
@@ -180,15 +204,20 @@ bool CPropertyPoolHandler::transferProperties(
 		result = copyPass(requests,leftOverProps)&&result;
 
 	return result;
+#endif
+	return false;
 }
 
+#if 0 // TODO: up streaming requests
+
 uint32_t CPropertyPoolHandler::transferProperties(
 	StreamingTransientDataBufferMT<>* const upBuff, IGPUCommandBuffer* const cmdbuf, IGPUFence* const fence, IGPUQueue* const queue,
 	const asset::SBufferBinding<video::IGPUBuffer>& scratch, UpStreamingRequest* &requests, const uint32_t requestCount,
 	uint32_t& waitSemaphoreCount, IGPUSemaphore* const*& semaphoresToWaitBeforeOverwrite, const asset::E_PIPELINE_STAGE_FLAGS*& stagesToWaitForPerSemaphore,
 	system::logger_opt_ptr logger, const std::chrono::steady_clock::time_point& maxWaitPoint
 )
 {
+#if 0
 	if (!requestCount)
 		return 0u;
 
@@ -526,72 +555,9 @@ uint32_t CPropertyPoolHandler::transferProperties(
 	const auto leftOverProps = requestCount-fullPasses*m_maxPropertiesPerPass;
 	if (leftOverProps)
 		return copyPass(requests,leftOverProps);
+#endif
 
 	return 0u;
 }
 
-uint32_t CPropertyPoolHandler::TransferDescriptorSetCache::acquireSet(
-	CPropertyPoolHandler* handler, const asset::SBufferBinding<video::IGPUBuffer>& scratch, const asset::SBufferBinding<video::IGPUBuffer>& addresses,
-	const TransferRequest* requests, const uint32_t propertyCount
-)
-{
-	auto retval = IDescriptorSetCache::acquireSet();
-	if (retval==IDescriptorSetCache::invalid_index)
-		return IDescriptorSetCache::invalid_index;
-	
-
-	auto device = handler->getDevice();
-	const auto maxPropertiesPerPass = handler->getMaxPropertiesPerTransferDispatch();
-
-
-	IGPUDescriptorSet::SDescriptorInfo infos[MaxPropertiesPerDispatch*2u+2u];
-	infos[0] = scratch;
-	infos[0].info.buffer.size = sizeof(nbl_glsl_property_pool_transfer_t)*propertyCount;
-	infos[1] = addresses;
-	auto* inDescInfo = infos+2;
-	auto* outDescInfo = infos+2+maxPropertiesPerPass;
-	for (uint32_t i=0u; i<propertyCount; i++)
-	{
-		const auto& request = requests[i];
-			
-		const auto& memblock = request.memblock;
-
-		// no not attempt to bind sized ranges of the buffers, remember that the copies are indexed, so the reads and writes may be scattered
-		if (request.isDownload())
-		{
-			inDescInfo[i] = memblock;
-			outDescInfo[i] = request.buffer;
-		}
-		else
-		{
-			inDescInfo[i] = request.buffer;
-			outDescInfo[i] = memblock;
-		}
-	}
-	// just to make Vulkan shut up
-	for (uint32_t i=propertyCount; i<maxPropertiesPerPass; i++)
-	{
-		inDescInfo[i] = scratch;
-		outDescInfo[i] = scratch;
-	}
-	IGPUDescriptorSet::SWriteDescriptorSet writes[4u];
-	IGPUDescriptorSet* const set = IDescriptorSetCache::getSet(retval);
-	for (auto i=0u; i<4u; i++)
-	{
-		writes[i].dstSet = set;
-		writes[i].binding = i;
-		writes[i].arrayElement = 0u;
-		writes[i].descriptorType = asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER;
-	}
-	writes[0].count = 1u;
-	writes[0].info = infos;
-	writes[1].count = 1u;
-	writes[1].info = infos+1u;
-	writes[2].count = maxPropertiesPerPass;
-	writes[2].info = inDescInfo;
-	writes[3].count = maxPropertiesPerPass;
-	writes[3].info = outDescInfo;
-	device->updateDescriptorSets(4u, writes, 0u, nullptr);
-
-	return retval;
-}
+#endif

src/nbl/video/utilities/IPropertyPool.cpp

@@ -20,7 +20,7 @@ IPropertyPool::IPropertyPool(uint32_t capacity, void* reserved, bool contiguous)
 {
     if (contiguous)
     {
-        m_indexToAddr = reinterpret_cast<uint32_t*>(reinterpret_cast<uint8_t*>(reserved)+getReservedSize(capacity));
+        m_indexToAddr = reinterpret_cast<uint64_t*>(reinterpret_cast<uint8_t*>(reserved)+getReservedSize(capacity));
         m_addrToIndex = m_indexToAddr+capacity;
 
         std::fill_n(m_indexToAddr,capacity,invalid);