Migrate to Zig 0.16.0-dev.2535 Io-based APIs

Author: HTRMC

.gitignore

@@ -11,3 +11,4 @@ compiler/
 *.txt
 nul
 /cache
+/zig-pkg

.vscode/tasks.json

@@ -1,32 +1,32 @@
 {
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "Build",
-            "type": "shell",
-            "command": "./compiler/zig/zig.exe",
-            "args": ["build"],
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Build and Run",
-            "type": "shell",
-            "command": "./compiler/zig/zig.exe",
-            "args": ["build", "run"],
-            "group": "build",
-            "problemMatcher": []
-        },
-        {
-            "label": "Build and Run (Tracy)",
-            "type": "shell",
-            "command": "./compiler/zig/zig.exe",
-            "args": ["build", "run", "-Dtracy=true"],
-            "group": "build",
-            "problemMatcher": []
-        }
-    ]
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Build",
+      "type": "shell",
+      "command": "zig",
+      "args": ["build"],
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "Build and Run",
+      "type": "shell",
+      "command": "zig",
+      "args": ["build", "run"],
+      "group": "build",
+      "problemMatcher": []
+    },
+    {
+      "label": "Build and Run (Tracy)",
+      "type": "shell",
+      "command": "zig",
+      "args": ["build", "run", "-Dtracy=true"],
+      "group": "build",
+      "problemMatcher": []
+    }
+  ]
 }

.zigversion

@@ -1 +1 @@
-0.16.0-dev.2368+380ea6fb5
+0.16.0-dev.2535+b5bd49460

build.zig.zon

@@ -2,7 +2,7 @@
     .name = .FarHorizons,
     .version = "0.0.0",
     .fingerprint = 0x953f10b5d0f3e503,
