[backend|renderer] refactor command_stream

Extract le_command_stream and make it available to backend, and
renderer. Command streams are owned by the Backend's Frame, and are a
growable container for raw command stream data.

+ command streams can be re-used.
+ command streams can be cheaply re-set (bump allocator) when we clear
  the frame

Author: tgfrerer

modules/le_backend_vk/CMakeLists.txt

@@ -20,6 +20,7 @@ set (SOURCES ${SOURCES} "le_backend_vk_settings.inl")
 set (SOURCES ${SOURCES} "le_backend_types_internal.h")
 set (SOURCES ${SOURCES} "private/le_backend_vk/le_backend_types_pipeline.inl")
 set (SOURCES ${SOURCES} "private/le_backend_vk/vk_to_str_helpers.inl")
+set (SOURCES ${SOURCES} "private/le_backend_vk/le_command_stream_t.h")
 set (SOURCES ${SOURCES} "le_instance_vk.cpp")
 set (SOURCES ${SOURCES} "le_pipeline.cpp")
 set (SOURCES ${SOURCES} "le_device_vk.cpp")
@@ -55,4 +56,4 @@ ENDIF()
 target_link_libraries(${TARGET} PUBLIC ${LINKER_FLAGS})
 
 
-source_group(${TARGET} FILES ${SOURCES})
+source_group(${TARGET} FILES ${SOURCES})

modules/le_backend_vk/le_backend_vk.cpp

@@ -1,6 +1,7 @@
 #include "le_core.h"
 #include "le_backend_vk.h"
 #include "le_log.h"
+#include "private/le_backend_vk/le_command_stream_t.h"
 #include "util/vk_mem_alloc/vk_mem_alloc.h" // for allocation
 #include "le_backend_types_internal.h"      // includes vulkan.hpp
 #include "le_swapchain_vk.h"
@@ -612,6 +613,8 @@ struct BackendFrameData {
 
 	le_staging_allocator_o* stagingAllocator; // owning: allocator for large objects to GPU memory
 
+	std::vector<le_command_stream_t*> command_streams; // owning; these must be destroyed when frame gets destroyed.
+
 	bool must_create_queues_dot_graph = false;
 };
 
