.

Author: VReaperV

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

@@ -206,21 +206,20 @@ void TaskList::FinishDependency( const uint16 bufferID ) {
 	}
 }
 
-template<IsTask T>
-void TaskList::ResolveDependencies( Task& task, TaskInitList<T>& dependencies ) {
-	for ( const T* dep = dependencies.start; dep < dependencies.end; dep++ ) {
-		if ( !AddedToTaskMemory( ( *dep )->bufferID ) ) {
+void TaskList::ResolveDependencies( Task& task, TaskInitList& dependencies ) {
+	for ( const TaskProxy* dep = dependencies.start; dep < dependencies.end; dep++ ) {
+		if ( !AddedToTaskMemory( dep->task.bufferID ) ) {
 			Sys::Drop( "Tried to add task with an unallocated dependency" );
 		}
 
-		if ( IsTrackedDependency( ( *dep )->id ) ) {
+		if ( IsTrackedDependency( dep->task.id ) ) {
 			continue;
 		}
 
-		Task& dependency  = tasks[( *dep )->bufferID];
+		Task& dependency  = tasks[dep->task.bufferID];
 
 		// The dependency has already been executed, but the ringbuffer wrapped around
-		if ( dependency.gen > ( *dep )->gen ) {
+		if ( dependency.gen > dep->task.gen ) {
 			continue;
 		}
 
@@ -373,8 +372,7 @@ Task* TaskList::GetTaskMemory( Task& task ) {
 	return taskMemory;
 }
 
-template<IsTask T>
-void TaskList::AddTaskExt( Task& task, TaskInitList<T>&& dependencies ) {
+void TaskList::AddTaskExt( Task& task, TaskInitList&& dependencies ) {
 	if ( exiting.load( std::memory_order_relaxed ) && !task.IsShutdownTask() ) {
 		return;
 	}
@@ -411,25 +409,29 @@ void TaskList::AddTaskExt( Task& task, TaskInitList<T>&& dependencies ) {
 	TLM.addTimer.Stop();
 }
 
-template<IsTask T>
-void TaskList::MarkDependencies( Task& task, TaskInitList<T>&& dependencies ) {
+void TaskList::MarkDependencies( Task& task, TaskInitList&& dependencies ) {
 	Task* mainTask          = GetTaskMemory( task );
 	uint8 dependencyCounter = 0;
 
 	if ( IsUpdatedDependency( mainTask->id ) ) {
 		return;
 	}
 
-	for ( const T* dep = dependencies.start; dep < dependencies.end; dep++ ) {
-		if ( AddedToTaskList( ( *dep )->id ) ) {
+	if ( !dependencies.start ) {
+		mainTask->dependencyCounter.store( 0, std::memory_order_relaxed );
+		return;
+	}
+
+	for ( const TaskProxy* dep = dependencies.start; dep < dependencies.end; dep++ ) {
+		if ( AddedToTaskList( dep->task.id ) ) {
 			continue;
 		}
 
 		Task* taskMemory = GetTaskMemory( ( *dep ).GetTask() );
 
 		taskMemory->forwardTasks[GetForwardCounterFast( taskMemory->id )] = mainTask->bufferID;
 		IncrementForwardCounterFast( &taskMemory->id );
-		SetBit( &( *dep )->id, TASK_SHIFT_TRACKED_DEPENDENCY );
+		SetBit( &dep->task.id, TASK_SHIFT_TRACKED_DEPENDENCY );
 
 		dependencyCounter++;
 	}
@@ -445,9 +447,8 @@ void TaskList::MarkDependencies( Task& task, TaskInitList<T>&& dependencies ) {
 	SetBit( &task.id, TASK_SHIFT_UPDATED_DEPENDENCY );
 }
 
-template<IsTask T>
-void TaskList::UnMarkDependencies( TaskInitList<T>&& dependencies ) {
-	for ( const T* dep = dependencies.start; dep < dependencies.end; dep++ ) {
+void TaskList::UnMarkDependencies( TaskInitList&& dependencies ) {
+	for ( const TaskProxy* dep = dependencies.start; dep < dependencies.end; dep++ ) {
 		UnSetBit( &( *dep )->id, TASK_SHIFT_TRACKED_DEPENDENCY );
 		UnSetBit( &( *dep )->id, TASK_SHIFT_UPDATED_DEPENDENCY );
 	}
@@ -464,16 +465,16 @@ void TaskList::AddTask( Task& task, std::initializer_list<TaskProxy> dependencie
 	}
 
 	for ( const TaskProxy& dep : dependencies ) {
-		AddTaskExt( dep.task, TaskInitList<Task> {} );
+		AddTaskExt( dep.task );
 	}
 
-	UnMarkDependencies( TaskInitList{ dependencies.begin(), dependencies.end() } );
+	UnMarkDependencies( TaskInitList { dependencies.begin(), dependencies.end() } );
 }
 
-void TaskList::AddTasksExt( std::initializer_list<TaskInit> dependencies ) {
+void TaskList::AddTasksExt( std::initializer_list<TaskInitList> dependencies ) {
 	// TODO: Currently this is an O( 4 * n ) loop. The tasks form a DAG, which we can instead flatten in O( n ), then loop in O( n )
-	for ( const TaskInit& taskInit : dependencies ) {
-		MarkDependencies( taskInit.begin()[0].task, TaskInitList { &taskInit.begin()[1], taskInit.end() } );
+	for ( const TaskInitList& taskInit : dependencies ) {
+		MarkDependencies( taskInit.start->task, { taskInit.start + 1, taskInit.end } );
 	}
 
 	/* Tracked dependencies are those that we allocated in the AtomicRingBuffer during this function call.
@@ -482,17 +483,17 @@ void TaskList::AddTasksExt( std::initializer_list<TaskInit> dependencies ) {
 	Otherwise we could end up updating it after other threads have already finished all of the dependencies.
 	Flattening the DAG would get rid of the need to do this because we'd just add tasks starting from the end of the graph */
 
-	for ( const TaskInit& taskInit : dependencies ) {
-		for ( const TaskProxy* task = &taskInit.begin()[1]; task < taskInit.end(); task++ ) {
+	for ( const TaskInitList& taskInit : dependencies ) {
+		for ( const TaskProxy* task = taskInit.start + 1; task < taskInit.end; task++ ) {
 			if ( IsTrackedDependency( task->task.id ) ) {
 				Task* taskMemory = GetTaskMemory( task->task );
 				taskMemory->forwardTaskCounter.store( GetForwardCounterFast( taskMemory->id ), std::memory_order_relaxed );
 			}
 		}
 	}
 
-	for ( const TaskInit& taskInit : dependencies ) {
-		for ( const TaskProxy* task = &taskInit.begin()[1]; task < taskInit.end(); task++ ) {
+	for ( const TaskInitList& taskInit : dependencies ) {
+		for ( const TaskProxy* task = taskInit.start + 1; task < taskInit.end; task++ ) {
 			if ( !IsUpdatedDependency( task->task.id ) && !AddedToTaskList( task->task.id ) ) {
 				GetTaskMemory( task->task )->dependencyCounter.store( 0, std::memory_order_relaxed );
 			}
@@ -501,15 +502,15 @@ void TaskList::AddTasksExt( std::initializer_list<TaskInit> dependencies ) {
 			if ( time < task->task.time && task->task.time - time > eventQueue.minGranularity ) {
 				eventQueue.AddTask( task->task );
 			} else {
-				AddTaskExt( task->task, TaskInitList<Task> {} );
+				AddTaskExt( task->task );
 			}
 		}
 
-		AddTaskExt( taskInit.begin()[0].task, TaskInitList{ &taskInit.begin()[1], taskInit.end() } );
+		AddTaskExt( taskInit.start->task, { taskInit.start + 1, taskInit.end } );
 	}
 
-	for ( const TaskInit& taskInit : dependencies ) {
-		UnMarkDependencies( TaskInitList{ &taskInit.begin()[1], taskInit.end() } );
+	for ( const TaskInitList& taskInit : dependencies ) {
+		UnMarkDependencies( { taskInit.start + 1, taskInit.end } );
 	}
 }
 

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

@@ -47,26 +47,25 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using TaskInit = std::initializer_list<TaskProxy>;
 #define AddTasks( ... ) AddTasksExt( { __VA_ARGS__ } )
 
-template<typename T>
-concept IsTask = requires ( T value ) {
-	{ std::is_convertible<T, Task>::value || std::is_convertible<T, TaskProxy>::value };
-};
-
 // Use this for task dependencies because it allows natvis visualisation
-template<IsTask T>
 struct TaskInitList {
-	const T* start;
-	const T* end;
+	const TaskProxy* start;
+	const TaskProxy* end;
 
 	TaskInitList() :
 		start( nullptr ),
 		end( nullptr ) {
 	}
 
-	TaskInitList( const T* newStart, const T* newEnd ) :
+	TaskInitList( const TaskProxy* newStart, const TaskProxy* newEnd ) :
 		start( newStart ),
 		end( newEnd ) {
 	}
+
+	TaskInitList( std::initializer_list<TaskProxy> list ) :
+		start( list.begin() ),
+		end( list.end() ) {
+	}
 };
 
 struct ThreadQueue {
@@ -126,7 +125,7 @@ class TaskList :
 	byte* GetTaskData( const uint64 offset );
 
 	void  AddTask( Task& task, std::initializer_list<TaskProxy> dependencies = {} );
-	void  AddTasksExt( std::initializer_list<TaskInit> dependencies );
+	void  AddTasksExt( std::initializer_list<TaskInitList> dependencies );
 	Task* FetchTask( Thread* thread );
 
 	void  TaskWait( Task& task );
@@ -167,17 +166,12 @@ class TaskList :
 
 	Task* GetTaskMemory( Task& task );
 
-	template<IsTask T>
-	void  ResolveDependencies( Task& task, TaskInitList<T>& dependencies );
-
-	template<IsTask T>
-	void  AddTaskExt( Task& task, TaskInitList<T>&& dependencies );
+	void  ResolveDependencies( Task& task, TaskInitList& dependencies );
 
-	template<IsTask T>
-	void  MarkDependencies( Task& task, TaskInitList<T>&& dependencies );
+	void  AddTaskExt( Task& task, TaskInitList&& dependencies = {} );
 
-	template<IsTask T>
-	void  UnMarkDependencies( TaskInitList<T>&& dependencies );
+	void  MarkDependencies( Task& task, TaskInitList&& dependencies );
+	void  UnMarkDependencies( TaskInitList&& dependencies );
 };
 
 extern TaskList taskList;