Remove some junk from the AsyncLoader. Can't remember why that was there in the 1st place

AnKi/Core/App.cpp

@@ -477,9 +477,6 @@ Error App::mainLoop()
 			TexturePtr presentableTex = GrManager::getSingleton().acquireNextPresentableTexture();
 			ANKI_CHECK(MainRenderer::getSingleton().render(rqueue, presentableTex.get()));
 
-			// Pause and sync async loader. That will force all tasks before the pause to finish in this frame.
-			ResourceManager::getSingleton().getAsyncLoader().pause();
-
 			// If we get stats exclude the time of GR because it forces some GPU-CPU serialization. We don't want to
 			// count that
 			Second grTime = 0.0;
@@ -501,14 +498,6 @@ Error App::mainLoop()
 			GpuVisibleTransientMemoryPool::getSingleton().endFrame();
 			GpuReadbackMemoryPool::getSingleton().endFrame();
 
-			// Update the trace info with some async loader stats
-			U64 asyncTaskCount = ResourceManager::getSingleton().getAsyncLoader().getCompletedTaskCount();
-			ANKI_TRACE_INC_COUNTER(RsrcAsyncTasks, asyncTaskCount - m_resourceCompletedAsyncTaskCount);
-			m_resourceCompletedAsyncTaskCount = asyncTaskCount;
-
-			// Now resume the loader
-			ResourceManager::getSingleton().getAsyncLoader().resume();
-
 			// Sleep
 			const Second endTime = HighRezTimer::getCurrentTime();
 			const Second frameTime = endTime - startTime;

AnKi/Core/App.h

@@ -71,7 +71,6 @@ private:
 	Bool m_consoleEnabled = false;
 	CoreString m_settingsDir; ///< The path that holds the configuration
 	CoreString m_cacheDir; ///< This is used as a cache
-	U64 m_resourceCompletedAsyncTaskCount = 0;
 
 	void* m_originalAllocUserData = nullptr;
 	AllocAlignedCallback m_originalAllocCallback = nullptr;

AnKi/Gr/Vulkan/CommandBufferFactory.cpp

@@ -68,8 +68,7 @@ Error CommandBufferThreadAllocator::init()
 			continue;
 		}
 
-		VkCommandPoolCreateInfo ci = {};
-		ci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+		VkCommandPoolCreateInfo ci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
 		ci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
 		ci.queueFamilyIndex = m_factory->m_queueFamilies[qtype];
 

AnKi/Renderer/Renderer.cpp

@@ -341,19 +341,6 @@ Error Renderer::populateRenderGraph(RenderingContext& ctx)
 
 	ctx.m_matrices.m_unprojectionParameters = ctx.m_matrices.m_projection.extractPerspectiveUnprojectionParams();
 
-	// Check if resources got loaded
-	if(m_prevLoadRequestCount != ResourceManager::getSingleton().getLoadingRequestCount()
-	   || m_prevAsyncTasksCompleted != ResourceManager::getSingleton().getAsyncTaskCompletedCount())
-	{
-		m_prevLoadRequestCount = ResourceManager::getSingleton().getLoadingRequestCount();
-		m_prevAsyncTasksCompleted = ResourceManager::getSingleton().getAsyncTaskCompletedCount();
-		m_resourcesDirty = true;
-	}
-	else
-	{
-		m_resourcesDirty = false;
-	}
-
 	// Import RTs first
 	m_downscaleBlur->importRenderTargets(ctx);
 	m_tonemapping->importRenderTargets(ctx);

AnKi/Renderer/Renderer.h

@@ -126,12 +126,6 @@ public:
 	[[nodiscard]] TexturePtr createAndClearRenderTarget(const TextureInitInfo& inf, TextureUsageBit initialUsage,
 														const ClearValue& clearVal = ClearValue());
 