@@ -830,28 +833,36 @@ static void backend_destroy( le_backend_o* self ) {
 
 		vmaDestroyPool( self->mAllocator, frameData.allocationPool );
 
-		// destroy staging allocator
+		// Destroy staging allocator
 		le_staging_allocator_i.destroy( frameData.stagingAllocator );
 
-		// remove any binned resources
-		for ( auto& a : frameData.binnedResources ) {
+		{ // Remove any binned resources
+			for ( auto& a : frameData.binnedResources ) {
 
-			if ( a.second.info.isBuffer() ) {
-				vkDestroyBuffer( device, a.second.as.buffer, nullptr );
-			} else {
-				vkDestroyImage( device, a.second.as.image, nullptr );
-			}
-			if ( a.second.info.isBlas() ) {
-				vkDestroyBuffer( device, a.second.info.blasInfo.buffer, nullptr );
-				vkDestroyAccelerationStructureKHR( device, a.second.as.blas, nullptr );
+				if ( a.second.info.isBuffer() ) {
+					vkDestroyBuffer( device, a.second.as.buffer, nullptr );
+				} else {
+					vkDestroyImage( device, a.second.as.image, nullptr );
+				}
+				if ( a.second.info.isBlas() ) {
+					vkDestroyBuffer( device, a.second.info.blasInfo.buffer, nullptr );
+					vkDestroyAccelerationStructureKHR( device, a.second.as.blas, nullptr );
+				}
+				if ( a.second.info.isTlas() ) {
+					vkDestroyBuffer( device, a.second.info.tlasInfo.buffer, nullptr );
+					vkDestroyAccelerationStructureKHR( device, a.second.as.tlas, nullptr );
+				}
+				vmaFreeMemory( self->mAllocator, a.second.allocation );
 			}
-			if ( a.second.info.isTlas() ) {
-				vkDestroyBuffer( device, a.second.info.tlasInfo.buffer, nullptr );
-				vkDestroyAccelerationStructureKHR( device, a.second.as.tlas, nullptr );
+			frameData.binnedResources.clear();
+		}
+
+		{ // Clear command streams
+			for ( auto& cs : frameData.command_streams ) {
+				delete ( cs );
 			}
-			vmaFreeMemory( self->mAllocator, a.second.allocation );
+			frameData.command_streams.clear();
 		}
-		frameData.binnedResources.clear();
 	}
 
 	self->mFrames.clear();
@@ -2105,6 +2116,11 @@ static bool backend_clear_frame( le_backend_o* self, size_t frameIndex ) {
 	}
 	frame.passes.clear();
 
+	// Reset command streams
+	for ( auto cs : frame.command_streams ) {
+		cs->reset();
+	}
+
 	frame.frameNumber = self->mFramesCount++; // note post-increment
 
 	return true;
@@ -4237,6 +4253,23 @@ static le_allocator_o** backend_get_transient_allocators( le_backend_o* self, si
 	return self->mFrames[ frameIndex ].allocators.data();
 }
 
+// ----------------------------------------------------------------------
+
+static le_command_stream_t** backend_get_frame_command_streams( le_backend_o* self, size_t frameIndex, size_t num_command_streams ) {
+
+	// Check if the command stream pool has enough free command stream elements in the pool for us
+	// If no, we must add some additional command streams
+
+	auto& cmd_streams = self->mFrames[ frameIndex ].command_streams;
+
+	// We should maybe find a nicer way to do this...
+	while ( cmd_streams.size() < num_command_streams ) {
+		cmd_streams.insert( cmd_streams.end(), new le_command_stream_t() );
+	}
+
+	return cmd_streams.data();
+};
+
 // ----------------------------------------------------------------------
 static le_allocator_o** backend_create_transient_allocators( le_backend_o* self, size_t frameIndex, size_t numAllocators ) {
 
@@ -7803,6 +7836,7 @@ LE_MODULE_REGISTER_IMPL( le_backend_vk, api_ ) {
 	vk_backend_i.get_data_frames_count           = backend_get_data_frames_count;
 	vk_backend_i.get_transient_allocators        = backend_get_transient_allocators;
 	vk_backend_i.get_staging_allocator           = backend_get_staging_allocator;
+	vk_backend_i.get_frame_command_streams       = backend_get_frame_command_streams;
 	vk_backend_i.poll_frame_fence                = backend_poll_frame_fence;
 	vk_backend_i.clear_frame                     = backend_clear_frame;
 	vk_backend_i.acquire_physical_resources      = backend_acquire_physical_resources;

modules/le_backend_vk/le_backend_vk.h

@@ -17,6 +17,7 @@ struct le_buffer_o;
 struct le_allocator_o;
 struct le_staging_allocator_o;
 struct le_resource_handle_t; // defined in renderer_types
+struct le_command_stream_t;
 
 struct le_pipeline_manager_o;
 
@@ -132,6 +133,7 @@ struct le_backend_vk_api {
 
 		bool                   ( *dispatch_frame             ) ( le_backend_o *self, size_t frameIndex );
 		le_allocator_o**       ( *get_transient_allocators   ) ( le_backend_o* self, size_t frameIndex);
+		le_command_stream_t**  ( *get_frame_command_streams  ) ( le_backend_o* self, size_t frameIndex, size_t num_command_streams);
 		le_staging_allocator_o*( *get_staging_allocator      ) ( le_backend_o* self, size_t frameIndex);
 
 		le_shader_module_handle( *create_shader_module       ) ( le_backend_o* self, char const * path, const LeShaderSourceLanguageEnum& shader_source_language, const le::ShaderStageFlagBits& moduleType, char const * macro_definitions, le_shader_module_handle handle, VkSpecializationMapEntry const * specialization_map_entries, uint32_t specialization_map_entries_count, void * specialization_map_data, uint32_t specialization_map_data_num_bytes);

modules/le_backend_vk/private/le_backend_vk/le_command_stream_t.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <cstdlib>
+#include <stddef.h>
+
+/*
+ * The Command Stream is where the renderer stores the bytecode for
+ * our encoded command stream; Some data such as scissor dimensions and
+ * push constants will also be encoded into the command stream.
+ *
+ * The Backend reads from the command stream and decodes it into
+ * Vulkan commands.
+ *
+ * We keep the command stream in a header file that is shared by renderer
+ * and backend so that the methods herein can be inlined, as this is all
+ * happening on the hot path; we want renderer and backend to each have
+ * direct access to the data.
+ *
+ * A command stream maps 1:1 to a renderpass. As such, there should be no
+ * threading contention, as only ever one thread may access a renderpass,
+ * and only ever the backend or the renderer access the command stream.
+ *
+ * Command streams are stored with and owned by the Backend Frame. The
+ * Backend Frame creates new Command Streams so that there is one command
+ * stream per renderpass. Command Streams are reset when a frame gets cleared.
+ *
+ * Command streams work as bump, or arena-allocators. This saves us allocating
+ * and de-allocating command streams per-frame. At the same time, command
+ * streams may grow, if there are a large number of commands to record.
+ *
+ */
+
+struct le_command_stream_t {
+	char*  data      = nullptr;
+	size_t size      = 0;
+	size_t capacity  = 0;
+	size_t cmd_count = 0;
+
+	le_command_stream_t()
+	    : size( 0 )
+	    , capacity( 8 ) {
+		data = ( char* )malloc( capacity );
+	}
+
+	~le_command_stream_t() {
+
+		if ( data ) {
+			free( data );
+			size      = 0;
+			cmd_count = 0;
+			data      = nullptr;
+		}
+	}
+
+	void reset() {
+		this->cmd_count = 0;
+		this->size      = 0;
+	}
+
+	template <typename T>
+	inline T* emplace_cmd( size_t payload_sz = 0 ) {
+
+		size_t old_sz = this->size;
+		size_t new_sz = old_sz + sizeof( T ) + payload_sz;
+
+		while ( new_sz > this->capacity ) {
+			this->capacity *= 2;
+			this->data = ( char* )realloc( this->data, this->capacity );
+		}
+
+		this->size = new_sz;
+		this->cmd_count++;
+		return new ( this->data + old_sz )( T );
+	}
+};
+
+// ----------------------------------------------------------------------