-    .minimum_zig_version = "0.16.0-dev.1484+d0ba6642b",
+    .minimum_zig_version = "0.16.0-dev.2535+b5bd49460",
     .dependencies = .{
         // Headers (shared across all platforms)
         .farhorizons_deps_headers = .{

src/client/FarHorizonsClient.zig

@@ -224,10 +224,7 @@ pub const FarHorizonsClient = struct {
         self.window.show();
 
         var esc_was_pressed = false;
-        var timer = std.time.Timer.start() catch {
-            logger.err("Failed to start timer", .{});
-            return;
-        };
+        var last_frame_time = Io.Clock.awake.now(self.io);
         var tick_accumulator: f64 = 0;
 
         self.ecs_world = ecs.World.init(self.allocator);
@@ -302,7 +299,9 @@ pub const FarHorizonsClient = struct {
             const frame_zone = profiler.traceNamed("Frame");
             defer frame_zone.end();
 
-            const delta_ns = timer.lap();
+            const now_time = Io.Clock.awake.now(self.io);
+            const delta_ns: u64 = @intCast(last_frame_time.durationTo(now_time).nanoseconds);
+            last_frame_time = now_time;
             const delta_ms: f64 = @as(f64, @floatFromInt(delta_ns)) / 1_000_000.0;
             tick_accumulator += delta_ms;
 

src/client/renderer/ShaderManager.zig

@@ -68,7 +68,7 @@ pub const ShaderManager = struct {
         var hotbar_icon_frag: ?[]u8 = null;
 
         if (enable_runtime_compilation) {
-            var total_timer = std.time.Timer.start() catch unreachable;
+            const total_start = Io.Clock.awake.now(io);
 
             compiler = try ShaderCompiler.init(allocator, io);
 
@@ -77,17 +77,17 @@ pub const ShaderManager = struct {
 
             // Compile default shaders at startup from assets directory
             logger.info("Compiling default vertex shader...", .{});
-            var vert_timer = std.time.Timer.start() catch unreachable;
+            const vert_start = Io.Clock.awake.now(io);
             var vert_compiled = try compiler.?.compileFile(default_shader_path ++ "triangle.vert");
-            const vert_time_us = vert_timer.read() / std.time.ns_per_us;
+            const vert_time_us = @as(u64, @intCast(@divTrunc(vert_start.durationTo(Io.Clock.awake.now(io)).nanoseconds, std.time.ns_per_us)));
             default_vert = try allocator.dupe(u8, vert_compiled.spv_data);
             vert_compiled.deinit();
             logger.info("Vertex shader compiled in {d}us ({d} bytes SPIR-V)", .{ vert_time_us, default_vert.?.len });
 
             logger.info("Compiling default fragment shader...", .{});
-            var frag_timer = std.time.Timer.start() catch unreachable;
+            const frag_start = Io.Clock.awake.now(io);
             var frag_compiled = try compiler.?.compileFile(default_shader_path ++ "triangle.frag");
-            const frag_time_us = frag_timer.read() / std.time.ns_per_us;
+            const frag_time_us = @as(u64, @intCast(@divTrunc(frag_start.durationTo(Io.Clock.awake.now(io)).nanoseconds, std.time.ns_per_us)));
             default_frag = try allocator.dupe(u8, frag_compiled.spv_data);
             frag_compiled.deinit();
             logger.info("Fragment shader compiled in {d}us ({d} bytes SPIR-V)", .{ frag_time_us, default_frag.?.len });
@@ -155,7 +155,8 @@ pub const ShaderManager = struct {
             hotbar_icon_frag_compiled.deinit();
             logger.info("Hotbar icon shaders compiled", .{});
 
-            const total_time_ms = @as(f64, @floatFromInt(total_timer.read())) / @as(f64, std.time.ns_per_ms);
+            const total_elapsed_ns: i64 = @intCast(total_start.durationTo(Io.Clock.awake.now(io)).nanoseconds);
+            const total_time_ms = @as(f64, @floatFromInt(total_elapsed_ns)) / @as(f64, std.time.ns_per_ms);
             const cache_stats = compiler.?.getCacheStats();
             logger.info("Shader loading complete in {d:.2}ms (cache: {d} hits, {d} misses)", .{
                 total_time_ms,

src/client/renderer/buffer/ChunkBufferManager.zig

@@ -1,6 +1,7 @@
 /// ChunkBufferManager - Coordinates vertex/index arenas for chunk rendering
 /// Uses growable buffer arenas for AAA-quality smooth frame times
 const std = @import("std");
+const Io = std.Io;
 const volk = @import("volk");
 const vk = volk.c;
 const shared = @import("Shared");
@@ -102,6 +103,7 @@ pub const ChunkBufferManager = struct {
         device: vk.VkDevice,
         physical_device: vk.VkPhysicalDevice,
         config: ChunkBufferConfig,
+        io: Io,
     ) !Self {
         logger.info("Initializing ChunkBufferManager (single-buffer mode for GPU-driven rendering)...", .{});
         logger.info("  Vertex buffer: {} MB, Index buffer: {} MB", .{
@@ -123,6 +125,7 @@ pub const ChunkBufferManager = struct {
                 .alignment = config.vertex_size,
                 .expansion_threshold_percent = 100, // Disable expansion threshold
             },
+            io,
         );
         errdefer vertex_arena.deinit();
 
@@ -139,6 +142,7 @@ pub const ChunkBufferManager = struct {
                 .alignment = config.index_size,
                 .expansion_threshold_percent = 100, // Disable expansion threshold
             },
+            io,
         );
         errdefer index_arena.deinit();
 

src/client/renderer/buffer/GrowableBufferArena.zig

@@ -6,6 +6,7 @@
 /// - Async background expansion when capacity threshold reached
 /// - Batched rendering support (groups draw calls by buffer)
 const std = @import("std");
+const Io = std.Io;
 const volk = @import("volk");
 const vk = volk.c;
 const shared = @import("Shared");
@@ -66,9 +67,12 @@ pub const GrowableBufferArena = struct {
     /// Async expansion state
     expansion_thread: ?std.Thread = null,
     pending_arena: ?BufferArena = null,
-    expansion_mutex: std.Thread.Mutex = .{},
+    expansion_mutex: Io.Mutex = Io.Mutex.init,
     expansion_failed: bool = false,
 
+    /// I/O subsystem (needed for mutex operations)
+    io: Io,
+
     /// Vulkan handles needed for creating new arenas
     device: vk.VkDevice,
     physical_device: vk.VkPhysicalDevice,
@@ -90,13 +94,15 @@ pub const GrowableBufferArena = struct {
         device: vk.VkDevice,
         physical_device: vk.VkPhysicalDevice,
         config: GrowableBufferConfig,
+        io: Io,
     ) !Self {
         var self = Self{
             .arenas = .{},
             .device = device,
             .physical_device = physical_device,
             .config = config,
             .allocator = allocator,
+            .io = io,
         };
 
         // Pre-allocate initial arenas
@@ -137,6 +143,7 @@ pub const GrowableBufferArena = struct {
         usage: vk.VkBufferUsageFlags,
         alignment: u64,
         avg_chunk_size: u64,
+        io: Io,
     ) !Self {
         // Calculate expected chunk count
         const h_chunks = @as(u64, view_distance) * 2 + 1;
@@ -171,7 +178,7 @@ pub const GrowableBufferArena = struct {
             .initial_arena_count = @intCast(initial_arenas),
             .usage = usage,
             .alignment = alignment,
-        });
+        }, io);
     }
 
     pub fn deinit(self: *Self) void {
@@ -335,23 +342,23 @@ pub const GrowableBufferArena = struct {
             self.config.alignment,
         ) catch |err| {
             logger.err("Async arena allocation failed: {}", .{err});
-            self.expansion_mutex.lock();
+            self.expansion_mutex.lockUncancelable(self.io);
             self.expansion_failed = true;
-            self.expansion_mutex.unlock();
+            self.expansion_mutex.unlock(self.io);
             return;
         };
 
-        self.expansion_mutex.lock();
+        self.expansion_mutex.lockUncancelable(self.io);
         self.pending_arena = new_arena;
-        self.expansion_mutex.unlock();
+        self.expansion_mutex.unlock(self.io);
 
         logger.info("Async arena allocation complete", .{});
     }
 
     /// Collect a pending arena if ready
     fn collectPendingArena(self: *Self) void {
-        self.expansion_mutex.lock();
-        defer self.expansion_mutex.unlock();
+        self.expansion_mutex.lockUncancelable(self.io);
+        defer self.expansion_mutex.unlock(self.io);
 
         if (self.pending_arena) |arena| {
             self.arenas.append(self.allocator, arena) catch |err| {

src/client/world/ChunkManager.zig

@@ -300,10 +300,10 @@ pub const ChunkManager = struct {
             .chunk_storage = storage,
             .pending_loads = PosSet.init(allocator),
             .managed_positions = PosSet.init(allocator),
-            .completed_queue = ThreadSafeQueue(CompletedMesh).init(allocator),
-            .completed_terrain = ThreadSafeQueue(TerrainResult).init(allocator),
+            .completed_queue = ThreadSafeQueue(CompletedMesh).init(allocator, io),
+            .completed_terrain = ThreadSafeQueue(TerrainResult).init(allocator, io),
             .pending_mesh = PosSet.init(allocator),
-            .pool = try ThreadPool.init(allocator, config.worker_count, processTask),
+            .pool = try ThreadPool.init(allocator, io, config.worker_count, processTask),
             .player_chunk = ChunkPos{ .x = 0, .z = 0, .section_y = 0 },
             .config = config,
             .render_system = render_system,
@@ -326,6 +326,7 @@ pub const ChunkManager = struct {
                 // Uses single-buffer mode by default (1GB vertex, 512MB index)
                 // Required for GPU-driven rendering where all geometry must be in one buffer
             },
+            self.io,
         );
         self.buffer_manager = buffer_mgr;
 
@@ -352,7 +353,7 @@ pub const ChunkManager = struct {
         logger.info("Model cache pre-warmed", .{});
 
         const rcu_instance = try self.allocator.create(Rcu);
-        rcu_instance.* = Rcu.init(self.allocator, self.config.worker_count);
+        rcu_instance.* = Rcu.init(self.allocator, self.config.worker_count, self.io);
         self.rcu = rcu_instance;
         logger.info("RCU initialized for {} worker threads", .{self.config.worker_count});