Merge branch 'resizable_cache'

Author: Erfan-Ahmadi

Diff for: include/nbl/core/alloc/AddressAllocatorBase.h

@@ -14,9 +14,9 @@ namespace core
 {
 
     #define _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(SIZE_TYPE) \
-            typedef SIZE_TYPE                                   size_type;\
-            typedef typename std::make_signed<size_type>::type  difference_type;\
-            typedef uint8_t*                                    ubyte_pointer;\
+            using size_type =                                   SIZE_TYPE;\
+            using difference_type =                             typename std::make_signed<size_type>::type;\
+            using ubyte_pointer =                               uint8_t*;\
             static constexpr size_type                          invalid_address = nbl::core::address_type_traits<size_type>::invalid_address
 
     template<typename CRTP, typename _size_type>
@@ -25,11 +25,7 @@ namespace core
         public:
             _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-            AddressAllocatorBase() :
-                reservedSpace(nullptr), addressOffset(invalid_address), alignOffset(invalid_address),
-                maxRequestableAlignment(invalid_address), combinedOffset(invalid_address) {}
-            
-
+            AddressAllocatorBase() { invalidate(); }
 
             inline _size_type           max_alignment() const noexcept
             {
@@ -72,9 +68,7 @@ namespace core
                     assert(core::isPoT(maxRequestableAlignment)); // this is not a proper alignment value
                 #endif // _NBL_DEBUG
             }
-            AddressAllocatorBase(CRTP&& other, void* newReservedSpc) :
-                    reservedSpace(nullptr), addressOffset(invalid_address), alignOffset(invalid_address),
-                    maxRequestableAlignment(invalid_address), combinedOffset(invalid_address)
+            AddressAllocatorBase(CRTP&& other, void* newReservedSpc)
             {
                 operator=(std::move(other));
                 reservedSpace = newReservedSpc;
@@ -123,14 +117,24 @@ namespace core
 
             AddressAllocatorBase& operator=(AddressAllocatorBase&& other)
             {
-                std::swap(reservedSpace,other.reservedSpace);
-                std::swap(addressOffset,other.addressOffset);
-                std::swap(alignOffset,other.alignOffset);
-                std::swap(maxRequestableAlignment,other.maxRequestableAlignment);
-                std::swap(combinedOffset,other.combinedOffset);
+                reservedSpace = other.reservedSpace;
+                addressOffset = other.addressOffset;
+                alignOffset = other.alignOffset;
+                maxRequestableAlignment = other.maxRequestableAlignment;
+                combinedOffset = other.combinedOffset;
+                other.invalidate();
                 return *this;
             }
 
+            void invalidate()
+            {
+                reservedSpace = nullptr;
+                addressOffset = invalid_address;
+                alignOffset = invalid_address;
+                maxRequestableAlignment = invalid_address;
+                combinedOffset = invalid_address;
+            }
+
             // pointer to allocator specific state-keeping data, please note that irrBaW address allocators were designed to allocate memory they can't actually access
             void*           reservedSpace;
             // automatic offset to be added to generated addresses

Diff for: include/nbl/core/alloc/IteratablePoolAddressAllocator.h

@@ -21,61 +21,61 @@ namespace core
 template<typename _size_type>
 class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type>
 {
-        using Base = PoolAddressAllocator<_size_type>;
+        using base_t = PoolAddressAllocator<_size_type>;
     protected:
-        inline _size_type* begin() { return &Base::getFreeStack(Base::freeStackCtr); }
-        inline _size_type& getIteratorOffset(_size_type i) {return reinterpret_cast<_size_type*>(Base::reservedSpace)[Base::blockCount+i];}
-        inline const _size_type& getIteratorOffset(_size_type i) const {return reinterpret_cast<const _size_type*>(Base::reservedSpace)[Base::blockCount+i];}
+        inline _size_type* begin() { return &base_t::getFreeStack(base_t::freeStackCtr); }
+        inline _size_type& getIteratorOffset(_size_type i) {return reinterpret_cast<_size_type*>(base_t::reservedSpace)[base_t::blockCount+i];}
+        inline const _size_type& getIteratorOffset(_size_type i) const {return reinterpret_cast<const _size_type*>(base_t::reservedSpace)[base_t::blockCount+i];}
 
     private:
 
         void copySupplementaryState(const IteratablePoolAddressAllocator& other, _size_type newBuffSz)
         {
             std::copy(other.begin(),other.end(),begin());
-            for (auto i=0u; i<std::min(Base::blockCount,other.blockCount); i++)
+            for (auto i=0u; i<std::min(base_t::blockCount,other.blockCount); i++)
                 getIteratorOffset(i) = other.getIteratorOffset(i);
         }
         // use [freeStackCtr,blockCount) as the iteratable range
         // use [blockCount,blockCount*2u) to store backreferences to iterators
     public:
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-        IteratablePoolAddressAllocator() : Base() {}
+        IteratablePoolAddressAllocator() : base_t() {}
         virtual ~IteratablePoolAddressAllocator() {}
 
         IteratablePoolAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, _size_type bufSz, _size_type blockSz) noexcept :
-			Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz,blockSz) {}
+			base_t(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz,blockSz) {}
+
 
         //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
-        IteratablePoolAddressAllocator(_size_type newBuffSz, IteratablePoolAddressAllocator&& other, Args&&... args) noexcept :
-			Base(newBuffSz,std::move(other),std::forward<Args>(args)...)
+        IteratablePoolAddressAllocator(_size_type newBuffSz, const IteratablePoolAddressAllocator& other, Args&&... args) noexcept :
+            base_t(newBuffSz, other, std::forward<Args>(args)...)
         {
-            copyState(other, newBuffSz);
+            copySupplementaryState(other, newBuffSz);
         }
-
+        
         template<typename... Args>
-        IteratablePoolAddressAllocator(_size_type newBuffSz, const IteratablePoolAddressAllocator& other, Args&&... args) noexcept :
-			Base(newBuffSz,other,std::forward<Args>(args)...)
+        IteratablePoolAddressAllocator(_size_type newBuffSz, IteratablePoolAddressAllocator&& other, Args&&... args) noexcept :
+            IteratablePoolAddressAllocator(newBuffSz,other,std::forward<Args>(args)...)
         {
-            copyState(other, newBuffSz);
+            other.base_t::invalidate();
         }
 
         IteratablePoolAddressAllocator& operator=(IteratablePoolAddressAllocator&& other)
         {
-            Base::operator=(std::move(other));
+            base_t::operator=(std::move(other));
             return *this;
         }
 
-
         //! Functions that actually differ
         inline _size_type        alloc_addr(_size_type bytes, _size_type alignment, _size_type hint=0ull) noexcept
         {
-            const _size_type allocatedAddress = Base::alloc_addr(bytes,alignment,hint);
+            const _size_type allocatedAddress = base_t::alloc_addr(bytes,alignment,hint);
             if (allocatedAddress!=invalid_address)
             {
                 *begin() = allocatedAddress;
-                getIteratorOffset(addressToBlockID(allocatedAddress)) = Base::freeStackCtr;
+                getIteratorOffset(addressToBlockID(allocatedAddress)) = base_t::freeStackCtr;
             }
             return allocatedAddress;
         }
@@ -84,21 +84,21 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type
         {
             const _size_type iteratorOffset = getIteratorOffset(addressToBlockID(addr));
             #ifdef _NBL_DEBUG
-                assert(iteratorOffset>=Base::freeStackCtr);
+                assert(iteratorOffset>=base_t::freeStackCtr);
             #endif
             // swap the erased element with either end of the array in the contiguous array
             // not using a swap cause it doesn't matter where the erased element points
             const _size_type otherNodeOffset = *begin();
-            reinterpret_cast<_size_type*>(Base::reservedSpace)[iteratorOffset] = otherNodeOffset;
+            reinterpret_cast<_size_type*>(base_t::reservedSpace)[iteratorOffset] = otherNodeOffset;
             // but I need to patch up the back-link of the moved element
             getIteratorOffset(addressToBlockID(otherNodeOffset)) = iteratorOffset;
 
-            Base::free_addr(addr,bytes);
+            base_t::free_addr(addr,bytes);
         }
 
         // gets a range of all the allocated addresses
-        inline const _size_type* begin() const {return &Base::getFreeStack(Base::freeStackCtr);}
-        inline const _size_type* end() const {return &Base::getFreeStack(Base::blockCount);}
+        inline const _size_type* begin() const {return &base_t::getFreeStack(base_t::freeStackCtr);}
+        inline const _size_type* end() const {return &base_t::getFreeStack(base_t::blockCount);}
 
 
         inline _size_type        safe_shrink_size(_size_type sizeBound, _size_type newBuffAlignmentWeCanGuarantee=1u) noexcept
@@ -124,31 +124,31 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type
 
         inline void         reset()
         {
-            Base::reset();
+            base_t::reset();
         }
         inline _size_type    max_size() const noexcept
         {
-            return Base::max_size();
+            return base_t::max_size();
         }
         inline _size_type    min_size() const noexcept
         {
-            return Base::min_size();
+            return base_t::min_size();
         }
         inline _size_type    get_free_size() const noexcept
         {
-            return Base::get_free_size();
+            return base_t::get_free_size();
         }
         inline _size_type    get_allocated_size() const noexcept
         {
-            return Base::get_allocated_size();
+            return base_t::get_allocated_size();
         }
         inline _size_type    get_total_size() const noexcept
         {
-            return Base::get_total_size();
+            return base_t::get_total_size();
         }
         inline _size_type    addressToBlockID(_size_type addr) const noexcept
         {
-            return Base::addressToBlockID(addr);
+            return base_t::addressToBlockID(addr);
         }
 };
 

