Fixed allocator move constructor bug

Author: Fletterio

examples_tests

@@ -36,12 +36,34 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
 
             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::combinedOffset;
                 // check in case of shrink
                 if (freeEntry<blockCount*blockSize)
                     getFreeStack(freeStackCtr++) = freeEntry+Base::combinedOffset;
             }
         }
+
+        void copyStateMove(_size_type otherBlockCount, _size_type otherFreeStackCtr, _size_type newBuffSz)
+        {
+            if (blockCount > otherBlockCount)
+                freeStackCtr = blockCount - otherBlockCount;
+
+            #ifdef _NBL_DEBUG
+            assert(Base::checkResize(newBuffSz, Base::alignOffset));
+            #endif // _NBL_DEBUG
+
+            for (_size_type i = 0u; i < freeStackCtr; i++)
+                getFreeStack(i) = (blockCount - 1u - i) * blockSize + Base::combinedOffset;
+
+            for (_size_type i = 0; i < otherFreeStackCtr; i++)
+            {
+                _size_type freeEntry = getFreeStack(i) - Base::combinedOffset;
+                // check in case of shrink
+                if (freeEntry < blockCount * blockSize)
+                    getFreeStack(freeStackCtr++) = freeEntry + Base::combinedOffset;
+            }
+        }
+
         inline bool safe_shrink_size_common(_size_type& sizeBound, _size_type newBuffAlignmentWeCanGuarantee) noexcept
         {
             _size_type capacity = get_total_size()-Base::alignOffset;
@@ -82,7 +104,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
 					Base(std::move(other),std::forward<Args>(args)...),
 						blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
-            copyState(other, newBuffSz);
+            copyStateMove(other.blockCount, other.freeStackCtr, newBuffSz);
 
             other.blockCount = invalid_address;
 			other.blockSize = invalid_address;

include/nbl/core/alloc/PoolAddressAllocator.h

@@ -195,16 +195,16 @@ class DoublyLinkedList
 			return false;
 
 		node_t* newArray = reinterpret_cast<node_t*>(reinterpret_cast<uint8_t*>(newReservedSpace) + firstPart);
-
-		// Copy memory over to new buffer, then free old one
+		// Copy memory over to new buffer
 		memcpy(newArray, m_array, m_cap * sizeof(node_t));
-		_NBL_ALIGNED_FREE(m_reservedSpace);
-
-		// Finally, create new address allocator from old one
+		// Create new address allocator from old one
 		m_addressAllocator = std::unique_ptr<address_allocator_t>(new address_allocator_t(newCapacity, std::move(*(m_addressAllocator)), newReservedSpace));
+		// After address allocator creation we can free the old buffer
+		_NBL_ALIGNED_FREE(m_reservedSpace);
 		m_cap = newCapacity;
 		m_array = newArray;
 		m_reservedSpace = newReservedSpace;
+		
 
 		return true;
 	}

include/nbl/core/containers/DoublyLinkedList.h

@@ -281,11 +281,10 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 	using assoc_t = typename base_t::list_value_t;
 
 	//Constructor
-	ResizableLRUCache(const uint32_t capacity, disposal_func_t&& _df = disposal_func_t(), MapHash&& _hash = MapHash(), MapEquals&& _equals = MapEquals()) :
-		base_t(capacity, std::move(_hash), std::move(_equals), std::move(_df)),
+	ResizableLRUCache(uint32_t capacity, disposal_func_t&& _df = disposal_func_t(), MapHash&& _hash = MapHash(), MapEquals&& _equals = MapEquals()) :
+		base_t(capacity, std::move(_hash), std::move(_equals), std::move(_df)), m_capacity(capacity),
 		m_shortcut_map(capacity >> 2, WrapHash{ this }, WrapEquals{ this }) // 4x less buckets than capacity seems reasonable
 	{
-		assert(capacity > 1);
 		m_shortcut_map.reserve(capacity);
 	}
 	ResizableLRUCache() = delete;
@@ -301,10 +300,29 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 			stringStream << "k: '" << node->data.first << "', v: '" << node->data.second << "'\t prev: " << node->prev << " | curr: " << nodeAddr << " | next: " << node->next;
 			logger->log(stringStream.str());
 			nodeAddr = node->prev;
-			node = base_t::m_list.get(node->prev);
 		}
 	}
 
+	/**
+	* @brief Returns a string representing the elements currently in the cache in LRU order
+	*
+	* @param [in] newCapacity New number of elements to hold. MUST be greater than current list capacity.
+	*/
+	inline std::string getState()
+	{
+		std::ostringstream stringStream;
+		auto nodeAddr = base_t::m_list.getLastAddress();
+		while (nodeAddr != invalid_iterator)
+		{
+			auto node = base_t::m_list.get(nodeAddr);
+			stringStream << "{" << node->data.first << ", " << node->data.second << "}";
+			nodeAddr = node->prev;
+			if (nodeAddr != invalid_iterator)
+				stringStream << ", ";
+		}
+		return stringStream.str();
+	}
+
 	template<typename K, typename V, std::invocable<const Value&> EvictionCallback> requires std::is_constructible_v<Value, V> // && (std::is_same_v<Value,V> || std::is_assignable_v<Value,V>) // is_assignable_v<int, int&> returns false :(
 	inline Value* insert(K&& k, V&& v, EvictionCallback&& evictCallback)
 	{
@@ -390,6 +408,8 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 	*/
 	inline bool grow(uint32_t newCapacity)
 	{
+		if (newCapacity <= m_capacity)
+			return false;
 		m_shortcut_map.reserve(newCapacity);
 		return base_t::m_list.grow(newCapacity);
 	}
@@ -409,6 +429,7 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 
 protected:
 	unordered_set<uint32_t, WrapHash, WrapEquals> m_shortcut_map;
+	uint32_t m_capacity;
 };
 
 }	//namespace core