update for writergate

mrjbq7 · Cloudef · commit 0699dc51d634 · 2025-09-16T13:18:06.000+09:00
diff --git a/bugs/31.zig b/bugs/31.zig
@@ -23,11 +23,15 @@ fn protection(comptime func: anytype, args: anytype) void {
 }
 
 pub fn logInfo(comptime format: []const u8, args: anytype) void {
-    std.io.getStdOut().writer().print(format, args) catch return;
+    var buf: [4096]u8 = undefined;
+    var writer = std.fs.File.stdout().writerStreaming(&buf);
+    writer.interface.print(format, args) catch return;
 }
 
 pub fn logErr(comptime format: []const u8, args: anytype) void {
-    std.io.getStdErr().writer().print(format, args) catch return;
+    var buf: [4096]u8 = undefined;
+    var writer = std.fs.File.stderr().writerStreaming(&buf);
+    writer.interface.print(format, args) catch return;
 }
 
 pub fn delay(ns: u128) !void {
diff --git a/build.zig b/build.zig
@@ -70,15 +70,18 @@ pub fn build(b: *std.Build) void {
         .coro_wttr,
     }) |example| {
         const os = target.query.os_tag orelse builtin.os.tag;
-        const exe = b.addExecutable(.{
-            .name = @tagName(example),
+        const module = b.createModule(.{
             .root_source_file = b.path("examples/" ++ @tagName(example) ++ ".zig"),
             .target = target,
             .optimize = optimize,
             .sanitize_thread = sanitize,
             .single_threaded = if (example == .coro_wttr and os != .wasi) false else single_threaded,
             .strip = false,
         });
+        const exe = b.addExecutable(.{
+            .name = @tagName(example),
+            .root_module = module,
+        });
         exe.root_module.addImport("aio", aio);
         exe.root_module.addImport("coro", coro);
         const install = b.addInstallArtifact(exe, .{ .dest_dir = .{ .override = .{ .custom = "example" } } });
@@ -90,16 +93,19 @@ pub fn build(b: *std.Build) void {
     const test_filter = b.option([]const u8, "test-filter", "Skip tests that do not match any filter") orelse "";
     const test_step = b.step("test", "Run unit tests");
     inline for (.{ .minilib, .aio, .coro }) |mod| {
-        const tst = b.addTest(.{
+        const module = b.createModule(.{
             .root_source_file = b.path("src/" ++ @tagName(mod) ++ ".zig"),
             .target = target,
             .optimize = optimize,
-            .filters = &.{test_filter},
             .link_libc = aio.link_libc,
             .sanitize_thread = sanitize,
             .single_threaded = single_threaded,
             .strip = false,
         });
+        const tst = b.addTest(.{
+            .root_module = module,
+            .filters = &.{test_filter},
+        });
         switch (mod) {
             .minilib => addImportsFrom(tst.root_module, minilib),
             .aio => addImportsFrom(tst.root_module, aio),
@@ -119,8 +125,7 @@ pub fn build(b: *std.Build) void {
         .ticker,
         .backend_override,
     }) |bug| {
-        const exe = b.addExecutable(.{
-            .name = @tagName(bug),
+        const module = b.createModule(.{
             .root_source_file = b.path("bugs/" ++ @tagName(bug) ++ ".zig"),
             .target = target,
             .optimize = switch (bug) {
@@ -132,6 +137,10 @@ pub fn build(b: *std.Build) void {
             .single_threaded = single_threaded,
             .strip = false,
         });
+        const exe = b.addExecutable(.{
+            .name = @tagName(bug),
+            .root_module = module,
+        });
         exe.root_module.addImport("aio", aio);
         exe.root_module.addImport("coro", coro);
         var cmd = makeRunStep(b, target, exe, "bug:" ++ @tagName(bug), "Check regression for #" ++ @tagName(bug), .{});
@@ -150,15 +159,18 @@ pub fn build(b: *std.Build) void {
         .spawn_managed,
         .spawn_unmanaged,
     }) |bench| {
-        const exe = b.addExecutable(.{
-            .name = @tagName(bench),
+        const module = b.createModule(.{
             .root_source_file = b.path("bench/" ++ @tagName(bench) ++ ".zig"),
             .target = target,
             .optimize = .ReleaseFast,
             .sanitize_thread = sanitize,
             .single_threaded = single_threaded,
             .strip = false,
         });
+        const exe = b.addExecutable(.{
+            .name = @tagName(bench),
+            .root_module = module,
+        });
         exe.root_module.addImport("aio", aio);
         exe.root_module.addImport("coro", coro);
         const install = b.addInstallArtifact(exe, .{ .dest_dir = .{ .override = .{ .custom = "bench" } } });
diff --git a/build.zig.zon b/build.zig.zon
@@ -4,8 +4,8 @@
     .fingerprint = 0xdf66d422DEADBEEF,
     .dependencies = .{
         .zigwin32 = .{
-            .url = "git+https://github.com/marlersoft/zigwin32.git#0d804dce7632d0912245b1a7aa0384a21629f453",
-            .hash = "zigwin32-25.0.28-preview-AAAAAC8f_AP71CpFWpTOITTECAoWyZB0-yjKlN-H3ePP",
+            .url = "git+https://github.com/marlersoft/zigwin32.git#9d399c0895de4746c1fcab366841e2ab031b0429",
+            .hash = "zigwin32-25.0.28-preview-AAAAANd_5APbcon3QqoYfLKnJ13fiBGJSGq9YrVZsfI-",
             .lazy = true,
         },
     },
diff --git a/examples/coro_wttr.zig b/examples/coro_wttr.zig
@@ -10,37 +10,37 @@ pub const std_options: std.Options = .{
 
 fn getWeather(completed: *std.atomic.Value(u32), allocator: std.mem.Allocator, city: []const u8, lang: []const u8) anyerror![]const u8 {
     defer _ = completed.fetchAdd(1, .monotonic);
-    var url: std.BoundedArray(u8, 256) = .{};
+    var url_buf: [256]u8 = undefined;
+    var url_writer: std.Io.Writer = .fixed(&url_buf);
     if (builtin.target.os.tag == .windows) {
-        try url.writer().print("https://wttr.in/{s}?AFT&lang={s}", .{ city, lang });
+        try url_writer.print("https://wttr.in/{s}?AFT&lang={s}", .{ city, lang });
     } else {
-        try url.writer().print("https://wttr.in/{s}?AF&lang={s}", .{ city, lang });
+        try url_writer.print("https://wttr.in/{s}?AF&lang={s}", .{ city, lang });
     }
-    var body = std.ArrayList(u8).init(allocator);
-    errdefer body.deinit();
+    var body_writer: std.Io.Writer.Allocating = .init(allocator);
     var client: std.http.Client = .{ .allocator = allocator };
     defer client.deinit();
     _ = try client.fetch(.{
-        .location = .{ .url = url.constSlice() },
-        .response_storage = .{ .dynamic = &body },
+        .location = .{ .url = url_writer.buffered() },
+        .response_writer = &body_writer.writer,
     });
-    return body.toOwnedSlice();
+    return try body_writer.toOwnedSlice();
 }
 
 fn getLatestZig(completed: *std.atomic.Value(u32), allocator: std.mem.Allocator) anyerror![]const u8 {
     defer _ = completed.fetchAdd(1, .monotonic);
-    var body = std.ArrayList(u8).init(allocator);
-    defer body.deinit();
+    var body_writer: std.Io.Writer.Allocating = .init(allocator);
+    defer body_writer.deinit();
     var client: std.http.Client = .{ .allocator = allocator };
     defer client.deinit();
     _ = try client.fetch(.{
         .location = .{ .url = "https://ziglang.org/download/index.json" },
-        .response_storage = .{ .dynamic = &body },
+        .response_writer = &body_writer.writer,
     });
     const Index = struct {
         master: struct { version: []const u8 },
     };
-    var parsed = try std.json.parseFromSlice(Index, allocator, body.items, .{ .ignore_unknown_fields = true });
+    var parsed = try std.json.parseFromSlice(Index, allocator, body_writer.written(), .{ .ignore_unknown_fields = true });
     defer parsed.deinit();
     return allocator.dupe(u8, parsed.value.master.version);
 }
@@ -86,13 +86,13 @@ pub fn main() !void {
     var tpool: coro.ThreadPool = try coro.ThreadPool.init(gpa.allocator(), .{});
     defer tpool.deinit();
 
-    var tasks = std.ArrayList(coro.Task.Generic(anyerror![]const u8)).init(allocator);
-    defer tasks.deinit();
+    var tasks: std.ArrayList(coro.Task.Generic(anyerror![]const u8)) = .empty;
+    defer tasks.deinit(allocator);
 
-    try tasks.append(try tpool.spawnForCompletion(&scheduler, getWeather, .{ &completed, allocator, "oulu", "fi" }));
-    try tasks.append(try tpool.spawnForCompletion(&scheduler, getWeather, .{ &completed, allocator, "tokyo", "ja" }));
-    try tasks.append(try tpool.spawnForCompletion(&scheduler, getWeather, .{ &completed, allocator, "portland", "en" }));
-    try tasks.append(try tpool.spawnForCompletion(&scheduler, getLatestZig, .{ &completed, allocator }));
+    try tasks.append(allocator, try tpool.spawnForCompletion(&scheduler, getWeather, .{ &completed, allocator, "oulu", "fi" }));
+    try tasks.append(allocator, try tpool.spawnForCompletion(&scheduler, getWeather, .{ &completed, allocator, "tokyo", "ja" }));
+    try tasks.append(allocator, try tpool.spawnForCompletion(&scheduler, getWeather, .{ &completed, allocator, "portland", "en" }));
+    try tasks.append(allocator, try tpool.spawnForCompletion(&scheduler, getLatestZig, .{ &completed, allocator }));
 
     max = @intCast(tasks.items.len);
     while (completed.load(.acquire) < tasks.items.len) {
@@ -102,18 +102,23 @@ pub fn main() !void {
     // don't really have to call this, but I want the defer that cleans the progress bar to run
     ltask.cancel();
 
+    var stdout_buf: [4096]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writer(&stdout_buf);
+    var stdout = &stdout_writer.interface;
+    defer stdout.flush() catch {};
+
     for (tasks.items, 0..) |task, idx| {
         if (task.complete(.wait)) |body| {
             defer allocator.free(body);
             if (idx == 3) {
-                try std.io.getStdOut().writer().print("\nAaand the current master zig version is... ", .{});
+                try stdout.print("\nAaand the current master zig version is... ", .{});
             }
-            try std.io.getStdOut().writeAll(body);
-            try std.io.getStdOut().writeAll("\n");
+            try stdout.writeAll(body);
+            try stdout.writeAll("\n");
         } else |err| {
-            try std.io.getStdOut().writer().print("request {} failed with: {}\n", .{ idx, err });
+            try stdout.print("request {} failed with: {}\n", .{ idx, err });
         }
     }
 
-    try std.io.getStdOut().writer().print("\nThat's all folks\n", .{});
+    try stdout.print("\nThat's all folks\n", .{});
 }
diff --git a/src/aio.zig b/src/aio.zig
@@ -278,13 +278,13 @@ test "shared outputs" {
     try std.testing.expect(id1 != id2);
     try std.testing.expect(id1 != id3);
     try std.testing.expect(id2 != id3);
-    std.debug.print("{}\n", .{id1});
-    std.debug.print("{}\n", .{id2});
-    std.debug.print("{}\n", .{id3});
+    std.debug.print("{f}\n", .{id1});
+    std.debug.print("{f}\n", .{id2});
+    std.debug.print("{f}\n", .{id3});
     _ = try dynamic.completeAll({});
-    std.debug.print("{}\n", .{id1});
-    std.debug.print("{}\n", .{id2});
-    std.debug.print("{}\n", .{id3});
+    std.debug.print("{f}\n", .{id1});
+    std.debug.print("{f}\n", .{id2});
+    std.debug.print("{f}\n", .{id3});
 }
 
 test "Nop" {
@@ -644,7 +644,7 @@ test "ChildExit" {
         .linux, .freebsd, .openbsd, .dragonfly, .netbsd, .macos, .ios, .watchos, .visionos, .tvos => blk: {
             const pid = try std.posix.fork();
             if (pid == 0) {
-                std.time.sleep(1 * std.time.ns_per_s);
+                std.Thread.sleep(1 * std.time.ns_per_s);
                 std.posix.exit(69);
             }
             break :blk pid;
diff --git a/src/aio/IoUring.zig b/src/aio/IoUring.zig
@@ -161,7 +161,7 @@ pub fn queue(self: *@This(), pairs: anytype, handler: anytype) aio.Error!void {
     if (comptime pairs.len > 1) {
         var ids: std.BoundedArray(aio.Id, pairs.len) = .{};
         errdefer inline for (ids.constSlice(), pairs) |id, pair| {
-            debug("dequeue: {}: {}, {s}", .{ id, pair.tag, @tagName(pair.link) });
+            debug("dequeue: {f}: {any}, {s}", .{ id, pair.tag, @tagName(pair.link) });
             self.ops.release(id) catch unreachable;
         };
         inline for (pairs) |pair| ids.append(try self.queueOperation(pair.tag, pair.op, pair.link)) catch unreachable;
@@ -449,7 +449,7 @@ fn uring_init(n: u16) aio.Error!std.os.linux.IoUring {
 }
 
 fn uring_queue(io: *std.os.linux.IoUring, comptime op_type: Operation, op: op_type.Type(), link: aio.Link, user_data: u64, state: *UringOperation.State) aio.Error!void {
-    debug("queue: {}: {}", .{ aio.Id.init(user_data), op_type });
+    debug("queue: {f}: {}", .{ aio.Id.init(user_data), op_type });
     const Trash = struct {
         var u_64: u64 align(1) = undefined;
     };
@@ -977,13 +977,13 @@ fn uring_handle_completion(comptime op_type: Operation, op: op_type.Type(), stat
             if (op_type == .link_timeout and res == error.Canceled) {
                 // special case
             } else {
-                debug("complete: {}: {} [FAIL] {}", .{ aio.Id.init(cqe.user_data), op_type, res });
+                debug("complete: {f}: {} [FAIL] {}", .{ aio.Id.init(cqe.user_data), op_type, res });
                 return error.OperationFailed;
             }
         }
     }
 
-    debug("complete: {}: {} [OK]", .{ aio.Id.init(cqe.user_data), op_type });
+    debug("complete: {f}: {} [OK]", .{ aio.Id.init(cqe.user_data), op_type });
 
     switch (op_type) {
         .nop => {},
diff --git a/src/aio/Posix.zig b/src/aio/Posix.zig
@@ -184,27 +184,27 @@ pub fn complete(self: *@This(), mode: aio.CompletionMode, handler: anytype) aio.
                             switch (op_type) {
                                 inline else => |tag| {
                                     if (hasField(tag.Type().Error, "BrokenPipe")) {
-                                        Uringlator.debug("poll: {}: {} => ERR (BrokenPipe)", .{ id, op_type });
+                                        Uringlator.debug("poll: {f}: {any} => ERR (BrokenPipe)", .{ id, op_type });
                                         self.uringlator.finish(self, id, error.BrokenPipe, .thread_unsafe);
                                     } else {
-                                        Uringlator.debug("poll: {}: {} => ERR (Unexpected)", .{ id, op_type });
+                                        Uringlator.debug("poll: {f}: {any} => ERR (Unexpected)", .{ id, op_type });
                                         self.uringlator.finish(self, id, error.Unexpected, .thread_unsafe);
                                     }
                                     continue :again;
                                 },
                             }
                         } else {
-                            Uringlator.debug("poll: {}: {} => NVAL (Unexpected)", .{ id, op_type });
+                            Uringlator.debug("poll: {f}: {any} => NVAL (Unexpected)", .{ id, op_type });
                             self.uringlator.finish(self, id, error.Unexpected, .thread_unsafe);
                             continue :again;
                         }
                     }
 
                     // start it for real this time
                     if (self.uringlator.ops.getOne(.next, id) != id) {
-                        Uringlator.debug("ready: {}: {} => {}", .{ id, op_type, self.uringlator.ops.getOne(.next, id) });
+                        Uringlator.debug("ready: {f}: {any} => {f}", .{ id, op_type, self.uringlator.ops.getOne(.next, id) });
                     } else {
-                        Uringlator.debug("ready: {}: {}", .{ id, op_type });
+                        Uringlator.debug("ready: {f}: {any}", .{ id, op_type });
                     }
 
                     try self.uringlator_start(id, op_type);
@@ -500,9 +500,9 @@ pub fn uringlator_start(self: *@This(), id: aio.Id, op_type: Operation) !void {
 
         // pending for readiness, perform the operation later
         if (self.uringlator.ops.getOne(.next, id) != id) {
-            Uringlator.debug("pending: {}: {} => {}", .{ id, op_type, self.uringlator.ops.getOne(.next, id) });
+            Uringlator.debug("pending: {f}: {any} => {f}", .{ id, op_type, self.uringlator.ops.getOne(.next, id) });
         } else {
-            Uringlator.debug("pending: {}: {}", .{ id, op_type });
+            Uringlator.debug("pending: {f}: {any}", .{ id, op_type });
         }
 
         const readiness = self.uringlator.ops.getOne(.readiness, id);
diff --git a/src/aio/posix/wasi.zig b/src/aio/posix/wasi.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 const posix = @import("posix.zig");
+const BoundedArray = @import("minilib").BoundedArray;
 const options = @import("../../aio.zig").options;
 const log = std.log.scoped(.aio_wasi);
 
@@ -207,7 +208,7 @@ fn clock(userdata: usize, timeout: i32) std.os.wasi.subscription_t {
 pub fn poll(fds: []std.posix.pollfd, timeout: i32) std.posix.PollError!usize {
     // TODO: maybe use thread local arena instead?
     const MAX_POLL_FDS = 4096;
-    var subs: std.BoundedArray(std.os.wasi.subscription_t, MAX_POLL_FDS) = .{};
+    var subs: BoundedArray(std.os.wasi.subscription_t, MAX_POLL_FDS) = .{};
     for (fds) |*pfd| {
         pfd.revents = 0;
         if (pfd.events & std.posix.POLL.IN != 0) {
diff --git a/src/aio/uringlator.zig b/src/aio/uringlator.zig
@@ -244,7 +244,7 @@ pub fn Uringlator(BackendOperation: type) type {
 
         fn queueOperation(self: *@This(), comptime tag: Operation, op: anytype, link: aio.Link, backend: anytype) aio.Error!aio.Id {
             const id = self.ops.next() orelse return error.OutOfMemory;
-            debug("queue: {}: {}, {s} ({?})", .{ id, tag, @tagName(link), self.prev_id });
+            debug("queue: {f}: {any}, {s} ({?f})", .{ id, tag, @tagName(link), self.prev_id });
 
             const uop: UringlatorOperation = .{
                 .type = tag,
@@ -285,7 +285,7 @@ pub fn Uringlator(BackendOperation: type) type {
             if (comptime pairs.len > 1) {
                 var ids: std.BoundedArray(aio.Id, pairs.len) = .{};
                 errdefer inline for (ids.constSlice(), pairs) |id, pair| {
-                    debug("dequeue: {}: {}, {s} ({?})", .{ id, pair.tag, @tagName(pair.link), self.prev_id });
+                    debug("dequeue: {f}: {any}, {s} ({?f})", .{ id, pair.tag, @tagName(pair.link), self.prev_id });
                     backend.uringlator_dequeue(id, pair.tag, pair.op);
                     self.ops.release(id) catch unreachable;
                 };
@@ -347,9 +347,9 @@ pub fn Uringlator(BackendOperation: type) type {
 
         fn start(self: *@This(), op_type: Operation, id: aio.Id, backend: anytype) aio.Error!void {
             if (self.ops.getOne(.next, id) != id) {
-                debug("perform: {}: {} => {}", .{ id, op_type, self.ops.getOne(.next, id) });
+                debug("perform: {f}: {any} => {f}", .{ id, op_type, self.ops.getOne(.next, id) });
             } else {
-                debug("perform: {}: {}", .{ id, op_type });
+                debug("perform: {f}: {any}", .{ id, op_type });
             }
             std.debug.assert(!self.started.isSet(id.slot));
             self.started.set(id.slot);
@@ -425,9 +425,9 @@ pub fn Uringlator(BackendOperation: type) type {
                 };
 
                 if (failed) {
-                    debug("complete: {}: {} [FAIL] {}", .{ res.id, op_type, failure });
+                    debug("complete: {f}: {any} [FAIL] {any}", .{ res.id, op_type, failure });
                 } else {
-                    debug("complete: {}: {} [OK]", .{ res.id, op_type });
+                    debug("complete: {f}: {any} [OK]", .{ res.id, op_type });
                 }
 
                 num_errors += @intFromBool(failed);
@@ -497,7 +497,7 @@ pub fn Uringlator(BackendOperation: type) type {
         };
 
         pub fn finish(self: *@This(), backend: anytype, id: aio.Id, failure: Operation.Error, comptime safety: Safety) void {
-            debug("finish: {} {}", .{ id, failure });
+            debug("finish: {f} {any}", .{ id, failure });
             if (safety == .thread_unsafe) self.ops.lookup(id) catch unreachable; // trying to finish nonexistant id
             self.finished.add(.{ .id = id, .failure = failure }) catch unreachable;
             backend.uringlator_notify(safety);
diff --git a/src/coro/Frame.zig b/src/coro/Frame.zig
diff --git a/src/coro/ThreadPool.zig b/src/coro/ThreadPool.zig
diff --git a/src/coro/zefi.zig b/src/coro/zefi.zig
diff --git a/src/minilib/id.zig b/src/minilib/id.zig

Original file line number	Diff line number	Diff line change
`@@ -23,11 +23,15 @@ fn protection(comptime func: anytype, args: anytype) void {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`pub fn logInfo(comptime format: []const u8, args: anytype) void {`
`26`		`- std.io.getStdOut().writer().print(format, args) catch return;`
	`26`	`+ var buf: [4096]u8 = undefined;`
	`27`	`+ var writer = std.fs.File.stdout().writerStreaming(&buf);`
	`28`	`+ writer.interface.print(format, args) catch return;`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`pub fn logErr(comptime format: []const u8, args: anytype) void {`
`30`		`- std.io.getStdErr().writer().print(format, args) catch return;`
	`32`	`+ var buf: [4096]u8 = undefined;`
	`33`	`+ var writer = std.fs.File.stderr().writerStreaming(&buf);`
	`34`	`+ writer.interface.print(format, args) catch return;`
`31`	`35`	`}`
`32`	`36`
`33`	`37`	`pub fn delay(ns: u128) !void {`