Merge branch 'master' of github.com:Devsh-Graphics-Programming/Nabla-Examples-and-Tests into vulkan_1_3_example_03_fix

Author: Przemog1

02_HelloCompute/main.cpp

@@ -120,7 +120,7 @@ class HelloComputeApp final : public nbl::application_templates::MonoSystemMonoL
 
 					// Yes we know workgroup sizes can come from specialization constants, however DXC has a problem with that https://github.com/microsoft/DirectXShaderCompiler/issues/3092
 					const string WorkgroupSizeAsStr = std::to_string(WorkgroupSize);
-					const IShaderCompiler::SPreprocessorOptions::SMacroDefinition WorkgroupSizeDefine = {"WORKGROUP_SIZE",WorkgroupSizeAsStr};
+					const IShaderCompiler::SMacroDefinition WorkgroupSizeDefine = {"WORKGROUP_SIZE",WorkgroupSizeAsStr};
 
 					CHLSLCompiler::SOptions options = {};
 					// really we should set it to `ESS_COMPUTE` since we know, but we'll test the `#pragma` handling fur teh lulz

07_StagingAndMultipleQueues/app_resources/comp_shader.hlsl

@@ -2,8 +2,7 @@
 
 #include "../app_resources/common.hlsl"
 
-[[vk::combinedImageSampler]][[vk::binding(0,0)]] Texture2D texture;
-[[vk::combinedImageSampler]][[vk::binding(0,0)]] SamplerState samplerState;
+[[vk::binding(0,0)]] Texture2D texture;
 [[vk::binding(1,0)]] RWStructuredBuffer<uint32_t> histogram;
 
 [[vk::push_constant]]
@@ -18,7 +17,7 @@ void main(uint32_t3 ID : SV_DispatchThreadID)
 	if(ID.x >= width || ID.y >= height)
 		return;
 
-    const float32_t4 texel = texture.SampleLevel(samplerState, ID.xy, 0.0);
+    const float32_t4 texel = texture.Load(int32_t3(ID.xy,/*miplevel*/0));
 
     const uint32_t redVal = uint32_t(texel.r * 255.f + 0.5f);
     const uint32_t greenVal = uint32_t(texel.g * 255.f + 0.5f);

07_StagingAndMultipleQueues/main.cpp

@@ -21,6 +21,7 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 	using device_base_t = application_templates::BasicMultiQueueApplication;
 	using asset_base_t = application_templates::MonoAssetManagerAndBuiltinResourceApplication;
 
+	// TODO: would be cool if we used `system::ISystem::listItemsInDirectory(sharedInputCWD/"GLI")` as our dataset
 	static constexpr std::array imagesToLoad = {
 		"../app_resources/test0.png",
 		"../app_resources/test1.png",
@@ -54,15 +55,17 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 		m_histogramSavedSemaphore = m_device->createSemaphore(TIMELINE_SEMAPHORE_STARTING_VALUE);
 
 		// TODO: create/initialize array of atomic pointers to IGPUImage* and IGPUBuffer* to hold results
-		// no need i think
 
+		// TODO: Change the capture start/end to become methods of IAPIConnection, because our current API is not how renderdoc works
+		getComputeQueue()->startCapture();
 		std::thread loadImagesThread(&StagingAndMultipleQueuesApp::loadImages, this);
 		std::thread saveHistogramsThread(&StagingAndMultipleQueuesApp::saveHistograms, this);
 
 		calculateHistograms();
 
 		loadImagesThread.join();
 		saveHistogramsThread.join();
+		getComputeQueue()->endCapture();
 
 		return true;
 	}
@@ -89,8 +92,8 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 
 private:
 	smart_refctd_ptr<ISemaphore> m_imagesLoadedSemaphore, m_imagesProcessedSemaphore, m_histogramSavedSemaphore;
-	std::atomic<uint32_t> m_imagesLoadedCnt, m_imagesProcessedCnt, m_imagesDownloadedCnt, m_imagesSavedCnt;
 	std::atomic<uint32_t> imageHandlesCreated = 0u;