Diff for: include/nbl/core/alloc/PoolAddressAllocator.h

@@ -20,32 +20,32 @@ template<typename _size_type>
 class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_size_type>,_size_type>
 {
     private:
-        typedef AddressAllocatorBase<PoolAddressAllocator<_size_type>,_size_type> Base;
+        using base_t = AddressAllocatorBase<PoolAddressAllocator<_size_type>,_size_type>;
 
         void copyState(const PoolAddressAllocator& other, _size_type newBuffSz)
         {
             if (blockCount>other.blockCount)
                 freeStackCtr = blockCount-other.blockCount;
 
             #ifdef _NBL_DEBUG
-                assert(Base::checkResize(newBuffSz,Base::alignOffset));
-                assert(freeStackCtr==0u);
+                assert(base_t::checkResize(newBuffSz,base_t::alignOffset));
             #endif // _NBL_DEBUG
 
             for (_size_type i=0u; i<freeStackCtr; i++)
-                getFreeStack(i) = (blockCount-1u-i)*blockSize+Base::combinedOffset;
+                getFreeStack(i) = (blockCount-1u-i)*blockSize+base_t::combinedOffset;
 
             for (_size_type i=0; i<other.freeStackCtr; i++)
             {
-                _size_type freeEntry = other.getFreeStack(i)-other.combinedOffset;
+                _size_type freeEntry = other.getFreeStack(i)-other.base_t::combinedOffset;
                 // check in case of shrink
                 if (freeEntry<blockCount*blockSize)
-                    getFreeStack(freeStackCtr++) = freeEntry+Base::combinedOffset;
+                    getFreeStack(freeStackCtr++) = freeEntry+base_t::combinedOffset;
             }
         }
+
         inline bool safe_shrink_size_common(_size_type& sizeBound, _size_type newBuffAlignmentWeCanGuarantee) noexcept
         {
-            _size_type capacity = get_total_size()-Base::alignOffset;
+            _size_type capacity = get_total_size()-base_t::alignOffset;
             if (sizeBound>=capacity)
                 return false;
 
@@ -71,7 +71,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         virtual ~PoolAddressAllocator() {}
 
         PoolAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, size_type bufSz, size_type blockSz) noexcept :
-					Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment),
+					base_t(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment),
 						blockCount((bufSz-alignOffsetNeeded)/blockSz), blockSize(blockSz), freeStackCtr(0u)
         {
             reset();
@@ -80,29 +80,28 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         //! 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), freeStackCtr(0u)
+					base_t(other,std::forward<Args>(args)...),
+						blockCount((newBuffSz-base_t::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
             copyState(other, newBuffSz);
 
-            other.blockCount = invalid_address;
-			other.blockSize = invalid_address;
-            other.freeStackCtr = invalid_address;
+            other.invalidate();
         }
         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), freeStackCtr(0u)
+            base_t(other, std::forward<Args>(args)...),
+            blockCount((newBuffSz-base_t::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
             copyState(other, newBuffSz);
         }
 
         PoolAddressAllocator& operator=(PoolAddressAllocator&& other)
         {
-            Base::operator=(std::move(other));
-            std::swap(blockCount,other.blockCount);
-            std::swap(blockSize,other.blockSize);
-            std::swap(freeStackCtr,other.freeStackCtr);
+            base_t::operator=(std::move(other));
+            blockCount = other.blockCount;
+            blockSize = other.blockSize;
+            freeStackCtr = other.freeStackCtr;
+            other.invalidateLocal();
             return *this;
         }
 
@@ -118,15 +117,15 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         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);
+                assert(addr>=base_t::combinedOffset && (addr-base_t::combinedOffset)%blockSize==0 && freeStackCtr<blockCount);
             #endif // _NBL_DEBUG
 			getFreeStack(freeStackCtr++) = addr;
         }
 
         inline void             reset()
         {
             for (freeStackCtr=0u; freeStackCtr<blockCount; freeStackCtr++)
-                getFreeStack(freeStackCtr) = (blockCount-1u-freeStackCtr)*blockSize+Base::combinedOffset;
+                getFreeStack(freeStackCtr) = (blockCount-1u-freeStackCtr)*blockSize+base_t::combinedOffset;
         }
 
         //! conservative estimate, does not account for space lost to alignment
