Make the CoreTracer singleton

AnKi/Core/App.cpp

@@ -144,8 +144,7 @@ void App::cleanup()
 	NativeWindow::freeSingleton();
 
 #if ANKI_ENABLE_TRACE
-	deleteInstance(m_mainPool, m_coreTracer);
-	m_coreTracer = nullptr;
+	CoreTracer::freeSingleton();
 #endif
 
 	ConfigSet::freeSingleton();
@@ -233,8 +232,7 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	// Core tracer
 	//
 #if ANKI_ENABLE_TRACE
-	m_coreTracer = newInstance<CoreTracer>(m_mainPool);
-	ANKI_CHECK(m_coreTracer->init(&m_mainPool, m_settingsDir));
+	ANKI_CHECK(CoreTracer::allocateSingleton().init(m_settingsDir));
 #endif
 
 	//
@@ -617,7 +615,7 @@ Error App::mainLoop()
 
 #if ANKI_ENABLE_TRACE
 		static U64 frame = 1;
-		m_coreTracer->flushFrame(frame++);
+		CoreTracer::getSingleton().flushFrame(frame++);
 #endif
 	}
 

AnKi/Core/App.h

@@ -13,7 +13,6 @@
 namespace anki {
 
 // Forward
-class CoreTracer;
 class GrManager;
 class MainRenderer;
 class SceneGraph;
@@ -99,9 +98,6 @@ private:
 	HeapMemoryPool m_mainPool;
 
 	// Sybsystems
-#if ANKI_ENABLE_TRACE
-	CoreTracer* m_coreTracer = nullptr;
-#endif
 	GrManager* m_gr = nullptr;
 	MaliHwCounters* m_maliHwCounters = nullptr;
 	ResourceFilesystem* m_resourceFs = nullptr;

AnKi/Core/Common.h

@@ -8,6 +8,7 @@
 #include <AnKi/Config.h>
 #include <AnKi/Util/StdTypes.h>
 #include <AnKi/Util/MemoryPool.h>
+#include <AnKi/Util/DynamicArray.h>
 #include <AnKi/Util/ThreadHive.h>
 
 namespace anki {
@@ -45,4 +46,7 @@ public:
 
 using CoreString = BaseStringRaii<SingletonMemoryPoolWrapper<CoreMemoryPool>>;
 
+template<typename T>
+using CoreDynamicArray = DynamicArrayRaii<T, U32, SingletonMemoryPoolWrapper<CoreMemoryPool>>;
+
 } // end namespace anki

AnKi/Core/CoreTracer.cpp

@@ -33,28 +33,17 @@ static void getSpreadsheetColumnName(U32 column, Array<char, 3>& arr)
 class CoreTracer::ThreadWorkItem : public IntrusiveListEnabled<ThreadWorkItem>
 {
 public:
-	DynamicArrayRaii<TracerEvent> m_events;
-	DynamicArrayRaii<TracerCounter> m_counters;
+	CoreDynamicArray<TracerEvent> m_events;
+	CoreDynamicArray<TracerCounter> m_counters;
 	ThreadId m_tid;
 	U64 m_frame;
-
-	ThreadWorkItem(HeapMemoryPool* pool)
-		: m_events(pool)
-		, m_counters(pool)
-	{
-	}
 };
 
 class CoreTracer::PerFrameCounters : public IntrusiveListEnabled<PerFrameCounters>
 {
 public:
-	DynamicArrayRaii<TracerCounter> m_counters;
+	CoreDynamicArray<TracerCounter> m_counters;
 	U64 m_frame;
-
-	PerFrameCounters(HeapMemoryPool* pool)
-		: m_counters(pool)
-	{
-	}
 };
 
 CoreTracer::CoreTracer()
@@ -85,31 +74,22 @@ CoreTracer::~CoreTracer()
 	while(!m_frameCounters.isEmpty())
 	{
 		PerFrameCounters* frame = m_frameCounters.popBack();
-		deleteInstance(*m_pool, frame);
+		deleteInstance(CoreMemoryPool::getSingleton(), frame);
 	}
 
 	while(!m_workItems.isEmpty())
 	{
 		ThreadWorkItem* item = m_workItems.popBack();
-		deleteInstance(*m_pool, item);
+		deleteInstance(CoreMemoryPool::getSingleton(), item);
 	}
 
-	for(String& s : m_counterNames)
-	{
-		s.destroy(*m_pool);
-	}
-	m_counterNames.destroy(*m_pool);
-
 	// Destroy the tracer
 	Tracer::freeSingleton();
 }
 
