put PoolAddressAllocator on a diet and get rid of the remnant of old times supportsNullBuffer

Author: devshgraphicsprogramming

include/nbl/core/alloc/GeneralpurposeAddressAllocator.h

@@ -440,8 +440,6 @@ class GeneralpurposeAddressAllocator : public AddressAllocatorBase<Generalpurpos
     public:
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-        static constexpr bool supportsNullBuffer = true;
-
         #define DUMMY_DEFAULT_CONSTRUCTOR GeneralpurposeAddressAllocator() noexcept : AllocStrategy(invalid_address,invalid_address) {}
         GCC_CONSTRUCTOR_INHERITANCE_BUG_WORKAROUND(DUMMY_DEFAULT_CONSTRUCTOR)
         #undef DUMMY_DEFAULT_CONSTRUCTOR
@@ -465,7 +463,7 @@ class GeneralpurposeAddressAllocator : public AddressAllocatorBase<Generalpurpos
                     AllocStrategy(newBuffSz-Base::alignOffset,std::move(other),newReservedSpc)
         {
         }
-        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator even if `supportsNullBuffer==true`
+        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
         GeneralpurposeAddressAllocator(size_type newBuffSz, GeneralpurposeAddressAllocator&& other, void* newReservedSpc, Args&&... args) noexcept :
                     Base(std::move(other),newReservedSpc,std::forward<Args>(args)...),

include/nbl/core/alloc/HeterogenousMemoryAddressAllocatorAdaptor.h

@@ -116,12 +116,7 @@ class HeterogenousMemoryAddressAllocatorAdaptor : public impl::HeterogenousMemor
                                             AddressAllocator(ImplBase::mReservedAlloc.allocate(ImplBase::mReservedSize,_NBL_SIMD_ALIGNMENT),
                                                                         addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz,std::forward<Args>(args)...)
         {
-            mAllocation = ImplBase::mDataAlloc.allocate(bufSz,maxAllocatableAlignment);
-			if constexpr(!alloc_traits::supportsNullBuffer)
-			{
-                this->getBaseAddrAllocRef().setDataBufferPtr(std::get<1u>(mAllocation));
-            }
-			
+            mAllocation = ImplBase::mDataAlloc.allocate(bufSz,maxAllocatableAlignment);			
         }
 
         virtual ~HeterogenousMemoryAddressAllocatorAdaptor()

include/nbl/core/alloc/LinearAddressAllocator.h

@@ -20,8 +20,6 @@ class LinearAddressAllocator : public AddressAllocatorBase<LinearAddressAllocato
     public:
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-        static constexpr bool supportsNullBuffer = true;
-
         #define DUMMY_DEFAULT_CONSTRUCTOR LinearAddressAllocator() : bufferSize(invalid_address), cursor(invalid_address) {}
         GCC_CONSTRUCTOR_INHERITANCE_BUG_WORKAROUND(DUMMY_DEFAULT_CONSTRUCTOR)
         #undef DUMMY_DEFAULT_CONSTRUCTOR
@@ -34,7 +32,7 @@ class LinearAddressAllocator : public AddressAllocatorBase<LinearAddressAllocato
             reset();
         }
 
-        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator even if `supportsNullBuffer==true`
+        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
         LinearAddressAllocator(_size_type newBuffSz, LinearAddressAllocator&& other, Args&&... args) :
             Base(std::move(other),std::forward<Args>(args)...), bufferSize(invalid_address), cursor(invalid_address)

include/nbl/core/alloc/PoolAddressAllocator.h

@@ -32,21 +32,19 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
             #endif // _NBL_DEBUG
 
             for (size_type i=0u; i<freeStackCtr; i++)
-                freeStack[i] = (blockCount-1u-i)*blockSize+Base::combinedOffset;
+                getFreeStack(i) = (blockCount-1u-i)*blockSize+Base::combinedOffset;
 
             for (size_type i=0; i<other.freeStackCtr; i++)
             {
-                size_type freeEntry = other.freeStack[i]-other.combinedOffset;
+                size_type freeEntry = other.getFreeStack(i)-other.combinedOffset;
 
                 if (freeEntry<blockCount*blockSize)
-                    freeStack[freeStackCtr++] = freeEntry+Base::combinedOffset;
+                    getFreeStack(freeStackCtr++) = freeEntry+Base::combinedOffset;
             }
         }
     public:
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-        static constexpr bool supportsNullBuffer = true;
-
         #define DUMMY_DEFAULT_CONSTRUCTOR PoolAddressAllocator() : blockSize(1u), blockCount(0u) {}
         GCC_CONSTRUCTOR_INHERITANCE_BUG_WORKAROUND(DUMMY_DEFAULT_CONSTRUCTOR)
         #undef DUMMY_DEFAULT_CONSTRUCTOR
