Refactor Task

Author: VReaperV

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

@@ -28,33 +28,5 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 =============================================================================
 */
 
-#include "../SrcDebug/Tag.h"
-#include "../Error.h"
-
 #include "Memory.h"
 
-MALLOC_LIKE void* AllocAligned( const uint64 size, const uint64 alignment ) {
-	if ( !size ) {
-		return nullptr;
-	}
-
-	ASSERT_EQ( ( alignment & ( alignment - 1 ) ), 0 );
-
-	const uint64 paddedSize = ( size + alignment - 1 ) & ~( alignment - 1 );
-
-	void* ret = Com_Allocate_Aligned( alignment, paddedSize );
-	if ( !ret ) {
-		Err( "AllocAligned: failed: memory allocation returned nullptr (size: %u, alignment: %u)",
-			paddedSize, alignment );
-	}
-
-	return ret;
-}
-
-void FreeAligned( void* memory ) {
-	if ( !memory ) {
-		Log::WarnTag( "Freeing nullptr" );
-	}
-
-	Com_Free_Aligned( memory );
-}

src/engine/renderer-vulkan/Memory/Memory.h

@@ -35,11 +35,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../Math/NumberTypes.h"
 
-MALLOC_LIKE void* AllocAligned( const uint64 size, const uint64 alignment );
-void              FreeAligned( void* memory );
+template<typename T>
+byte* CopyAligned( byte* memory, const T& value ) {
+	const uint64 alignment = alignof( T );
 
-inline void* Alloc64( const uint64 size ) {
-	return AllocAligned( size, 64 );
+	memory                 = ( byte* ) PAD( ( uint64 ) memory, alignment );
+	*( ( T* ) memory )     = value;
+
+	return memory + sizeof( T );
 }
 
 #endif // MEMORY_H

src/engine/renderer-vulkan/Memory/RingBuffer.h

@@ -195,13 +195,13 @@ class AtomicRingBuffer :
 			element &= mask;
 		} else {
 			element &= mask;
-			while ( memory[element].active ) {
+			while ( memory[element].IsActive() ) {
 				std::this_thread::yield();
 				Log::DebugTag( "Yielding" );
 
 			}
 
-			memory[element].active = true;
+			memory[element].SetActive( true );
 		}
 
 		return &memory[element];

src/engine/renderer-vulkan/RefAPI.cpp

@@ -174,7 +174,7 @@ namespace TempAPI {
 		);
 
 		static int cnt = 30;
-		Task task20{ &TestRecursive, &cnt };
+		Task task20{ &TestRecursive, cnt };
 		taskList.AddTask( task20 );
 
 		return true;

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

@@ -70,7 +70,7 @@ class GlobalMemory : public Allocator {
 	public:
 	DynamicArray<ChunkAllocator> chunkAllocators[MAX_MEMORY_AREAS] { { &sysAllocator }, { &sysAllocator }, { &sysAllocator } };
 
-	std::unordered_map<Task::TaskFunction, GlobalTaskTime> taskTimes;
+	std::unordered_map<TaskFunction, GlobalTaskTime> taskTimes;
 	AccessLock                                             taskTimesLock;
 
 	void         Init();

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

@@ -28,11 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 =============================================================================
 */
 
-#include "../Math/Bit.h"
+#include <algorithm>
 
-#include "ThreadMemory.h"
+#include "../Math/Bit.h"
 
 #include "TaskList.h"
+#include "ThreadMemory.h"
 
 #include "Task.h"
 
@@ -45,6 +46,18 @@ Task::Task( const Task& other ) {
 	*this = other;
 }
 
+const Task& Task::operator*() {
+	return *this;
+}
+
+const Task* Task::operator->() const {
+	return this;
+}
+
+constexpr Task& Task::GetTask() {
+	return *this;
+}
+
 Task& Task::Delay( const uint64 delay ) {
 	if ( IsShutdownTask() ) {
 		Log::Warn( "Shutdown tasks may not be delayed! (task: %s, delay: %u)", Execute, delay );
@@ -84,45 +97,131 @@ void Task::Wait() {
 	}
 }
 
+void Task::ExecuteDestructors() {
+	uint8  destructors = argsMap & 255;
+	uint32 offset      = 0;
+
+	while ( destructors ) {
+		DestructorFunction destructor = *( DestructorFunction* ) ( taskList.GetTaskData( GetDataOffset() ) + offset );
+
+		uint32             arg        = FindLSB( destructors );
+		destructor( GetArgMemory( arg ) );
+
+		offset                       += sizeof( DestructorFunction );
+		UnSetBit( &destructors, arg );
+	}
+}
+
 bool Task::IsValid() {
-	return BitSet( flags, validOffset );
+	return BitSet(  flags,  validOffset );
+}
+
+bool Task::IsActive() {
+	return BitSet(  flags,  activeOffset );
 }
 
 bool Task::IsShutdownTask() {
-	return BitSet( flags, shutdownOffset );
+	return BitSet(  flags,  shutdownOffset );
+}
+
+uint8 Task::GetArgCount() {
+	return GetBits( flags, argCountOffset, 3 );
+}
+
+void Task::SetValid(  const bool valid ) {
+	valid  ? SetBit( &flags, validOffset )  : UnSetBit( &flags, validOffset );
+}
+
+void Task::SetActive( const bool active ) {
+	active ? SetBit( &flags, activeOffset ) : UnSetBit( &flags, activeOffset );
+}
+
+uint32 Task::RemapArg( const uint32 arg ) {
+	return GetBits( argsMap, arg * argMapArgSize + argMapArgOffset, argMapArgSize );
+}
+
+uint64 Task::GetDataOffset() {
+	return SetBits( ( uint64 ) dataOffset, ( uint64 ) dataOffset2, 32, 8 );
+}
+
+uint32 Task::SetArgsMap( Arg* start, Arg* end ) {
+	uint32 size = 0;
+
+	for ( Arg* arg = start; arg < end; arg++ ) {
+		if ( arg > start ) {
+			dataOffsets[arg - start] = size;
+		}
+
+		size = PAD( size, arg->size > 8 ? 8 : arg->size ) + arg->size;
+		SetBits( &argsMap, arg - start, arg->id * argMapArgSize + argMapArgOffset, argMapArgSize );
+
+		if ( arg->hasDestructor ) {
+			SetBit( &argsMap, arg->id );
+		};
+	}
+
+	SetBits( &flags, end - start, argCountOffset, 3 );
+
+	return CountBits( argsMap & argMapMask ) * sizeof( DestructorFunction ) + PAD( size, 8 );
+}
+
+byte* Task::InitMemory( Arg* start, Arg* end ) {
+	SetValid( true );
+
+	std::sort( start, end,
+		[]( const Arg& lhs, const Arg& rhs ) {
+			return lhs.size > rhs.size;
+		}
+	);
+
+	uint32 dataSize = SetArgsMap( start, end );
+
+	uint64 offset;
+	byte* data  = AllocTaskData( dataSize, &offset );
+
+	dataOffset  = GetBits( offset, 0, 32 );
+	dataOffset2 = GetBits( offset, 32, 8 );
+
+	return data;
 }
 
-void Task::SetValid( const bool valid ) {
-	valid ? SetBit( &flags, validOffset ) : UnSetBit( &flags, validOffset );
+byte* Task::GetArgMemory( const uint32 arg ) {
+	return taskList.GetTaskData( GetDataOffset() ) + dataOffsets[RemapArg( arg )];
 }
 
 void Task::operator=( const Task& other ) {
 	Execute            = other.Execute;
-	data               = other.data;
-
 	complete           = other.complete;
 
-	flags              = other.flags;
+	dataOffset         = other.dataOffset;
+	dataOffset2        = other.dataOffset2;
 
-	active             = other.active;
+	flags              = other.flags;
+	id                 = other.id;
 
-	eventMask          = other.eventMask;
+	bufferID           = other.bufferID;
 
 	gen                = other.gen;
+
 	time               = other.time;
+	threadMask         = other.threadMask;
 
 	dependencyCounter  = other.dependencyCounter.load( std::memory_order_relaxed );
 	forwardTaskCounter = other.forwardTaskCounter.load( std::memory_order_relaxed );
-
-	id                 = other.id;
-
-	bufferID           = other.bufferID;
-	threadMask         = other.threadMask;
 	threadCount        = other.threadCount.load( std::memory_order_relaxed );
 
 	forwardTaskLock    = other.forwardTaskLock;
 
-	memcpy( forwardTasks, other.forwardTasks, MAX_FORWARD_TASKS * sizeof( uint16 ) );
+	memcpy( dataOffsets,  other.dataOffsets,  maxArgCount     * sizeof( uint16 ) );
+	memcpy( forwardTasks, other.forwardTasks, maxForwardTasks * sizeof( uint16 ) );
+
+	argsMap            = other.argsMap;
+}
+
+TaskProxy::TaskProxy( Task& newTask ) :
+	task( newTask ) {
+}
 
-	dataSize           = other.dataSize;
+Task* TaskProxy::operator->() const {
+	return &task;
 }