@@ -151,7 +150,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
                 for (size_type i=0; i<freeStackCtr; i++)
                 {
                     auto freeAddr = getFreeStack(i);
-                    if (freeAddr<sizeBound+Base::combinedOffset)
+                    if (freeAddr<sizeBound+base_t::combinedOffset)
                         continue;
 
                     tmpStackCopy[boundedCount++] = freeAddr;
@@ -162,7 +161,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
                     std::make_heap(tmpStackCopy,tmpStackCopy+boundedCount);
                     std::sort_heap(tmpStackCopy,tmpStackCopy+boundedCount);
                     // could do sophisticated modified version of std::adjacent_find with a binary search, but F'it
-                    size_type endAddr = (blockCount-1u)*blockSize+Base::combinedOffset;
+                    size_type endAddr = (blockCount-1u)*blockSize+base_t::combinedOffset;
                     size_type i=0u;
                     for (;i<boundedCount; i++,endAddr-=blockSize)
                     {
@@ -173,7 +172,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
                     sizeBound -= i*blockSize;
                 }
             }
-            return Base::safe_shrink_size(sizeBound,newBuffAlignmentWeCanGuarantee);
+            return base_t::safe_shrink_size(sizeBound,newBuffAlignmentWeCanGuarantee);
         }
 
 