@@ -55,16 +53,16 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
 
         PoolAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, size_type bufSz, size_type blockSz) noexcept :
 					Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment),
-						blockCount((bufSz-alignOffsetNeeded)/blockSz), blockSize(blockSz), freeStack(reinterpret_cast<size_type*>(Base::reservedSpace)), freeStackCtr(0u)
+						blockCount((bufSz-alignOffsetNeeded)/blockSz), blockSize(blockSz), freeStackCtr(0u)
         {
             reset();
         }
 
-        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator even if `supportsNullBuffer==true`
+        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
         PoolAddressAllocator(_size_type newBuffSz, PoolAddressAllocator&& other, Args&&... args) noexcept :
 					Base(std::move(other),std::forward<Args>(args)...),
-						blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStack(reinterpret_cast<size_type*>(Base::reservedSpace)), freeStackCtr(0u)
+						blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
             copyState(other, newBuffSz);
 
@@ -76,7 +74,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         template<typename... Args>
         PoolAddressAllocator(_size_type newBuffSz, const PoolAddressAllocator& other, Args&&... args) noexcept :
             Base(other, std::forward<Args>(args)...),
-            blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStack(reinterpret_cast<size_type*>(Base::reservedSpace)), freeStackCtr(0u)
+            blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
             copyState(other, newBuffSz);
         }
@@ -86,7 +84,6 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
             Base::operator=(std::move(other));
             std::swap(blockCount,other.blockCount);
             std::swap(blockSize,other.blockSize);
-			std::swap(freeStack,other.freeStack);
             std::swap(freeStackCtr,other.freeStackCtr);
             return *this;
         }
@@ -97,21 +94,21 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
             if (freeStackCtr==0u || (blockSize%alignment)!=0u || bytes==0u || bytes>blockSize)
                 return invalid_address;
 
-            return freeStack[--freeStackCtr];
+            return getFreeStack(--freeStackCtr);
         }
 
         inline void             free_addr(size_type addr, size_type bytes) noexcept
         {
             #ifdef _NBL_DEBUG
                 assert(addr>=Base::combinedOffset && (addr-Base::combinedOffset)%blockSize==0 && freeStackCtr<blockCount);
             #endif // _NBL_DEBUG
-			freeStack[freeStackCtr++] = addr;
+			getFreeStack(freeStackCtr++) = addr;
         }
 
         inline void             reset()
         {
             for (freeStackCtr=0u; freeStackCtr<blockCount; freeStackCtr++)
-                freeStack[freeStackCtr] = (blockCount-1u-freeStackCtr)*blockSize+Base::combinedOffset;
+                getFreeStack(freeStackCtr) = (blockCount-1u-freeStackCtr)*blockSize+Base::combinedOffset;
         }
 
         //! conservative estimate, does not account for space lost to alignment
@@ -139,12 +136,12 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
             if (allocSize>sizeBound)
                 sizeBound = allocSize;
 
-            auto tmpStackCopy = freeStack+freeStackCtr;
+            auto tmpStackCopy = &getFreeStack(freeStackCtr);
 
             size_type boundedCount = 0;
             for (size_type i=0; i<freeStackCtr; i++)
             {
-                auto freeAddr = freeStack[i];
+                auto freeAddr = getFreeStack(i);
                 if (freeAddr<sizeBound+Base::combinedOffset)
                     continue;
 
@@ -206,8 +203,10 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         // although to implement that one of the heaps would have to be in reverse in the memory (no wiggle room)
         // then can minimize fragmentation due to allocation and give lighting fast returns from `safe_shrink_size`
         // but then should probably have two pool allocators, because doing that changes insertion/removal from O(1) to O(log(N))
-		size_type*	freeStack;
         size_type   freeStackCtr;
+
+        inline size_type& getFreeStack(size_type i) {return reinterpret_cast<size_type*>(Base::reservedSpace)[i];}
+        inline const size_type& getFreeStack(size_type i) const {return reinterpret_cast<const size_type*>(Base::reservedSpace)[i];}
 };
 
 