-Error CoreTracer::init(HeapMemoryPool* pool, CString directory)
+Error CoreTracer::init(CString directory)
 {
-	ANKI_ASSERT(pool);
-	m_pool = pool;
-
-	Tracer::allocateSingleton(m_pool);
+	Tracer::allocateSingleton(&CoreMemoryPool::getSingleton());
 	const Bool enableTracer = getenv("ANKI_CORE_TRACER_ENABLED") && getenv("ANKI_CORE_TRACER_ENABLED")[0] == '1';
 	Tracer::getSingleton().setEnabled(enableTracer);
 	ANKI_CORE_LOGI("Tracing is %s from the beginning", (enableTracer) ? "enabled" : "disabled");
@@ -119,15 +99,14 @@ Error CoreTracer::init(HeapMemoryPool* pool, CString directory)
 	});
 
 	std::tm tm = getLocalTime();
-	StringRaii fname(m_pool);
+	CoreString fname;
 	fname.sprintf("%s/%d%02d%02d-%02d%02d_", directory.cstr(), tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
 				  tm.tm_min);
 
-	ANKI_CHECK(m_traceJsonFile.open(StringRaii(m_pool).sprintf("%strace.json", fname.cstr()), FileOpenFlag::kWrite));
+	ANKI_CHECK(m_traceJsonFile.open(CoreString().sprintf("%strace.json", fname.cstr()), FileOpenFlag::kWrite));
 	ANKI_CHECK(m_traceJsonFile.writeText("[\n"));
 
-	ANKI_CHECK(
-		m_countersCsvFile.open(StringRaii(m_pool).sprintf("%scounters.csv", fname.cstr()), FileOpenFlag::kWrite));
+	ANKI_CHECK(m_countersCsvFile.open(CoreString().sprintf("%scounters.csv", fname.cstr()), FileOpenFlag::kWrite));
 
 	return Error::kNone;
 }
@@ -171,7 +150,7 @@ Error CoreTracer::threadWorker()
 				gatherCounters(*item);
 			}
 
-			deleteInstance(*m_pool, item);
+			deleteInstance(CoreMemoryPool::getSingleton(), item);
 		}
 	}
 
@@ -214,7 +193,7 @@ void CoreTracer::gatherCounters(ThreadWorkItem& item)
 	});
 
 	// Merge same
-	DynamicArrayRaii<TracerCounter> mergedCounters(m_pool);
+	CoreDynamicArray<TracerCounter> mergedCounters;
 	for(U32 i = 0; i < item.m_counters.getSize(); ++i)
 	{
 		if(mergedCounters.getSize() == 0 || mergedCounters.getBack().m_name != item.m_counters[i].m_name)
@@ -248,7 +227,7 @@ void CoreTracer::gatherCounters(ThreadWorkItem& item)
 
 		if(!found)
 		{
-			m_counterNames.emplaceBack(*m_pool, *m_pool, counter.m_name);
+			m_counterNames.emplaceBack(counter.m_name);
 			addedCounterName = true;
 		}
 	}