+	std::atomic<uint32_t> transfersSubmitted = 0u;
 	std::array<core::smart_refctd_ptr<IGPUImage>, IMAGE_CNT> images;
 
 	static constexpr uint32_t FRAMES_IN_FLIGHT = 3u;
@@ -104,34 +107,37 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 
 	void loadImages()
 	{
+		const core::set<uint32_t> uniqueFamilyIndices = { getTransferUpQueue()->getFamilyIndex(), getComputeQueue()->getFamilyIndex() };
+		const std::vector<uint32_t> familyIndices(uniqueFamilyIndices.begin(),uniqueFamilyIndices.end());
+		const bool multipleQueueFamilies = familyIndices.size()>1;
+
 		IAssetLoader::SAssetLoadParams lp;
 		lp.logger = m_logger.get();
 
 		auto transferUpQueue = getTransferUpQueue();
-		const core::bitflag<IGPUCommandPool::CREATE_FLAGS> commandPoolFlags = IGPUCommandPool::CREATE_FLAGS::RESET_COMMAND_BUFFER_BIT;
 		std::array<core::smart_refctd_ptr<nbl::video::IGPUCommandPool>, FRAMES_IN_FLIGHT> commandPools;
 		std::array<core::smart_refctd_ptr<nbl::video::IGPUCommandBuffer>, FRAMES_IN_FLIGHT> commandBuffers;
 		std::fill(commandPools.begin(), commandPools.end(), nullptr);
 
 		core::smart_refctd_ptr<ICPUImage> cpuImages[IMAGE_CNT];
 		for (uint32_t i = 0u; i < FRAMES_IN_FLIGHT; ++i)
 		{
+			const core::bitflag<IGPUCommandPool::CREATE_FLAGS> commandPoolFlags = IGPUCommandPool::CREATE_FLAGS::RESET_COMMAND_BUFFER_BIT;
 			commandPools[i] = m_device->createCommandPool(transferUpQueue->getFamilyIndex(), commandPoolFlags);
 			commandPools[i]->createCommandBuffers(IGPUCommandPool::BUFFER_LEVEL::PRIMARY, {commandBuffers.data() + i, 1}, core::smart_refctd_ptr(m_logger));
+			commandBuffers[i]->setObjectDebugName(("Upload Command Buffer #"+std::to_string(i)).c_str());
 		}
 
 		core::smart_refctd_ptr<ISemaphore> imgFillSemaphore = m_device->createSemaphore(0);
-		IQueue::SSubmitInfo::SSemaphoreInfo imgFillSemaphoreInfo[] =
-		{
-			{
+		imgFillSemaphore->setObjectDebugName("Image Fill Semaphore");
+		SIntendedSubmitInfo intendedSubmit = {
+			.queue = transferUpQueue,
+			.waitSemaphores = {},
+			.commandBuffers = {}, // fill later
+			.scratchSemaphore = {
 				.semaphore = imgFillSemaphore.get(),
-				.value = 1,
+				.value = 0,
 				.stageMask = PIPELINE_STAGE_FLAGS::ALL_TRANSFER_BITS
-			},
-			{
-				.semaphore = m_imagesLoadedSemaphore.get(),
-				.value = 0xdeadbeef,
-				.stageMask = PIPELINE_STAGE_FLAGS::ALL_COMMANDS_BITS
 			}
 		};
 
@@ -162,13 +168,15 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 			imgParams.arrayLayers = 1u;
 			imgParams.samples = IImage::E_SAMPLE_COUNT_FLAGS::ESCF_1_BIT;
 			imgParams.usage = asset::IImage::EUF_TRANSFER_DST_BIT | asset::IImage::EUF_SAMPLED_BIT; 
-			// constexpr uint32_t FAMILY_INDICES_CNT = 3; // TODO: test on intel integrated GPU (which allows only one queue family)
-			std::array familyIndices = { getTransferUpQueue()->getFamilyIndex(), getComputeQueue()->getFamilyIndex() };
-			imgParams.queueFamilyIndexCount = familyIndices.size();
-			imgParams.queueFamilyIndices = familyIndices.data();
+			if (multipleQueueFamilies)
+			{
+				imgParams.queueFamilyIndexCount = familyIndices.size();
+				imgParams.queueFamilyIndices = familyIndices.data();
+			}
 			imgParams.preinitialized = false;
 
 			images[imageIdx] = m_device->createImage(std::move(imgParams));
+			images[imageIdx]->setObjectDebugName(("Image #"+std::to_string(imageIdx)).c_str());
 			auto imageAllocation = m_device->allocate(images[imageIdx]->getMemoryReqs(), images[imageIdx].get(), IDeviceMemoryAllocation::EMAF_NONE);
 			imageHandlesCreated++;
 			imageHandlesCreated.notify_one();
@@ -206,13 +214,7 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 			}
 
 			IQueue::SSubmitInfo::SCommandBufferInfo imgFillCmdBuffInfo = { cmdBuff.get() };
-			
-			imgFillSemaphoreInfo[1].value = imageIdx + 1u;
-
-
-			SIntendedSubmitInfo intendedSubmit = {
-				.frontHalf = {.queue = transferUpQueue, .waitSemaphores = {}, .commandBuffers = {&imgFillCmdBuffInfo, 1}}, .signalSemaphores = imgFillSemaphoreInfo
-			};
+			intendedSubmit.commandBuffers = {&imgFillCmdBuffInfo,1};
 
 			cmdBuff->begin(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT);
 
@@ -221,18 +223,17 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 			if (!cmdBuff->pipelineBarrier(E_DEPENDENCY_FLAGS::EDF_NONE, pplnBarrierDepInfo0))
 				logFailAndTerminate("Failed to issue barrier!\n");
 
-
-			transferUpQueue->startCapture();
-			uint64_t oldCntr = imgFillSemaphoreInfo[0].value;
+			const uint64_t oldCntr = intendedSubmit.scratchSemaphore.value;
 			const bool uploadCommendRecorded = m_utils->updateImageViaStagingBuffer(
 				intendedSubmit, cpuImages[imageIdx]->getBuffer(), cpuImages[imageIdx]->getCreationParameters().format,
 				images[imageIdx].get(), IImage::LAYOUT::TRANSFER_DST_OPTIMAL, cpuImages[imageIdx]->getRegions()
 			);
 			if (!uploadCommendRecorded)
 				logFailAndTerminate("Couldn't update image data.\n");
 
-			if(imgFillSemaphoreInfo[0].value != oldCntr)
-				m_logger->log("%d overflows when uploading image %d!\n", ILogger::ELL_PERFORMANCE, imgFillSemaphoreInfo[0].value - oldCntr, imageIdx);
+			const auto newCntr = intendedSubmit.scratchSemaphore.value;
+			if (newCntr!=oldCntr)
+				m_logger->log("%d overflows when uploading image %d!\n", ILogger::ELL_PERFORMANCE, newCntr-oldCntr, imageIdx);
 
 			IGPUCommandBuffer::SPipelineBarrierDependencyInfo pplnBarrierDepInfo1;
 			pplnBarrierDepInfo1.imgBarriers = { &imageLayoutTransitionBarrier1, 1 };
@@ -242,10 +243,15 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 
 			cmdBuff->end();
 
-			intendedSubmit.advanceScratchSemaphoreValue();
-			IQueue::SSubmitInfo submitInfo[1] = { intendedSubmit };
-			getTransferUpQueue()->submit(submitInfo);
-			transferUpQueue->endCapture();
+			const IQueue::SSubmitInfo::SSemaphoreInfo signalSemaphore = {
+				.semaphore=m_imagesLoadedSemaphore.get(),
+				.value=imageIdx+1u,
+				// cannot signal from COPY stage because there's a layout transition we need to wait for right after and it doesn't have an explicit stage
+				.stageMask=PIPELINE_STAGE_FLAGS::ALL_COMMANDS_BITS
+			};
+			getTransferUpQueue()->submit(intendedSubmit.popSubmit({&signalSemaphore,1}));
+			transfersSubmitted++;
+			transfersSubmitted.notify_one();
 
 
 			// TODO: this is for basic testing purposes, will be deleted ofc
@@ -259,44 +265,48 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 	{
 		// INITIALIZE COMMON DATA
 		auto computeQueue = getComputeQueue();
-		const core::bitflag<IGPUCommandPool::CREATE_FLAGS> commandPoolFlags = static_cast<IGPUCommandPool::CREATE_FLAGS>(IGPUCommandPool::CREATE_FLAGS::NONE);
-		std::array<core::smart_refctd_ptr<nbl::video::IGPUCommandPool>, FRAMES_IN_FLIGHT> commandPools;
-		std::array<core::smart_refctd_ptr<nbl::video::IGPUCommandBuffer>, FRAMES_IN_FLIGHT> commandBuffers;
+
+		smart_refctd_ptr<IGPUDescriptorSetLayout> dsLayout;
 		core::smart_refctd_ptr<IGPUDescriptorSet> descSets[FRAMES_IN_FLIGHT];
-		std::fill(commandPools.begin(), commandPools.end(), nullptr);
-		nbl::video::IGPUDescriptorSetLayout::SBinding bindings[2] = {
-			{
-				.binding = 0,
-				.type = nbl::asset::IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER,
-				.createFlags = IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
-				.stageFlags = IGPUShader::E_SHADER_STAGE::ESS_COMPUTE,
-				.count = 1,
-				.samplers = nullptr
-			},
+		{
+			nbl::video::IGPUDescriptorSetLayout::SBinding bindings[2] = {
+				{
+					.binding = 0,
+					.type = nbl::asset::IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER, // TODO: just an image descriptor type when separable samplers arrive
+					.createFlags = IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
+					.stageFlags = IGPUShader::E_SHADER_STAGE::ESS_COMPUTE,
+					.count = 1,
+					.samplers = nullptr
+				},
+				{
+					.binding = 1,
+					.type = nbl::asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER,
+					.createFlags = IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
+					.stageFlags = IGPUShader::E_SHADER_STAGE::ESS_COMPUTE,
+					.count = 1,
+					.samplers = nullptr
+				}
+			};
+
+			dsLayout = m_device->createDescriptorSetLayout(bindings);
+			if (!dsLayout)
+				logFailAndTerminate("Failed to create a Descriptor Layout!\n");
+			auto descPool = m_device->createDescriptorPoolForDSLayouts(IDescriptorPool::ECF_NONE, { &dsLayout.get(),1 }, &FRAMES_IN_FLIGHT);
+			for (uint32_t i = 0u; i < FRAMES_IN_FLIGHT; ++i)
 			{
-				.binding = 1,
-				.type = nbl::asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER,
-				.createFlags = IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
-				.stageFlags = IGPUShader::E_SHADER_STAGE::ESS_COMPUTE,
-				.count = 1,
-				.samplers = nullptr
+				descSets[i] = descPool->createDescriptorSet(core::smart_refctd_ptr(dsLayout));
+				descSets[i]->setObjectDebugName(("Descriptor Set #" + std::to_string(i)).c_str());
 			}
-		};
-		smart_refctd_ptr<IGPUDescriptorSetLayout> dsLayout[1] = { m_device->createDescriptorSetLayout(bindings) };
-		if (!dsLayout[0])
-			logFailAndTerminate("Failed to create a Descriptor Layout!\n");
-		smart_refctd_ptr<nbl::video::IDescriptorPool> descPools[FRAMES_IN_FLIGHT] = { // TODO: only one desc pool?
-			m_device->createDescriptorPoolForDSLayouts(IDescriptorPool::ECF_NONE, {&dsLayout[0].get(), 1}),
-			m_device->createDescriptorPoolForDSLayouts(IDescriptorPool::ECF_NONE, {&dsLayout[0].get(), 1}),
-			m_device->createDescriptorPoolForDSLayouts(IDescriptorPool::ECF_NONE, {&dsLayout[0].get(), 1})
-		};
+		}
 
+		std::array<core::smart_refctd_ptr<nbl::video::IGPUCommandPool>, FRAMES_IN_FLIGHT> commandPools;
+		std::array<core::smart_refctd_ptr<nbl::video::IGPUCommandBuffer>, FRAMES_IN_FLIGHT> commandBuffers;
 		for (uint32_t i = 0u; i < FRAMES_IN_FLIGHT; ++i)
 		{
+			const core::bitflag<IGPUCommandPool::CREATE_FLAGS> commandPoolFlags = IGPUCommandPool::CREATE_FLAGS::NONE;
 			commandPools[i] = m_device->createCommandPool(getComputeQueue()->getFamilyIndex(), commandPoolFlags);
 			commandPools[i]->createCommandBuffers(IGPUCommandPool::BUFFER_LEVEL::PRIMARY, {commandBuffers.data() + i, 1}, core::smart_refctd_ptr(m_logger));
-			
-			descSets[i] = descPools[i]->createDescriptorSet(core::smart_refctd_ptr(dsLayout[0]));
+			commandBuffers[i]->setObjectDebugName(("Histogram Command Buffer #" + std::to_string(i)).c_str());
 		}
 
 		// LOAD SHADER FROM FILE
@@ -320,7 +330,7 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 		pc[0].size = sizeof(PushConstants);
 
 		smart_refctd_ptr<nbl::video::IGPUComputePipeline> pipeline;
-		smart_refctd_ptr<IGPUPipelineLayout> pplnLayout = m_device->createPipelineLayout(pc, smart_refctd_ptr(dsLayout[0]));
+		smart_refctd_ptr<IGPUPipelineLayout> pplnLayout = m_device->createPipelineLayout(pc,std::move(dsLayout));
 		{
 			// Nabla actually has facilities for SPIR-V Reflection and "guessing" pipeline layouts for a given SPIR-V which we'll cover in a different example
 			if (!pplnLayout)
@@ -369,6 +379,7 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 			m_histogramBufferMemPtrs[2] = m_histogramBufferMemPtrs[1] + HISTOGRAM_SIZE;
 		}
 
+		// TODO: will no longer be necessary after separable samplers and images
 		IGPUSampler::SParams samplerParams;
 		samplerParams.AnisotropicFilter = false;
 		core::smart_refctd_ptr<IGPUSampler> sampler = m_device->createSampler(samplerParams);
@@ -409,17 +420,18 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 			params.subresourceRange.aspectMask = IImage::E_ASPECT_FLAGS::EAF_COLOR_BIT;
 			params.subresourceRange.layerCount = images[imageToProcessId]->getCreationParameters().arrayLayers;
 
-			imgInfo.desc = m_device->createImageView(std::move(params));
-			if (!imgInfo.desc)
+			auto view = m_device->createImageView(std::move(params));
+			if (!view)
 				logFailAndTerminate("Couldn't create descriptor.");
+			view->setObjectDebugName(("Image View #"+std::to_string(imageToProcessId)).c_str());
+			imgInfo.desc = std::move(view);
 			imgInfo.info.image = { .sampler = sampler, .imageLayout = IImage::LAYOUT::READ_ONLY_OPTIMAL };
 
 			IGPUDescriptorSet::SWriteDescriptorSet write[1] = {
 				{.dstSet = descSets[resourceIdx].get(), .binding = 0, .arrayElement = 0, .count = 1, .info = &imgInfo }
 			};
 			m_device->updateDescriptorSets(1, write, 0u, nullptr);
 
-			computeQueue->startCapture();
 			cmdBuff->begin(IGPUCommandBuffer::USAGE::NONE);
 			cmdBuff->beginDebugMarker("My Compute Dispatch", core::vectorSIMDf(0, 1, 0, 1));
 			cmdBuff->bindComputePipeline(pipeline.get());
@@ -450,8 +462,14 @@ class StagingAndMultipleQueuesApp final : public application_templates::BasicMul
 			submitInfo[0].commandBuffers = cmdBuffSubmitInfo;
 			submitInfo[0].signalSemaphores = signalSemaphoreSubmitInfo;
 			submitInfo[0].waitSemaphores = {waitSemaphoreSubmitInfo, imageToProcessId < FRAMES_IN_FLIGHT ? 1u : 2u};
+			// Some Devices like all of the Intel GPUs do not have enough queues for us to allocate different queues to compute and transfers,
+			// so our `BasicMultiQueueApplication` will "alias" a single queue to both usages. Normally you don't need to care, but here we're
+			// attempting to do "out-of-order" "submit-before-signal" so we need to "hold back" submissions if the queues are aliased!
+			// TODO: Renderdoc freezes because it starts capturing immediately upon a submit and can't defer a capture till semaphores signal.
+			if (getTransferUpQueue()==computeQueue /*|| m_api->isRunningInRenderdoc()*/)
+			for (auto old = transfersSubmitted.load(); old <= imageToProcessId; old = transfersSubmitted.load())
+				transfersSubmitted.wait(old);
 			computeQueue->submit(submitInfo);
-			computeQueue->endCapture();
 			std::string msg = std::string("Image nr ") + std::to_string(imageToProcessId) + " processed. Resource idx: " + std::to_string(resourceIdx);
 			m_logger->log(msg);
 		}

21_LRUCacheUnitTest/main.cpp

@@ -41,13 +41,21 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 			cache.insert(11, 'd');
 			cache.insert(12, 'e');
 			cache.insert(13, 'f');
-
+			cache.print(m_logger);
+			m_logger->log("We're Referencing `10:c`");
+			char returned = *(cache.get(10));
+			cache.print(m_logger);
+			m_logger->log("We're erasing `11:d`");
+			cache.erase(11);
+			assert(cache.get(11) == nullptr);
+			cache.print(m_logger);
+			m_logger->log("We're adding `11:d` again");
+			cache.insert(11, 'd');
 			cache.print(m_logger);
 
-			char returned = *(cache.get(11));
-			assert(returned == 'd');
-			returned = *(cache.get(10));
 			assert(returned == 'c');
+			returned = *(cache.get(11));
+			assert(returned == 'd');
 			returned = *(cache.get(13));
 			assert(returned == 'f');
 
@@ -105,6 +113,44 @@ class LRUCacheTestApp final : public nbl::application_templates::MonoSystemMonoL
 		#endif
 			m_logger->log("all good");
 
+			constexpr uint32_t InvalidIdx = ~0u;
+			struct TextureReference
+			{
+				uint32_t alloc_idx;
+				uint64_t lastUsedSemaphoreValue;
+
+				// copy ctor
+				TextureReference(const TextureReference& tref)
+				{
+					assert(false); // based on the code in this test, copy constuctor shouldn't be called
+				}
+				TextureReference(TextureReference&& tref) = default;
+				inline TextureReference& operator=(TextureReference&& tref) = default;
+
+				TextureReference(uint32_t alloc_idx, uint64_t semaphoreVal) : alloc_idx(alloc_idx), lastUsedSemaphoreValue(semaphoreVal) {}
+				TextureReference(uint64_t semaphoreVal) : TextureReference(InvalidIdx, semaphoreVal) {}
+				TextureReference() : TextureReference(InvalidIdx, ~0ull) {}
+
+				// 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>;
+
+			TextureLRUCache textureCache = TextureLRUCache(3u);
+
+			static_assert(std::is_assignable_v<TextureReference, uint64_t>);
+			static_assert(std::is_constructible_v<TextureReference, uint64_t>);
+
+			textureCache.insert(91u, TextureReference{ ~0u, 69u });
+			textureCache.insert(92u, TextureReference{ 20u, 70u });
+			textureCache.insert(93u, TextureReference{ 10u, 71u });
+			auto t = textureCache.get(91u);
+			assert(t->lastUsedSemaphoreValue == 69u); // make 91 jump to front, now 92 is the LRU
+			// next insertion will evict because capacity is 3
+			auto insertion = textureCache.insert(99u, 6999ull, [](const TextureReference& evictedTextureRef) -> void { assert(evictedTextureRef.alloc_idx == 20u); });
+			assert(insertion->alloc_idx == InvalidIdx);
+			assert(insertion->lastUsedSemaphoreValue == 6999ull);
+
 			return true;
 		}