-	/// Returns true if there were resources loaded or loading async tasks that got completed.
-	Bool resourcesLoaded() const
-	{
-		return m_resourcesDirty;
-	}
-
 	TextureView& getDummyTextureView2d() const
 	{
 		return *m_dummyTexView2d;
@@ -217,10 +211,6 @@ private:
 
 	U64 m_frameCount; ///< Frame number
 
-	U64 m_prevLoadRequestCount = 0;
-	U64 m_prevAsyncTasksCompleted = 0;
-	Bool m_resourcesDirty = true;
-
 	CommonMatrices m_prevMatrices;
 
 	Array<Vec2, 64> m_jitterOffsets;

AnKi/Resource/AsyncLoader.cpp

@@ -4,11 +4,14 @@
 // http://www.anki3d.org/LICENSE
 
 #include <AnKi/Resource/AsyncLoader.h>
+#include <AnKi/Core/StatsSet.h>
 #include <AnKi/Util/Logger.h>
 #include <AnKi/Util/Tracer.h>
 
 namespace anki {
 
+static StatCounter g_asyncTasksInFlightStatVar(StatCategory::kMisc, "Async loader tasks", StatFlag::kThreadSafe);
+
 AsyncLoader::AsyncLoader()
 	: m_thread("AsyncLoad")
 {
@@ -43,25 +46,6 @@ void AsyncLoader::stop()
 	[[maybe_unused]] Error err = m_thread.join();
 }
 
-void AsyncLoader::pause()
-{
-	{
-		LockGuard<Mutex> lock(m_mtx);
-		m_paused = true;
-		m_sync = true;
-		m_condVar.notifyOne();
-	}
-
-	m_barrier.wait();
-}
-
-void AsyncLoader::resume()
-{
-	LockGuard<Mutex> lock(m_mtx);
-	m_paused = false;
-	m_condVar.notifyOne();
-}
-
 Error AsyncLoader::threadCallback(ThreadCallbackInfo& info)
 {
 	AsyncLoader& self = *reinterpret_cast<AsyncLoader*>(info.m_userData);
@@ -76,12 +60,11 @@ Error AsyncLoader::threadWorker()
 	{
 		AsyncLoaderTask* task = nullptr;
 		Bool quit = false;
-		Bool sync = false;
 
 		{
 			// Wait for something
 			LockGuard<Mutex> lock(m_mtx);
-			while((m_taskQueue.isEmpty() || m_paused) && !m_quit && !m_sync)
+			while(m_taskQueue.isEmpty() && !m_quit)
 			{
 				m_condVar.wait(m_mtx);
 			}
@@ -91,11 +74,6 @@ Error AsyncLoader::threadWorker()
 			{
 				quit = true;
 			}
-			else if(m_sync)
-			{
-				sync = true;
-				m_sync = false;
-			}
 			else
 			{
 				task = &m_taskQueue.getFront();
@@ -107,10 +85,6 @@ Error AsyncLoader::threadWorker()
 		{
 			break;
 		}
-		else if(sync)
-		{
-			m_barrier.wait();
-		}
 		else
 		{
 			// Exec the task
@@ -120,11 +94,12 @@ Error AsyncLoader::threadWorker()
 			{
 				ANKI_TRACE_SCOPED_EVENT(RsrcAsyncTask);
 				err = (*task)(ctx);
+				g_asyncTasksInFlightStatVar.atomicDecrement(1);
 			}
 
 			if(!err)
 			{
-				m_completedTaskCount.fetchAdd(1);
+				m_tasksInFlightCount.fetchSub(1);
 			}
 			else
 			{
@@ -142,12 +117,6 @@ Error AsyncLoader::threadWorker()
 				// Delete the task
 				deleteInstance(ResourceMemoryPool::getSingleton(), task);
 			}
-
-			if(ctx.m_pause)
-			{
-				LockGuard<Mutex> lock(m_mtx);
-				m_paused = true;
-			}
 		}
 	}
 
@@ -158,15 +127,12 @@ void AsyncLoader::submitTask(AsyncLoaderTask* task)
 {
 	ANKI_ASSERT(task);
 
-	// Append task to the list
+	m_tasksInFlightCount.fetchAdd(1);
+	g_asyncTasksInFlightStatVar.atomicIncrement(1);
+
 	LockGuard<Mutex> lock(m_mtx);
 	m_taskQueue.pushBack(task);
-
-	if(!m_paused)
-	{
-		// Wake up the thread if it's not paused
-		m_condVar.notifyOne();
-	}
+	m_condVar.notifyOne();
 }
 
 } // end namespace anki

AnKi/Resource/AsyncLoader.h

@@ -20,9 +20,6 @@ class AsyncLoader;
 class AsyncLoaderTaskContext
 {
 public:
-	/// Pause the async loader.
-	Bool m_pause = false;
-
 	/// Resubmit the same task at the end of the queue.
 	Bool m_resubmitTask = false;
 };
@@ -63,17 +60,10 @@ public:
 		submitTask(newTask<TTask>(std::forward<TArgs>(args)...));
 	}
 
-	/// Pause the loader. This method will block the caller for the current async task to finish. The rest of the
-	/// tasks in the queue will not be executed until resume is called.
-	void pause();
-
-	/// Resume the async loading.
-	void resume();
-
 	/// Get the total number of completed tasks.
-	U64 getCompletedTaskCount() const
+	U32 getTasksInFlightCount() const
 	{
-		return m_completedTaskCount.load();
+		return m_tasksInFlightCount.load();
 	}
 
 private:
@@ -84,10 +74,8 @@ private:
 	ConditionVariable m_condVar;
 	IntrusiveList<AsyncLoaderTask> m_taskQueue;
 	Bool m_quit = false;
-	Bool m_paused = false;
-	Bool m_sync = false;
 
-	Atomic<U64> m_completedTaskCount = {0};
+	Atomic<U32> m_tasksInFlightCount = {0};
 
 	/// Thread callback
 	static Error threadCallback(ThreadCallbackInfo& info);

AnKi/Resource/ResourceManager.cpp

@@ -66,18 +66,12 @@ Error ResourceManager::init(AllocAlignedCallback allocCallback, void* allocCallb
 	return Error::kNone;
 }
 
-U64 ResourceManager::getAsyncTaskCompletedCount() const
-{
-	return m_asyncLoader->getCompletedTaskCount();
-}
-
 template<typename T>
 Error ResourceManager::loadResource(const CString& filename, ResourcePtr<T>& out, Bool async)
 {
 	ANKI_ASSERT(!out.isCreated() && "Already loaded");
 
 	Error err = Error::kNone;
-	++m_loadRequestCount;
 
 	T* const other = findLoadedResource<T>(filename);
 

AnKi/Resource/ResourceManager.h

@@ -138,12 +138,6 @@ public:
 		return *m_asyncLoader;
 	}
 
-	/// Get the number of times loadResource() was called.
-	ANKI_INTERNAL U64 getLoadingRequestCount() const
-	{
-		return m_loadRequestCount;
-	}
-
 	/// Get the total number of completed async tasks.
 	ANKI_INTERNAL U64 getAsyncTaskCompletedCount() const;
 
@@ -165,7 +159,6 @@ private:
 	TransferGpuAllocator* m_transferGpuAlloc = nullptr;
 
 	U64 m_uuid = 0;
-	U64 m_loadRequestCount = 0;
 
 	ResourceManager();
 

Tests/Resource/AsyncLoader.cpp

@@ -13,6 +13,7 @@ using namespace anki;
 
 namespace {
 
+#if 0
 class Task : public AsyncLoaderTask
 {
 public:
@@ -262,4 +263,6 @@ ANKI_TEST(Resource, AsyncLoader)
 		barrier.wait();
 		ANKI_TEST_EXPECT_EQ(counter.load(), 10);
 	}
-}
+#endif
+
+} // namespace