@@ -262,7 +241,7 @@ void CoreTracer::gatherCounters(ThreadWorkItem& item)
 	if(m_frameCounters.isEmpty() || m_frameCounters.getBack().m_frame != item.m_frame)
 	{
 		// Create new frame
-		PerFrameCounters* newPerFrame = newInstance<PerFrameCounters>(*m_pool, m_pool);
+		PerFrameCounters* newPerFrame = newInstance<PerFrameCounters>(CoreMemoryPool::getSingleton());
 		newPerFrame->m_counters = std::move(mergedCounters);
 		newPerFrame->m_frame = item.m_frame;
 		m_frameCounters.pushBack(newPerFrame);
@@ -310,7 +289,7 @@ void CoreTracer::flushFrame(U64 frame)
 			Ctx& ctx = *static_cast<Ctx*>(ud);
 			CoreTracer& self = *ctx.m_self;
 
-			ThreadWorkItem* item = newInstance<ThreadWorkItem>(*self.m_pool, self.m_pool);
+			ThreadWorkItem* item = newInstance<ThreadWorkItem>(CoreMemoryPool::getSingleton());
 			item->m_tid = tid;
 			item->m_frame = ctx.m_frame;
 

AnKi/Core/CoreTracer.h

@@ -16,15 +16,14 @@ namespace anki {
 /// @{
 
 /// A system that sits on top of the tracer and processes the counters and events.
-class CoreTracer
+class CoreTracer : public MakeSingleton<CoreTracer>
 {
-public:
-	CoreTracer();
-
-	~CoreTracer();
+	template<typename>
+	friend class MakeSingleton;
 
+public:
 	/// @param directory The directory to store the trace and counters.
-	Error init(HeapMemoryPool* pool, CString directory);
+	Error init(CString directory);
 
 	/// It will flush everything.
 	void flushFrame(U64 frame);
@@ -33,13 +32,11 @@ private:
 	class ThreadWorkItem;
 	class PerFrameCounters;
 
-	HeapMemoryPool* m_pool = nullptr;
-
 	Thread m_thread;
 	ConditionVariable m_cvar;
 	Mutex m_mtx;
 
-	DynamicArray<String> m_counterNames;
+	CoreDynamicArray<CoreString> m_counterNames;
 	IntrusiveList<PerFrameCounters> m_frameCounters;
 
 	IntrusiveList<ThreadWorkItem> m_workItems; ///< Items for the thread to process.
@@ -47,6 +44,10 @@ private:
 	File m_countersCsvFile;
 	Bool m_quit = false;
 
+	CoreTracer();
+
+	~CoreTracer();
+
 	Error threadWorker();
 
 	Error writeEvents(ThreadWorkItem& item);

AnKi/Gr/Vulkan/CommandBufferImpl.inl.h

@@ -394,7 +394,7 @@ inline void CommandBufferImpl::pushSecondLevelCommandBuffersInternal(ConstWeakAr
 		beginRenderPassInternal();
 	}
 
-	DynamicArrayRaii<VkCommandBuffer> handles(m_pool, cmdbs.getSize());
+	DynamicArrayRaii<VkCommandBuffer> handles(cmdbs.getSize(), m_pool);
 	for(U32 i = 0; i < cmdbs.getSize(); ++i)
 	{
 		ANKI_ASSERT(static_cast<const CommandBufferImpl&>(*cmdbs[i]).m_finalized);

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -231,7 +231,7 @@ Error GrManagerImpl::initInstance()
 
 		if(layerCount)
 		{
-			DynamicArrayRaii<VkLayerProperties> layerProps(&m_pool, layerCount);
+			DynamicArrayRaii<VkLayerProperties> layerProps(layerCount, &m_pool);
 			vkEnumerateInstanceLayerProperties(&layerCount, &layerProps[0]);
 
 			ANKI_VK_LOGV("Found the following instance layers:");
@@ -426,7 +426,7 @@ Error GrManagerImpl::initInstance()
 			return Error::kFunctionFailed;
 		}
 
-		DynamicArrayRaii<VkPhysicalDevice> physicalDevices(&m_pool, count);
+		DynamicArrayRaii<VkPhysicalDevice> physicalDevices(count, &m_pool);
 		ANKI_VK_CHECK(vkEnumeratePhysicalDevices(m_instance, &count, &physicalDevices[0]));
 
 		class Dev
@@ -436,7 +436,7 @@ Error GrManagerImpl::initInstance()
 			VkPhysicalDeviceProperties2 m_vkProps;
 		};
 
-		DynamicArrayRaii<Dev> devs(&m_pool, count);
+		DynamicArrayRaii<Dev> devs(count, &m_pool);
 		for(U32 devIdx = 0; devIdx < count; ++devIdx)
 		{
 			devs[devIdx].m_pdev = physicalDevices[devIdx];
@@ -1613,7 +1613,7 @@ Error GrManagerImpl::printPipelineShaderInfoInternal(VkPipeline ppline, CString
 		pplineInf.pipeline = ppline;
 		U32 executableCount = 0;
 		ANKI_VK_CHECK(vkGetPipelineExecutablePropertiesKHR(m_device, &pplineInf, &executableCount, nullptr));
-		DynamicArrayRaii<VkPipelineExecutablePropertiesKHR> executableProps(&m_pool, executableCount);
+		DynamicArrayRaii<VkPipelineExecutablePropertiesKHR> executableProps(executableCount, &m_pool);
 		for(VkPipelineExecutablePropertiesKHR& prop : executableProps)
 		{
 			prop = {};
@@ -1635,7 +1635,7 @@ Error GrManagerImpl::printPipelineShaderInfoInternal(VkPipeline ppline, CString
 			exeInf.pipeline = ppline;
 			U32 statCount = 0;
 			vkGetPipelineExecutableStatisticsKHR(m_device, &exeInf, &statCount, nullptr);
-			DynamicArrayRaii<VkPipelineExecutableStatisticKHR> stats(&m_pool, statCount);
+			DynamicArrayRaii<VkPipelineExecutableStatisticKHR> stats(statCount, &m_pool);
 			for(VkPipelineExecutableStatisticKHR& s : stats)
 			{
 				s = {};

AnKi/Gr/Vulkan/ShaderProgramImpl.cpp

@@ -264,7 +264,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 	if(!!(m_stages & ShaderTypeBit::kAllRayTracing))
 	{
 		// Create shaders
-		DynamicArrayRaii<VkPipelineShaderStageCreateInfo> stages(&getMemoryPool(), m_shaders.getSize());
+		DynamicArrayRaii<VkPipelineShaderStageCreateInfo> stages(m_shaders.getSize(), &getMemoryPool());
 		for(U32 i = 0; i < stages.getSize(); ++i)
 		{
 			const ShaderImpl& impl = static_cast<const ShaderImpl&>(*m_shaders[i]);
@@ -289,7 +289,7 @@ Error ShaderProgramImpl::init(const ShaderProgramInitInfo& inf)
 		U32 groupCount = inf.m_rayTracingShaders.m_rayGenShaders.getSize()
 						 + inf.m_rayTracingShaders.m_missShaders.getSize()
 						 + inf.m_rayTracingShaders.m_hitGroups.getSize();
-		DynamicArrayRaii<VkRayTracingShaderGroupCreateInfoKHR> groups(&getMemoryPool(), groupCount, defaultGroup);
+		DynamicArrayRaii<VkRayTracingShaderGroupCreateInfoKHR> groups(groupCount, defaultGroup, &getMemoryPool());
 
 		// 1st group is the ray gen
 		groupCount = 0;

AnKi/Importer/GltfImporter.cpp

@@ -437,7 +437,7 @@ Error GltfImporter::getExtras(const cgltf_extras& extras, HashMapRaii<CString, S
 		auto it2 = it;
 		++it2;
 
-		out.emplace(it->toCString(), StringRaii(m_pool, it2->toCString()));
+		out.emplace(it->toCString(), StringRaii(it2->toCString(), m_pool));
 		++it;
 		++it;
 	}

AnKi/Importer/GltfImporter.h

@@ -157,7 +157,7 @@ private:
 
 	StringRaii fixFilename(CString in) const
 	{
-		StringRaii out(m_pool, in);
+		StringRaii out(in, m_pool);
 		out.replaceAll("|", "_");
 		out.replaceAll(" ", "_");
 		return out;

AnKi/Importer/GltfImporterAnimation.cpp

@@ -163,7 +163,7 @@ Error GltfImporter::writeAnimation(const cgltf_animation& anim)
 	}
 
 	// Gather the keys
-	DynamicArrayRaii<GltfAnimChannel> tempChannels(m_pool, channelCount, m_pool);
+	DynamicArrayRaii<GltfAnimChannel> tempChannels(channelCount, m_pool, m_pool);
 	channelCount = 0;
 	for(auto it = channelMap.getBegin(); it != channelMap.getEnd(); ++it)
 	{

AnKi/Importer/GltfImporterMesh.cpp

@@ -211,7 +211,7 @@ static void decimateSubmesh(F32 factor, SubMesh& submesh, BaseMemoryPool* pool)
 	}
 
 	// Decimate
-	DynamicArrayRaii<U32> newIndices(pool, submesh.m_indices.getSize());
+	DynamicArrayRaii<U32> newIndices(submesh.m_indices.getSize(), pool);
 	newIndices.resize(U32(meshopt_simplify(&newIndices[0], &submesh.m_indices[0], submesh.m_indices.getSize(),
 										   &submesh.m_verts[0].m_position.x(), submesh.m_verts.getSize(),
 										   sizeof(TempVertex), targetIndexCount, 1e-2f)));
@@ -679,7 +679,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 	}
 
 	// Write sub meshes
-	DynamicArrayRaii<MeshBinarySubMesh> outSubmeshes(m_pool, U32(submeshes[0].getSize()));
+	DynamicArrayRaii<MeshBinarySubMesh> outSubmeshes(U32(submeshes[0].getSize()), m_pool);
 
 	for(U32 submeshIdx = 0; submeshIdx < outSubmeshes.getSize(); ++submeshIdx)
 	{
@@ -714,7 +714,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 		U32 vertCount = 0;
 		for(const SubMesh& submesh : submeshes[lod])
 		{
-			DynamicArrayRaii<U16> indices(m_pool, submesh.m_indices.getSize());
+			DynamicArrayRaii<U16> indices(submesh.m_indices.getSize(), m_pool);
 			for(U32 i = 0; i < indices.getSize(); ++i)
 			{
 				const U32 idx = submesh.m_indices[i] + vertCount;
@@ -734,7 +734,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 		// Write positions
 		for(const SubMesh& submesh : submeshes[lod])
 		{
-			DynamicArrayRaii<U16Vec4> positions(m_pool, submesh.m_verts.getSize());
+			DynamicArrayRaii<U16Vec4> positions(submesh.m_verts.getSize(), m_pool);
 			for(U32 v = 0; v < submesh.m_verts.getSize(); ++v)
 			{
 				Vec3 localPos = (submesh.m_verts[v].m_position + posTranslation) * posScale;
@@ -750,7 +750,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 		// Write normals
 		for(const SubMesh& submesh : submeshes[lod])
 		{
-			DynamicArrayRaii<U32> normals(m_pool, submesh.m_verts.getSize());
+			DynamicArrayRaii<U32> normals(submesh.m_verts.getSize(), m_pool);
 			for(U32 v = 0; v < submesh.m_verts.getSize(); ++v)
 			{
 				normals[v] = packSnorm4x8(submesh.m_verts[v].m_normal.xyz0());
@@ -762,7 +762,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 		// Write tangent
 		for(const SubMesh& submesh : submeshes[lod])
 		{
-			DynamicArrayRaii<U32> tangents(m_pool, submesh.m_verts.getSize());
+			DynamicArrayRaii<U32> tangents(submesh.m_verts.getSize(), m_pool);
 			for(U32 v = 0; v < submesh.m_verts.getSize(); ++v)
 			{
 				tangents[v] = packSnorm4x8(submesh.m_verts[v].m_tangent);
@@ -774,7 +774,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 		// Write UV
 		for(const SubMesh& submesh : submeshes[lod])
 		{
-			DynamicArrayRaii<Vec2> uvs(m_pool, submesh.m_verts.getSize());
+			DynamicArrayRaii<Vec2> uvs(submesh.m_verts.getSize(), m_pool);
 			for(U32 v = 0; v < submesh.m_verts.getSize(); ++v)
 			{
 				uvs[v] = submesh.m_verts[v].m_uv;
@@ -788,7 +788,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 			// Bone IDs
 			for(const SubMesh& submesh : submeshes[lod])
 			{
-				DynamicArrayRaii<U8Vec4> boneids(m_pool, submesh.m_verts.getSize());
+				DynamicArrayRaii<U8Vec4> boneids(submesh.m_verts.getSize(), m_pool);
 				for(U32 v = 0; v < submesh.m_verts.getSize(); ++v)
 				{
 					boneids[v] = U8Vec4(submesh.m_verts[v].m_boneIds);
@@ -800,7 +800,7 @@ Error GltfImporter::writeMesh(const cgltf_mesh& mesh) const
 			// Bone weights
 			for(const SubMesh& submesh : submeshes[lod])
 			{
-				DynamicArrayRaii<U32> boneWeights(m_pool, submesh.m_verts.getSize());
+				DynamicArrayRaii<U32> boneWeights(submesh.m_verts.getSize(), m_pool);
 				for(U32 v = 0; v < submesh.m_verts.getSize(); ++v)
 				{
 					boneWeights[v] = packSnorm4x8(submesh.m_verts[v].m_boneWeights);

AnKi/Resource/MeshBinaryLoader.cpp

@@ -314,7 +314,7 @@ Error MeshBinaryLoader::storeIndicesAndPosition(U32 lod, DynamicArrayRaii<U32>&
 	// Store positions
 	{
 		const MeshBinaryVertexAttribute& attrib = m_header.m_vertexAttributes[VertexStreamId::kPosition];
-		DynamicArrayRaii<U16Vec4> tempPositions(m_pool, m_header.m_totalVertexCounts[lod]);
+		DynamicArrayRaii<U16Vec4> tempPositions(m_header.m_totalVertexCounts[lod], m_pool);
 		static_assert(kMeshRelatedVertexStreamFormats[VertexStreamId::kPosition] == Format::kR16G16B16A16_Unorm,
 					  "Incorrect format");
 		ANKI_CHECK(storeVertexBuffer(lod, attrib.m_bufferIndex, &tempPositions[0], tempPositions.getSizeInBytes()));

AnKi/Scene/Components/ModelComponent.cpp

@@ -184,7 +184,7 @@ Error ModelComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 		}
 
 		// Upload the uniforms
-		DynamicArrayRaii<U32> allUniforms(info.m_framePool, U32(m_gpuSceneUniforms.m_size / 4));
+		DynamicArrayRaii<U32> allUniforms(U32(m_gpuSceneUniforms.m_size / 4), info.m_framePool);
 		U32 count = 0;
 		for(U32 i = 0; i < modelPatchCount; ++i)
 		{

AnKi/Scene/Components/SkinComponent.cpp

@@ -198,7 +198,7 @@ Error SkinComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 
 		// Update the GPU scene
 		const U32 boneCount = m_skeleton->getBones().getSize();
-		DynamicArrayRaii<Mat3x4> trfs(info.m_framePool, boneCount * 2);
+		DynamicArrayRaii<Mat3x4> trfs(boneCount * 2, info.m_framePool);
 		for(U32 i = 0; i < boneCount; ++i)
 		{
 			trfs[i * 2 + 0] = getBoneTransforms()[i];

AnKi/ShaderCompiler/Dxc.cpp

@@ -74,31 +74,31 @@ Error compileHlslToSpirv(CString src, ShaderType shaderType, Bool compileWith16b
 	spvFilename.sprintf("%s/%" PRIu64 ".spv", tmpDir.cstr(), rand);
 
 	DynamicArrayRaii<StringRaii> dxcArgs(&tmpPool);
-	dxcArgs.emplaceBack(&tmpPool, "-Fo");
-	dxcArgs.emplaceBack(&tmpPool, spvFilename);
-	dxcArgs.emplaceBack(&tmpPool, "-Wall");
-	dxcArgs.emplaceBack(&tmpPool, "-Wextra");
-	dxcArgs.emplaceBack(&tmpPool, "-Wno-conversion");
-	dxcArgs.emplaceBack(&tmpPool, "-Werror");
-	dxcArgs.emplaceBack(&tmpPool, "-Wfatal-errors");
-	dxcArgs.emplaceBack(&tmpPool, "-Wundef");
-	dxcArgs.emplaceBack(&tmpPool, "-Wno-unused-const-variable");
-	dxcArgs.emplaceBack(&tmpPool, "-HV");
-	dxcArgs.emplaceBack(&tmpPool, "2021");
-	dxcArgs.emplaceBack(&tmpPool, "-E");
-	dxcArgs.emplaceBack(&tmpPool, "main");
-	dxcArgs.emplaceBack(&tmpPool, "-T");
-	dxcArgs.emplaceBack(&tmpPool, profile(shaderType));
-	dxcArgs.emplaceBack(&tmpPool, "-spirv");
-	dxcArgs.emplaceBack(&tmpPool, "-fspv-target-env=vulkan1.1spirv1.4");
-	dxcArgs.emplaceBack(&tmpPool, hlslFilename);
+	dxcArgs.emplaceBack("-Fo", &tmpPool);
+	dxcArgs.emplaceBack(spvFilename, &tmpPool);
+	dxcArgs.emplaceBack("-Wall", &tmpPool);
+	dxcArgs.emplaceBack("-Wextra", &tmpPool);
+	dxcArgs.emplaceBack("-Wno-conversion", &tmpPool);
+	dxcArgs.emplaceBack("-Werror", &tmpPool);
+	dxcArgs.emplaceBack("-Wfatal-errors", &tmpPool);
+	dxcArgs.emplaceBack("-Wundef", &tmpPool);
+	dxcArgs.emplaceBack("-Wno-unused-const-variable", &tmpPool);
+	dxcArgs.emplaceBack("-HV", &tmpPool);
+	dxcArgs.emplaceBack("2021", &tmpPool);
+	dxcArgs.emplaceBack("-E", &tmpPool);
+	dxcArgs.emplaceBack("main", &tmpPool);
+	dxcArgs.emplaceBack("-T", &tmpPool);
+	dxcArgs.emplaceBack(profile(shaderType), &tmpPool);
+	dxcArgs.emplaceBack("-spirv", &tmpPool);
+	dxcArgs.emplaceBack("-fspv-target-env=vulkan1.1spirv1.4", &tmpPool);
+	dxcArgs.emplaceBack(hlslFilename);
 
 	if(compileWith16bitTypes)
 	{
-		dxcArgs.emplaceBack(&tmpPool, "-enable-16bit-types");
+		dxcArgs.emplaceBack("-enable-16bit-types", &tmpPool);
 	}
 
-	DynamicArrayRaii<CString> dxcArgs2(&tmpPool, dxcArgs.getSize());
+	DynamicArrayRaii<CString> dxcArgs2(dxcArgs.getSize(), &tmpPool);
 	for(U32 i = 0; i < dxcArgs.getSize(); ++i)
 	{
 		dxcArgs2[i] = dxcArgs[i];

AnKi/ShaderCompiler/ShaderProgramCompiler.cpp

@@ -784,8 +784,8 @@ static Error doGhostStructReflection(const StringList& symbolsToReflect,
 
 	// Add the ghost structs to binary structs
 	const U32 nonGhostStructCount = binary.m_structs.getSize();
-	DynamicArrayRaii<ShaderProgramBinaryStruct> structs(&binaryPool,
-														nonGhostStructCount + ghostStructIndices.getSize());
+	DynamicArrayRaii<ShaderProgramBinaryStruct> structs(nonGhostStructCount + ghostStructIndices.getSize(),
+														&binaryPool);
 
 	for(U32 i = 0; i < binary.m_structs.getSize(); ++i)
 	{
@@ -799,7 +799,7 @@ static Error doGhostStructReflection(const StringList& symbolsToReflect,
 
 		ANKI_CHECK(Refl::setName(in.m_name, out.m_name));
 
-		DynamicArrayRaii<ShaderProgramBinaryStructMember> members(&binaryPool, in.m_members.getSize());
+		DynamicArrayRaii<ShaderProgramBinaryStructMember> members(in.m_members.getSize(), &binaryPool);
 		for(U32 j = 0; j < in.m_members.getSize(); ++j)
 		{
 			const ShaderProgramParserMember& inMember = in.m_members[j];
@@ -1054,11 +1054,11 @@ Error compileShaderProgramInternal(CString fname, ShaderProgramFilesystemInterfa
 	if(parser.getMutators().getSize() > 0)
 	{
 		// Initialize
-		DynamicArrayRaii<MutatorValue> mutationValues(&tempPool, parser.getMutators().getSize());
-		DynamicArrayRaii<U32> dials(&tempPool, parser.getMutators().getSize(), 0);
+		DynamicArrayRaii<MutatorValue> mutationValues(parser.getMutators().getSize(), &tempPool);
+		DynamicArrayRaii<U32> dials(parser.getMutators().getSize(), 0, &tempPool);
 		DynamicArrayRaii<ShaderProgramBinaryVariant> variants(&binaryPool);
 		DynamicArrayRaii<ShaderProgramBinaryCodeBlock> codeBlocks(&binaryPool);
-		DynamicArrayRaii<ShaderProgramBinaryMutation> mutations(&binaryPool, mutationCount);
+		DynamicArrayRaii<ShaderProgramBinaryMutation> mutations(mutationCount, &binaryPool);
 		DynamicArrayRaii<U64> codeBlockHashes(&tempPool);
 		HashMapRaii<U64, U32> mutationHashToIdx(&tempPool);
 

AnKi/ShaderCompiler/ShaderProgramParser.cpp

@@ -32,7 +32,7 @@ static const U64 kShaderHeaderHash = computeHash(kShaderHeader, sizeof(kShaderHe
 ShaderProgramParser::ShaderProgramParser(CString fname, ShaderProgramFilesystemInterface* fsystem, BaseMemoryPool* pool,
 										 const ShaderCompilerOptions& compilerOptions)
 	: m_pool(pool)
-	, m_fname(pool, fname)
+	, m_fname(fname, pool)
 	, m_fsystem(fsystem)
 	, m_compilerOptions(compilerOptions)
 {
@@ -46,7 +46,7 @@ void ShaderProgramParser::tokenizeLine(CString line, DynamicArrayRaii<StringRaii
 {
 	ANKI_ASSERT(line.getLength() > 0);
 
-	StringRaii l(m_pool, line);
+	StringRaii l(line, m_pool);
 
 	// Replace all tabs with spaces
 	for(char& c : l)
@@ -64,7 +64,7 @@ void ShaderProgramParser::tokenizeLine(CString line, DynamicArrayRaii<StringRaii
 	// Create the array
 	for(const String& s : spaceTokens)
 	{
-		tokens.emplaceBack(m_pool, s);
+		tokens.emplaceBack(s, m_pool);
 	}
 }
 

AnKi/ShaderCompiler/ShaderProgramReflection.cpp

@@ -1011,7 +1011,7 @@ Error SpirvReflector::performSpirvReflection(Array<ConstWeakArray<U8>, U32(Shade
 		{
 			const StructMember& sm = s.m_members[j];
 			ANKI_CHECK(interface.visitStructMember(i, s.m_name, j, sm.m_name, sm.m_type,
-												   (sm.m_structIndex != kMaxU32) ? structs[sm.m_structIndex].m_name
+												   (sm.m_structIndex != kMaxU32) ? structs[sm.m_structIndex].m_name.toCString()
 																				 : CString(),
 												   sm.m_offset, sm.m_arraySize));
 		}

AnKi/Util/DynamicArray.h

@@ -330,14 +330,14 @@ public:
 	using typename Base::Size;
 	using MemoryPool = TMemPool;
 
-	DynamicArrayRaii(const MemoryPool& pool)
+	DynamicArrayRaii(const MemoryPool& pool = MemoryPool())
 		: Base()
 		, m_pool(pool)
 	{
 	}
 
 	/// And resize
-	DynamicArrayRaii(const MemoryPool& pool, Size size)
+	DynamicArrayRaii(Size size, const MemoryPool& pool = MemoryPool())
 		: Base()
 		, m_pool(pool)
 	{
@@ -345,7 +345,7 @@ public:
 	}
 
 	/// With default value
-	DynamicArrayRaii(const MemoryPool& pool, Size size, const T& v)
+	DynamicArrayRaii(Size size, const T& v, const MemoryPool& pool = MemoryPool())
 		: Base()
 		, m_pool(pool)
 	{

AnKi/Util/Filesystem.h

@@ -86,7 +86,7 @@ public:
 	Second m_seepTimeBeforeNextTry = 1.0_ms; ///< Time before the next try.
 
 	CleanupFile(BaseMemoryPool* pool, CString filename)
-		: m_fileToDelete(pool, filename)
+		: m_fileToDelete(filename, pool)
 	{
 	}
 

AnKi/Util/FilesystemWindows.cpp

@@ -199,7 +199,7 @@ Error walkDirectoryTreeInternal(const CString& dir, const Function<Error(const C
 
 Error getApplicationPath(StringRaii& out)
 {
-	DynamicArrayRaii<Char> buff(&out.getMemoryPool(), 1024);
+	DynamicArrayRaii<Char> buff(1024, &out.getMemoryPool());
 
 	const DWORD result = GetModuleFileNameA(nullptr, &buff[0], buff.getSize());
 	DWORD lastError = GetLastError();

AnKi/Util/String.h

@@ -858,7 +858,7 @@ public:
 	}
 
 	/// Create with memory pool and data.
-	BaseStringRaii(const MemoryPool& pool, const CStringType& cstr)
+	BaseStringRaii(const CStringType& cstr, const MemoryPool& pool = MemoryPool())
 		: Base()
 		, m_pool(pool)
 	{

Samples/Common/SampleApp.cpp

@@ -15,7 +15,7 @@ Error SampleApp::init(int argc, char** argv, CString sampleName)
 	ConfigSet::getSingleton().setWindowFullscreen(true);
 
 #if !ANKI_OS_ANDROID
-	StringRaii mainDataPath(&pool, ANKI_SOURCE_DIRECTORY);
+	StringRaii mainDataPath(ANKI_SOURCE_DIRECTORY, &pool);
 	StringRaii assetsDataPath(&pool);
 	assetsDataPath.sprintf("%s/Samples/%s", ANKI_SOURCE_DIRECTORY, sampleName.cstr());
 

Tests/Util/Tracer.cpp

@@ -12,12 +12,11 @@
 ANKI_TEST(Util, Tracer)
 {
 	HeapMemoryPool alloc(allocAligned, nullptr);
-	CoreTracer tracer;
-	ANKI_TEST_EXPECT_NO_ERR(tracer.init(&alloc, "./"));
+	CoreTracer::allocateSingleton().init("./");
 	Tracer::getSingleton().setEnabled(true);
 
 	// 1st frame
-	tracer.flushFrame(0);
+	CoreTracer::getSingleton().flushFrame(0);
 
 	// 2nd frame
 	// 2 events
@@ -31,7 +30,7 @@ ANKI_TEST(Util, Tracer)
 		HighRezTimer::sleep(0.25);
 	}
 
-	tracer.flushFrame(1);
+	CoreTracer::getSingleton().flushFrame(1);
 
 	// 4rd frame
 	// 2 different events & non zero counter
@@ -47,10 +46,12 @@ ANKI_TEST(Util, Tracer)
 
 	ANKI_TRACE_INC_COUNTER(COUNTER, 100);
 
-	tracer.flushFrame(3);
+	CoreTracer::getSingleton().flushFrame(3);
 
 	// 5th frame
 	ANKI_TRACE_INC_COUNTER(COUNTER, 150);
-	tracer.flushFrame(4);
+	CoreTracer::getSingleton().flushFrame(4);
+
+	CoreTracer::freeSingleton();
 }
 #endif

Tools/Image/ImageViewerMain.cpp

@@ -273,7 +273,7 @@ public:
 		}
 
 		HeapMemoryPool pool(allocAligned, nullptr);
-		StringRaii mainDataPath(&pool, ANKI_SOURCE_DIRECTORY);
+		StringRaii mainDataPath(ANKI_SOURCE_DIRECTORY, &pool);
 
 		ConfigSet::getSingleton().setWindowFullscreen(false);
 		ConfigSet::getSingleton().setRsrcDataPaths(mainDataPath);