@@ -197,16 +196,36 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         }
         inline size_type        get_total_size() const noexcept
         {
-            return blockCount*blockSize+Base::alignOffset;
+            return blockCount*blockSize+base_t::alignOffset;
         }
 
 
 
         inline size_type addressToBlockID(size_type addr) const noexcept
         {
-            return (addr-Base::combinedOffset)/blockSize;
+            return (addr-base_t::combinedOffset)/blockSize;
         }
     protected:
+
+        /**
+        * @brief Invalidates only fields from this class extension
+        */
+        void invalidateLocal()
+        {
+            blockCount = invalid_address;
+            blockSize = invalid_address;
+            freeStackCtr = invalid_address;
+        }
+
+        /**
+        * @brief Invalidates all fields
+        */
+        void invalidate()
+        {
+            base_t::invalidate();
+            invalidateLocal();
+        }
+
         size_type   blockCount;
         size_type   blockSize;
         // TODO: free address min-heap and allocated addresses max-heap, packed into the same memory (whatever is not allocated is free)
@@ -215,8 +234,8 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         // but then should probably have two pool allocators, because doing that changes insertion/removal from O(1) to O(log(N))
         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];}
+        inline size_type& getFreeStack(size_type i) {return reinterpret_cast<size_type*>(base_t::reservedSpace)[i];}
+        inline const size_type& getFreeStack(size_type i) const {return reinterpret_cast<const size_type*>(base_t::reservedSpace)[i];} 
 };