Show task performance

src/audio.zig

@@ -129,6 +129,7 @@ const MusicLoadTask = struct {
 		.isStillNeeded = @ptrCast(&isStillNeeded),
 		.run = @ptrCast(&run),
 		.clean = @ptrCast(&clean),
+		.taskType = .misc,
 	};
 
 	pub fn schedule(musicId: []const u8) void {

src/gui/windows/debug.zig

@@ -5,11 +5,17 @@ const graphics = main.graphics;
 const draw = graphics.draw;
 const Texture = graphics.Texture;
 const Vec2f = main.vec.Vec2f;
+const TaskType = main.utils.ThreadPool.TaskType;
 
 const gui = @import("../gui.zig");
 const GuiWindow = gui.GuiWindow;
 const GuiComponent = gui.GuiComponent;
 
+
+pub fn onOpen() void {
+	main.threadPool.performance.clear();
+}
+
 pub var window = GuiWindow {
 	.relativePosition = .{
 		.{ .attachedToFrame = .{.selfAttachmentPoint = .lower, .otherAttachmentPoint = .lower} },
@@ -61,6 +67,19 @@ pub fn render() void {
 		y += 8;
 		draw.print("Queue size: {}", .{main.threadPool.queueSize()}, 0, y, 8, .left);
 		y += 8;
+		const perf = main.threadPool.performance.read();
+		const values = comptime std.enums.values(TaskType);
+		var totalUtime: i64 = 0;
+		for(values) |task|
+			totalUtime += perf.utime[@intFromEnum(task)];
+		for(values) |t| {
+			const name = @tagName(t);
+			const i = @intFromEnum(t);
+			const taskTime = @divFloor(perf.utime[i], @max(1, perf.tasks[i]));
+			const relativeTime = 100.0 * @as(f32, @floatFromInt(perf.utime[i])) / @as(f32, @floatFromInt(totalUtime));
+			draw.print("    {s}: {} µs/task ({d:.1}%)", .{name, taskTime, relativeTime}, 0, y, 8, .left);
+			y += 8;
+		}
 		draw.print("Mesh Queue size: {}", .{main.renderer.mesh_storage.updatableList.items.len}, 0, y, 8, .left);
 		y += 8;
 		{

src/network.zig

@@ -1757,6 +1757,7 @@ const ProtocolTask = struct {
 		.isStillNeeded = @ptrCast(&isStillNeeded),
 		.run = @ptrCast(&run),
 		.clean = @ptrCast(&clean),
+		.taskType = .misc,
 	};
 
 	pub fn schedule(conn: *Connection, protocol: u8, data: []const u8) void {

src/renderer/chunk_meshing.zig

@@ -744,6 +744,7 @@ pub const ChunkMesh = struct { // MARK: ChunkMesh
 			.isStillNeeded = @ptrCast(&isStillNeeded),
 			.run = @ptrCast(&run),
 			.clean = @ptrCast(&clean),
+			.taskType = .misc,
 		};
 
 		pub fn scheduleAndDecreaseRefCount(mesh: *ChunkMesh) void {
@@ -1618,4 +1619,4 @@ pub const ChunkMesh = struct { // MARK: ChunkMesh
 		chunkList.append(self.chunkAllocation.start);
 		transparentQuadsDrawn += self.culledSortingCount;
 	}
-};
+};

src/renderer/mesh_storage.zig

@@ -885,6 +885,7 @@ pub const MeshGenerationTask = struct { // MARK: MeshGenerationTask
 		.isStillNeeded = @ptrCast(&isStillNeeded),
 		.run = @ptrCast(&run),
 		.clean = @ptrCast(&clean),
+		.taskType = .meshgenAndLighting,
 	};
 
 	pub fn schedule(mesh: *chunk.Chunk) void {
@@ -937,4 +938,4 @@ pub fn updateLightMap(map: *LightMap.LightMapFragment) void {
 	mutex.lock();
 	defer mutex.unlock();
 	mapUpdatableList.append(map);
-}
+}

src/server/world.zig

@@ -138,6 +138,7 @@ const ChunkManager = struct { // MARK: ChunkManager
 			.isStillNeeded = @ptrCast(&isStillNeeded),
 			.run = @ptrCast(&run),
 			.clean = @ptrCast(&clean),
+			.taskType = .chunkgen,
 		};
 
 		pub fn scheduleAndDecreaseRefCount(pos: ChunkPosition, source: Source) void {
@@ -201,6 +202,7 @@ const ChunkManager = struct { // MARK: ChunkManager
 			.isStillNeeded = @ptrCast(&isStillNeeded),
 			.run = @ptrCast(&run),
 			.clean = @ptrCast(&clean),
+			.taskType = .misc,
 		};
 
 		pub fn scheduleAndDecreaseRefCount(pos: terrain.SurfaceMap.MapFragmentPosition, source: ?*User) void {
@@ -570,6 +572,7 @@ pub const ServerWorld = struct { // MARK: ServerWorld
 			.isStillNeeded = @ptrCast(&isStillNeeded),
 			.run = @ptrCast(&run),
 			.clean = @ptrCast(&clean),
+			.taskType = .chunkgen,
 		};
 
 		pub fn schedule(pos: ChunkPosition, storeMaps: bool) void {

src/utils.zig

@@ -1010,6 +1010,12 @@ pub fn BlockingMaxHeap(comptime T: type) type { // MARK: BlockingMaxHeap
 }
 
 pub const ThreadPool = struct { // MARK: ThreadPool
+	pub const TaskType = enum(usize) {
+		chunkgen,
+		meshgenAndLighting,
+		misc,
+	};
+	pub const taskTypes = std.enums.directEnumArrayLen(TaskType, 0);
 	const Task = struct {
 		cachedPriority: f32,
 		self: *anyopaque,
@@ -1024,6 +1030,41 @@ pub const ThreadPool = struct { // MARK: ThreadPool
 		isStillNeeded: *const fn(*anyopaque, milliTime: i64) bool,
 		run: *const fn(*anyopaque) void,
 		clean: *const fn(*anyopaque) void,
+		taskType: TaskType = .misc,
+	};
+	pub const Performance = struct {
+		mutex: std.Thread.Mutex = .{},
+		tasks: [taskTypes]u32,
+		utime: [taskTypes]i64,
+
+		fn add(self: *Performance, task: TaskType, time: i64) void {
+			self.mutex.lock();
+			defer self.mutex.unlock();
+			const i = @intFromEnum(task);
+			self.tasks[i] += 1;
+			self.utime[i] += time;
+		}
+
+		pub fn clear(self: *Performance) void {
+			self.mutex.lock();
+			defer self.mutex.unlock();
+			for(0..taskTypes) |i| {
+				self.tasks[i] = 0;
+				self.utime[i] = 0;
+			}
+		}
+
+		fn init(allocator: NeverFailingAllocator) *Performance {
+			const self = allocator.create(Performance);
+			self.clear();
+			return self;
+		}
+
+		pub fn read(self: *Performance) Performance {
+			self.mutex.lock();
+			defer self.mutex.unlock();
+			return self.*;
+		}
 	};
 	const refreshTime: u32 = 100; // The time after which all priorities get refreshed in milliseconds.
 
@@ -1032,11 +1073,14 @@ pub const ThreadPool = struct { // MARK: ThreadPool
 	loadList: *BlockingMaxHeap(Task),
 	allocator: NeverFailingAllocator,
 
+	performance: *Performance,
+
 	pub fn init(allocator: NeverFailingAllocator, threadCount: usize) ThreadPool {
 		const self = ThreadPool {
 			.threads = allocator.alloc(std.Thread, threadCount),
 			.currentTasks = allocator.alloc(Atomic(?*const VTable), threadCount),
 			.loadList = BlockingMaxHeap(Task).init(allocator),
+			.performance = Performance.init(allocator),
 			.allocator = allocator,
 		};
 		for(self.threads, 0..) |*thread, i| {
@@ -1064,6 +1108,7 @@ pub const ThreadPool = struct { // MARK: ThreadPool
 		}
 		self.allocator.free(self.currentTasks);
 		self.allocator.free(self.threads);
+		self.allocator.destroy(self.performance);
 	}
 
 	pub fn closeAllTasksOfType(self: ThreadPool, vtable: *const VTable) void {
@@ -1098,7 +1143,10 @@ pub const ThreadPool = struct { // MARK: ThreadPool
 			{
 				const task = self.loadList.extractMax() catch break;
 				self.currentTasks[id].store(task.vtable, .monotonic);
+				const start = std.time.microTimestamp();
 				task.vtable.run(task.self);
+				const end = std.time.microTimestamp();
+				self.performance.add(task.vtable.taskType, end - start);
 				self.currentTasks[id].store(null, .monotonic);
 			}