include/nbl/core/alloc/ResizableHeterogenousMemoryAllocator.h

@@ -18,10 +18,10 @@ namespace core
 // if only we could use c++17 if-constexpr
 namespace impl
 {
-    template<class HeterogenousMemoryAllocator, bool supportsNullBuffer=HeterogenousMemoryAllocator::alloc_traits::supportsNullBuffer> class ResizableHeterogenousMemoryAllocatorBase;
+    template<class HeterogenousMemoryAllocator> class ResizableHeterogenousMemoryAllocatorBase;
 
     template<class HeterogenousMemoryAllocator>
-    class ResizableHeterogenousMemoryAllocatorBase<HeterogenousMemoryAllocator,true> : public HeterogenousMemoryAllocator // make protected?
+    class ResizableHeterogenousMemoryAllocatorBase : public HeterogenousMemoryAllocator // make protected?
     {
         protected:
             typedef HeterogenousMemoryAllocator Base;
@@ -37,25 +37,6 @@ namespace impl
                 mAddrAlloc = AddressAllocator(Base::mDataSize,std::move(mAddrAlloc),newReserved);
             }
     };
-
-    template<class HeterogenousMemoryAllocator>
-    class ResizableHeterogenousMemoryAllocatorBase<HeterogenousMemoryAllocator,false> : public HeterogenousMemoryAllocator // make protected?
-    {
-        protected:
-            typedef HeterogenousMemoryAllocator Base;
-
-            using Base::Base;
-
-            inline void resizeAddressAllocator(void* newReserved)
-            {
-                using alloc_traits = typename Base::alloc_traits;
-                using AddressAllocator = typename alloc_traits::allocator_type;
-
-                AddressAllocator& mAddrAlloc = Base::getBaseAddrAllocRef();
-                void* templateDeductionWorkaround = std::get<1u>(Base::mAllocation);
-                mAddrAlloc = AddressAllocator(templateDeductionWorkaround,Base::mDataSize,std::move(mAddrAlloc),newReserved);
-            }
-    };
 }
 
 template<class HeterogenousMemoryAllocator>

include/nbl/core/alloc/StackAddressAllocator.h

@@ -24,8 +24,6 @@ class StackAddressAllocator  : protected LinearAddressAllocator<_size_type>
 
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-        static constexpr bool supportsNullBuffer = true;
-
         #define DUMMY_DEFAULT_CONSTRUCTOR StackAddressAllocator() : minimumAllocSize(invalid_address), allocStackPtr(invalid_address) {}
         GCC_CONSTRUCTOR_INHERITANCE_BUG_WORKAROUND(DUMMY_DEFAULT_CONSTRUCTOR)
         #undef DUMMY_DEFAULT_CONSTRUCTOR
@@ -35,7 +33,7 @@ class StackAddressAllocator  : protected LinearAddressAllocator<_size_type>
         StackAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, size_type bufSz, size_type minAllocSize) noexcept :
                     Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz), minimumAllocSize(minAllocSize), allocStackPtr(0u) {}
 
-        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator even if `supportsNullBuffer==true`
+        //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
         StackAddressAllocator(size_type newBuffSz, StackAddressAllocator&& other, Args&&... args) :
                     Base(newBuffSz,std::move(other),std::forward<Args>(args)...),  minimumAllocSize(invalid_address), allocStackPtr(invalid_address)

include/nbl/core/alloc/address_allocator_traits.h

@@ -126,7 +126,6 @@ namespace core
 
             template<class U> using cstexpr_supportsArbitraryOrderFrees = decltype(std::declval<U&>().supportsArbitraryOrderFrees);
             template<class U> using cstexpr_maxMultiOps                 = decltype(std::declval<U&>().maxMultiOps);
-            template<class U> using cstexpr_supportsNullBuffer          = decltype(std::declval<U&>().supportsNullBuffer);
 
             template<class U> using func_multi_alloc_addr               = decltype(std::declval<U&>().multi_alloc_addr(0u,nullptr,nullptr,nullptr,nullptr));
             template<class U> using func_multi_free_addr                = decltype(std::declval<U&>().multi_free_addr(0u,nullptr,nullptr));
