Merge branch 'resizable_cache'

Author: Erfan-Ahmadi

21_LRUCacheUnitTest/main.cpp

@@ -33,7 +33,7 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 			inline TextureReference& operator=(uint64_t semamphoreVal) { lastUsedSemaphoreValue = semamphoreVal; return *this;  }
 		};
 
-		using TextureLRUCache = core::LRUCache<uint32_t, TextureReference>;
+		using TextureLRUCache = core::ResizableLRUCache<uint32_t, TextureReference>;
 
 		// we stuff all our work here because its a "single shot" app
 		bool onAppInitialized(smart_refctd_ptr<ISystem>&& system) override
@@ -44,12 +44,18 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 
 			m_logger->log("LRU cache unit test");
 			m_logger->log("Testing large cache...");
-			LRUCache<int, char> hugeCache(50000000u);
+			ResizableLRUCache<int, char> hugeCache(50000000u);
 			hugeCache.insert(0, '0');
 			hugeCache.print(m_logger);
 
-
-			LRUCache<int, char> cache(5u);
+			// Use this to ensure the disposal function is properly called on every element of the first cache
+			ResizableLRUCache<int, char>::disposal_func_t df([&](std::pair<int, char> a) 
+				{ 
+					std::ostringstream tmp;
+					tmp << "Disposal function called on element (" << a.first << ", " << a.second << ")";
+					m_logger->log(tmp.str()); 
+				});
+			ResizableLRUCache<int, char> cache(5u, std::move(df));
 
 			m_logger->log("Testing insert with const key, const val...");
 			//const, const
@@ -80,8 +86,11 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 			//non const, const
 			int i = 0;
 			cache.insert(++i, '1');
+			assert(cache.getState() == "{12, e}, {10, c}, {11, d}, {13, f}, {1, 1}");
 			cache.insert(++i, '2');
+			assert(cache.getState() == "{10, c}, {11, d}, {13, f}, {1, 1}, {2, 2}");
 			cache.insert(++i, '3');
+			assert(cache.getState() == "{11, d}, {13, f}, {1, 1}, {2, 2}, {3, 3}");
 			returned = *(cache.get(1));
 			assert(returned == '1');
 
@@ -111,7 +120,17 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 			auto peekedNullptr = cache.peek(5);
 			assert(peekedNullptr == nullptr);
 
-			core::LRUCache<int, std::string> cache2(5u);
+			// Try clearing the cache
+			m_logger->log("Clearing test");
+			m_logger->log("Print contents before clearing");
+			cache.print(m_logger);
+			assert(cache.getState() == "{2, 2}, {3, 3}, {1, 1}, {4, N}, {6, Y}");
+			cache.clear();
+			m_logger->log("Print contents after clearing");
+			cache.print(m_logger);
+			assert(cache.getState() == "");
+
+			ResizableLRUCache<int, std::string> cache2(5u);
 
 			cache2.insert(500, "five hundred");			//inserts at addr = 0
 			cache2.insert(510, "five hundred and ten");	//inserts at addr = 472
@@ -124,6 +143,82 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 			cache2.print(m_logger);
 			cache2.insert(++i, "key is 112");
 
+			// Grow test - try growing the cache
+			m_logger->log("Growing test");
+			auto previousState = cache2.getState();
+			// Grow cache
+			assert(cache2.grow(10));
+			// Cache state should be the same
+			assert(cache2.getState() == previousState);
+			cache2.print(m_logger);
+			cache2.insert(++i, "key is 113");
+			cache2.insert(++i, "key is 114");
+			cache2.insert(++i, "key is 115");
+			cache2.insert(++i, "key is 116");
+			cache2.insert(++i, "key is 117");
+			cache2.print(m_logger);
+			// Should evict key 52
+			cache2.insert(++i, "key is 118");
+			cache2.print(m_logger);
+			const auto latestState = cache2.getState();
+			assert(latestState == "{21, key is 21}, {22, key is 22}, {23, key is 23}, {112, key is 112}, {113, key is 113}, {114, key is 114}, {115, key is 115}, {116, key is 116}, {117, key is 117}, {118, key is 118}");
+			// Invalid grow should fail
+			assert(!cache2.grow(5));
+			assert(!cache2.grow(10));
+			// Call a bunch of grows that shouldn't fail and some others that should
+			for (auto i = 1u; i < 50; i++)
+			{
+				assert(cache2.grow(50 * i));
+				assert(!cache2.grow(25 * i));
+				assert(!cache2.grow(50 * i));
+				assert(cache2.getState() == latestState);
+			}
+			
+			// Single element cache test - checking for edge cases
+			ResizableLRUCache<int, std::string> cache3(1u);
+			cache3.insert(0, "foo");
+			cache3.insert(1, "bar");
+			cache3.clear();
+
+			// Besides the disposal function that gets called when evicting, we need to check that the Cache properly destroys all resident `Key,Value` pairs when destroyed
+			struct Foo
+			{
+				int* destroyCounter;
+
+				Foo(int* _destroyCounter) : destroyCounter(_destroyCounter){}
+
+				void operator=(Foo&& other)
+				{
+					destroyCounter = other.destroyCounter;
+					other.destroyCounter = nullptr;
+				}
+
+				Foo(Foo&& other)
+				{
+					operator=(std::move(other));
+				}
+
+				~Foo()
+				{
+					// Only count destructions of objects resident in Cache and not ones that happen right after moving out of
+					if (destroyCounter)
+						(*destroyCounter)++;
+				}
+			};
+
+			int destroyCounter = 0;
+			{
+				ResizableLRUCache<int, Foo> cache4(10u);
+				for (int i = 0; i < 10; i++)
+					cache4.insert(i, Foo(&destroyCounter));
+				int x = 0;
+			}
+			
+			assert(destroyCounter == 10);
+
+
+			m_logger->log("all good");
+
 			m_textureLRUCache = std::unique_ptr<TextureLRUCache>(new TextureLRUCache(1024u));
 			{
 				SIntendedSubmitInfo intendedNextSubmit = {};
@@ -142,11 +237,6 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 				TextureReference* inserted = m_textureLRUCache->insert(69420, nextSemaSignal.value, evictionCallback);
 			}
 
-		#ifdef _NBL_DEBUG
-			cache2.print(m_logger);
-		#endif
-			m_logger->log("all good");
-
 			constexpr uint32_t InvalidIdx = ~0u;
 			struct TextureReference
 			{
@@ -168,7 +258,7 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 				// In LRU Cache `insert` function, in case of cache hit, we need to assign semaphore value to TextureReference without changing `alloc_idx`
 				inline TextureReference& operator=(uint64_t semamphoreVal) { lastUsedSemaphoreValue = semamphoreVal; return *this;  }
 			};
-			using TextureLRUCache = LRUCache<uint32_t, TextureReference>;
+			using TextureLRUCache = ResizableLRUCache<uint32_t, TextureReference>;
 
 			TextureLRUCache textureCache = TextureLRUCache(3u);