Fix executingThreads and taskCount, add EventQueue.Shutdown()

Also disallow `Delay()` in shutdown tasks.

Author: VReaperV

src/engine/renderer-vulkan/Thread/EventQueue.cpp

@@ -134,4 +134,26 @@ void EventQueue::Rotate() {
 	}
 }
 
+void EventQueue::Shutdown() {
+	if ( exiting.load( std::memory_order_relaxed ) ) {
+		return;
+	}
+
+	uint32 count = 0;
+
+	for ( EventRing& eventRing : eventRings ) {
+		if ( eventRing.lock.LockWrite() ) {
+			for ( uint64 sector : eventRing.allocatedEvents ) {
+				count += CountBits( sector );
+			}
+
+			memset( eventRing.allocatedEvents, 0, EventRing::sectors * EventRing::sectorSize * sizeof( uint64 ) );
+
+			eventRing.lock.UnlockWrite();
+		}
+	}
+
+	exiting.store( true, std::memory_order_relaxed );
+}
+
 EventQueue eventQueue;

src/engine/renderer-vulkan/Thread/EventQueue.h

@@ -82,8 +82,12 @@ struct EventQueue {
 
 	const uint64 minGranularity = eventRings[0].granularity;
 
+	std::atomic<bool> exiting   = false;
+
 	void AddTask( Task& task );
 	void Rotate();
+
+	void Shutdown();
 };
 
 extern EventQueue eventQueue;

src/engine/renderer-vulkan/Thread/Task.cpp

@@ -48,7 +48,11 @@ Task::Task( const Task& other ) {
 }
 
 Task& Task::Delay( const uint64 delay ) {
-	time = TimeNs() + delay;
+	if ( shutdownTask ) {
+		Log::Warn( "Shutdown tasks may not be delayed! (task: %s, delay: %u)", Execute, delay );
+	} else {
+		time = TimeNs() + delay;
+	}
 
 	return *this;
 }

src/engine/renderer-vulkan/Thread/TaskList.cpp

@@ -263,6 +263,8 @@ void TaskList::AddToThreadQueueExt( Task& task ) {
 	if ( task.threadMask ) {
 		uint32 threadMask = task.threadMask;
 
+		taskCount.fetch_add( CountBits( threadMask ), std::memory_order_relaxed);
+
 		while ( threadMask ) {
 			const uint32 threadID = FindLSB( threadMask );
 			threadQueues[threadID].AddTask( threadID, task.bufferID );
@@ -273,6 +275,8 @@ void TaskList::AddToThreadQueueExt( Task& task ) {
 		return;
 	}
 
+	taskCount.fetch_add( 1, std::memory_order_relaxed );
+
 	const uint32 projectedTime = taskTime.time / std::max( taskTime.count, 1ull ) / 1000;
 
 	if ( projectedTime < TLM.addToQueueTimer.Time() / TLM.addToQueueCount && !TLM.main ) {
@@ -388,8 +392,6 @@ void TaskList::AddTask( Task& task, TaskInitList<T>&& dependencies ) {
 		AddToThreadQueue( *taskMemory );
 	}
 
-	taskCount.fetch_add( 1, std::memory_order_relaxed );
-
 	TLM.addTimer.Stop();
 }
 
@@ -494,10 +496,17 @@ Task* TaskList::FetchTask( Thread* thread, const bool longestTask ) {
 	threadQueue.tasks[current] = ThreadQueue::TASK_NONE;
 	threadQueue.current        = ( current + 1 ) % ThreadQueue::MAX_TASKS;
 
+	return &tasks[id];
+}
+
+void TaskList::TasksCleared( const uint32 count ) {
+	taskCount.fetch_sub( count, std::memory_order_relaxed );
+}
+
+void TaskList::TaskStarted() {
 	executingThreads.fetch_add( 1, std::memory_order_relaxed );
-	taskCount.fetch_sub( 1, std::memory_order_relaxed );
 
-	return &tasks[id];
+	taskCount.fetch_sub( 1, std::memory_order_relaxed );
 }
 
 bool TaskList::ThreadFinished( const bool hadTask ) {
@@ -506,6 +515,7 @@ bool TaskList::ThreadFinished( const bool hadTask ) {
 
 	if ( exit ) {
 		TLM.exitTimer.Start();
+		eventQueue.Shutdown();
 	}
 
 	if ( exit && !threadCount ) {

src/engine/renderer-vulkan/Thread/TaskList.h

@@ -129,6 +129,8 @@ class TaskList :
 	void AddTasksExt( std::initializer_list<TaskInit> dependencies );
 	Task* FetchTask( Thread* thread, const bool longestTask );
 
+	void TasksCleared( const uint32 count );
+	void TaskStarted();
 	bool ThreadFinished( const bool hadTask );
 
 	void FinishTask( Task* task );

src/engine/renderer-vulkan/Thread/Thread.cpp

@@ -124,6 +124,8 @@ void Thread::Run() {
 
 		Log::DebugTag( "id: %u: executing", id );
 
+		taskList.TaskStarted();
+
 		Timer t;
 		executing.Start();
 		task->Execute( task->data );