@@ -136,7 +135,6 @@ namespace core
         public:
             template<class,class=void> struct resolve_supportsArbitraryOrderFrees  : std::true_type {};
             template<class,class=void> struct resolve_maxMultiOps                           : std::integral_constant<uint32_t,256u> {};
-            template<class,class=void> struct resolve_supportsNullBuffer                  : std::true_type {};
 
             template<class,class=void> struct has_func_multi_alloc_addr                : std::false_type {};
             template<class,class=void> struct has_func_multi_free_addr                 : std::false_type {};
@@ -148,8 +146,6 @@ namespace core
                                                                             :  std::conditional<std::true_type/*std::is_same<cstexpr_supportsArbitraryOrderFrees<U>,bool>*/::value,nbl::bool_constant<U::supportsArbitraryOrderFrees>,resolve_supportsArbitraryOrderFrees<void,void> >::type {};
             template<class U> struct resolve_maxMultiOps<U,std::void_t<cstexpr_maxMultiOps<U> > >
                                                                             : std::conditional<std::true_type/*std::is_integral<cstexpr_maxMultiOps<U> >*/::value,std::integral_constant<uint32_t,U::maxMultiOps>, resolve_maxMultiOps<void, void> >::type {};
-            template<class U> struct resolve_supportsNullBuffer<U,std::void_t<cstexpr_supportsNullBuffer<U> > >
-                                                                            : std::conditional<std::true_type/*std::is_same<cstexpr_supportsNullBuffer<U>,bool>*/::value,nbl::bool_constant<U::supportsNullBuffer>,resolve_supportsNullBuffer<void,void> >::type {};
 
             template<class U> struct has_func_multi_alloc_addr<U,std::void_t<func_multi_alloc_addr<U> > >
                                                                             : std::is_same<func_multi_alloc_addr<U>,void> {};
@@ -160,7 +156,6 @@ namespace core
 
             _NBL_STATIC_INLINE_CONSTEXPR bool         supportsArbitraryOrderFrees = resolve_supportsArbitraryOrderFrees<AddressAlloc>::value;
             _NBL_STATIC_INLINE_CONSTEXPR uint32_t     maxMultiOps                 = resolve_maxMultiOps<AddressAlloc>::value;
-            _NBL_STATIC_INLINE_CONSTEXPR bool         supportsNullBuffer          = resolve_supportsNullBuffer<AddressAlloc>::value;
 
             static inline void          printDebugInfo()
             {
@@ -170,7 +165,6 @@ namespace core
 
                 printf("supportsArbitraryOrderFrees == %d\n", supportsArbitraryOrderFrees);
                 printf("maxMultiOps == %d\n",                           maxMultiOps);
-                printf("supportsNullBuffer == %d\n",                 supportsNullBuffer);
             }
 
 

include/nbl/video/IPropertyPool.h

@@ -112,31 +112,4 @@ class IPropertyPool : public core::IReferenceCounted
 }
 }
 
-#endif
-
-/*
-Old Code
-
-class IMeshSceneNodeInstanced : public ISceneNode
-{
-    struct MeshLoD
-    {
-        video::IGPUMesh* mesh;
-        void* userDataForVAOSetup; //put array of vertex attribute mappings here or something
-        float lodDistance;
-    };
-
-    virtual bool setLoDMeshes(const core::vector<MeshLoD>& levelsOfDetail, const size_t& dataSizePerInstanceOutput, const video::SGPUMaterial& lodSelectionShader, VaoSetupOverrideFunc vaoSetupOverride,
-        const size_t shaderLoDsPerPass = 1, void* overrideUserData = NULL, const size_t& extraDataSizePerInstanceInput = 0) = 0;
-
-    virtual video::CGPUMesh* getLoDMesh(const size_t& lod) = 0;
-
-
-    virtual const core::aabbox3df& getLoDInvariantBBox() const = 0;
-
-
-    inline void setBBoxUpdateEnabled() { wantBBoxUpdate = true; }
-    inline void setBBoxUpdateDisabled() { wantBBoxUpdate = false; }
-    inline const bool& getBBoxUpdateMode() { return wantBBoxUpdate; }
-};
-*/
+#endif