Merge pull request #32 from bernardassan/zig-0.15.2

mookums · web-flow · commit 26cbc3cab799 · 2026-01-02T20:19:33.000-08:00
Update Supported Zig Version to 0.15.2
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -18,7 +18,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.1
+          version: 0.15.2
       - name: Build Examples
         run: zig build -Dexample=all
       - name: Run unit tests
@@ -35,7 +35,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.1
+          version: 0.15.2
       - name: Generate random 64-bit integer
         id: random
         shell: bash
@@ -54,7 +54,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.1
+          version: 0.15.2
       - name: Generate random 64-bit integer
         id: random
         shell: bash
@@ -70,7 +70,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: mlugg/setup-zig@v2
         with:
-          version: 0.15.1
+          version: 0.15.2
       - name: Generate random 64-bit integer
         id: random
         shell: pwsh
diff --git a/README.md b/README.md
@@ -17,7 +17,7 @@ tardy is a thread-local, I/O driven runtime for Zig, providing the core implemen
 - Coroutines (internally called Frames).
 
 ## Installing
-Compatible Zig Version: `0.14.0`
+Compatible Zig Version: `0.15.2`
 
 Latest Release: `0.3.0`
 ```
@@ -60,72 +60,82 @@ A basic multi-threaded TCP echo server.
 
 ```zig
 const std = @import("std");
-const log = std.log.scoped(.@"tardy/example/echo");
 
+const AcceptResult = @import("tardy").AcceptResult;
+const Cross = @import("tardy").Cross;
 const Pool = @import("tardy").Pool;
+const RecvResult = @import("tardy").RecvResult;
 const Runtime = @import("tardy").Runtime;
-const Task = @import("tardy").Task;
-const Tardy = @import("tardy").Tardy(.auto);
-const Cross = @import("tardy").Cross;
-
+const SendResult = @import("tardy").SendResult;
 const Socket = @import("tardy").Socket;
+const Task = @import("tardy").Task;
 const Timer = @import("tardy").Timer;
 
-const AcceptResult = @import("tardy").AcceptResult;
-const RecvResult = @import("tardy").RecvResult;
-const SendResult = @import("tardy").SendResult;
+const Tardy = @import("tardy").Tardy(.auto);
+const log = std.log.scoped(.@"tardy/example/echo");
 
 fn echo_frame(rt: *Runtime, server: *const Socket) !void {
     const socket = try server.accept(rt);
     defer socket.close_blocking();
 
-    // you can use the standard Zig Reader/Writer if you want!
-    const reader = socket.reader(rt);
-    const writer = socket.writer(rt);
+    var sock_reader = socket.reader(rt, &.{});
+    const sock_r = &sock_reader.interface;
+
+    var sock_writer = socket.writer(rt, &.{});
+    const sock_w = &sock_writer.interface;
+    defer sock_w.flush() catch unreachable;
 
     log.debug(
-        "{d} - accepted socket [{}]",
+        "{d} - accepted socket [{f}]",
         .{ std.time.milliTimestamp(), socket.addr },
     );
 
+    // spawn off a new frame.
     try rt.spawn(.{ rt, server }, echo_frame, 1024 * 16);
 
-    var buffer: [1024]u8 = undefined;
+    var buffer: [501]u8 = undefined;
     while (true) {
-        const recv_length = reader.read(&buffer) catch |e| {
-            log.err("Failed to recv on socket | {}", .{e});
-            return;
+        const recv_length = sock_r.readSliceShort(&buffer) catch |e| {
+            log.err("Failed to recv on socket | {t}", .{e});
+            break;
         };
 
-        writer.writeAll(buffer[0..recv_length]) catch |e| {
-            log.err("Failed to send on socket | {}", .{e});
-            return;
+        if (recv_length == 0) return;
+
+        sock_w.writeAll(buffer[0..recv_length]) catch |e| {
+            log.err("Failed to send on socket | {t}", .{e});
+            break;
         };
 
         log.debug("Echoed: {s}", .{buffer[0..recv_length]});
     }
 }
 
 pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var gpa: std.heap.DebugAllocator(.{}) = .init;
     const allocator = gpa.allocator();
     defer _ = gpa.deinit();
 
-    // tardy by default is 
-    // - multithreaded
-    // - unbounded in terms of spawnable tasks
-    var tardy = try Tardy.init(allocator, .{});
+    var tardy: Tardy = try .init(allocator, .{
+        .threading = .single,
+        .pooling = .static,
+        .size_tasks_initial = 256,
+        .size_aio_reap_max = 256,
+    });
     defer tardy.deinit();
 
-    const server = try Socket.init(.{ .tcp = .{ .host = "127.0.0.1", .port = 9862 } });
+    const host = "0.0.0.0";
+    const port = 9862;
+
+    const server: Socket = try .init(.{ .tcp = .{ .host = host, .port = port } });
     try server.bind();
-    try server.listen(256);
+    try server.listen(1024);
 
     try tardy.entry(
         &server,
         struct {
             fn start(rt: *Runtime, tcp_server: *const Socket) !void {
-                try rt.spawn(.{ rt, tcp_server }, echo_frame, 1024 * 1024 * 4);
+                try rt.spawn(.{ rt, tcp_server }, echo_frame, 1024 * 16);
             }
         }.start,
     );
@@ -143,7 +153,7 @@ We use Nix Flakes for managing the development environment. Nix Flakes provide a
 
 ### Prerequisites
  - Install [Nix](https://nixos.org/download/)
-```bash 
+```bash
 sh <(curl -L https://nixos.org/nix/install) --daemon
 ```
  - Enable [Flake support](https://nixos.wiki/wiki/Flakes) in your Nix config (`~/.config/nix/nix.conf`): `experimental-features = nix-command flakes`
diff --git a/build.zig b/build.zig
@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 
 const AsyncKind = @import("src/aio/lib.zig").AsyncKind;
 
-const zig_version = std.SemanticVersion{ .major = 0, .minor = 15, .patch = 1 };
+const zig_version = std.SemanticVersion{ .major = 0, .minor = 15, .patch = 2 };
 comptime {
     // Compare versions while allowing different pre/patch metadata.
     const zig_version_eq = zig_version.major == builtin.zig_version.major and
diff --git a/build.zig.zon b/build.zig.zon
@@ -2,9 +2,8 @@
     .name = .tardy,
     .fingerprint = 0x36d7fa71822bdceb,
     .version = "0.3.0",
-    .minimum_zig_version = "0.14.0",
+    .minimum_zig_version = "0.15.2",
     .dependencies = .{},
-
     .paths = .{
         "README.md",
         "LICENSE",
diff --git a/examples/basic/main.zig b/examples/basic/main.zig
@@ -17,7 +17,9 @@ fn log_frame(rt: *Runtime) !void {
 }
 
 pub fn main() !void {
-    const allocator = std.heap.page_allocator;
+    var gpa: std.heap.DebugAllocator(.{}) = .init;
+    const allocator = gpa.allocator();
+    defer _ = gpa.deinit();
 
     var tardy: Tardy = try .init(allocator, .{
         .threading = .single,
diff --git a/examples/echo/main.zig b/examples/echo/main.zig
@@ -32,18 +32,14 @@ fn echo_frame(rt: *Runtime, server: *const Socket) !void {
     // spawn off a new frame.
     try rt.spawn(.{ rt, server }, echo_frame, 1024 * 16);
 
-    //TODO: investigate why using readSliceShort with a buffer bigger
-    // than reader size leads to a connection reset (try to get a repro)
     var buffer: [501]u8 = undefined;
     while (true) {
         const recv_length = sock_r.readSliceShort(&buffer) catch |e| {
             log.err("Failed to recv on socket | {t}", .{e});
             break;
         };
 
-        if (recv_length == 0) {
-            break;
-        }
+        if (recv_length == 0) return;
 
         sock_w.writeAll(buffer[0..recv_length]) catch |e| {
             log.err("Failed to send on socket | {t}", .{e});
diff --git a/src/aio/apis/epoll.zig b/src/aio/apis/epoll.zig
@@ -46,7 +46,7 @@ pub const AsyncEpoll = struct {
         const events = try allocator.alloc(std.os.linux.epoll_event, options.size_aio_reap_max);
         errdefer allocator.free(events);
 
-        var jobs = try Pool(Job).init(allocator, size, options.pooling);
+        var jobs: Pool(Job) = try .init(allocator, size, options.pooling);
         errdefer jobs.deinit();
 
         // Queue the wake task.
@@ -65,7 +65,7 @@ pub const AsyncEpoll = struct {
 
         try std.posix.epoll_ctl(epoll_fd, std.os.linux.EPOLL.CTL_ADD, wake_event_fd, &event);
 
-        return AsyncEpoll{
+        return .{
             .epoll_fd = epoll_fd,
             .wake_event_fd = wake_event_fd,
             .events = events,
@@ -463,7 +463,7 @@ pub const AsyncEpoll = struct {
     pub fn to_async(self: *AsyncEpoll) Async {
         return Async{
             .runner = self,
-            .features = AsyncFeatures.init(&.{
+            .features = .init(&.{
                 .timer,
                 .accept,
                 .connect,
diff --git a/src/aio/apis/io_uring.zig b/src/aio/apis/io_uring.zig
@@ -116,7 +116,7 @@ pub const AsyncIoUring = struct {
                 const uring = try allocator.create(std.os.linux.IoUring);
                 errdefer allocator.destroy(uring);
 
-                uring.* = try std.os.linux.IoUring.init_params(submit_size, &params);
+                uring.* = try .init_params(submit_size, &params);
                 errdefer uring.deinit();
 
                 break :blk uring;
@@ -125,7 +125,7 @@ pub const AsyncIoUring = struct {
                 const uring = try allocator.create(std.os.linux.IoUring);
                 errdefer allocator.destroy(uring);
 
-                uring.* = try std.os.linux.IoUring.init(submit_size, base_flags);
+                uring.* = try .init(submit_size, base_flags);
                 errdefer uring.deinit();
 
                 break :blk uring;
@@ -134,7 +134,7 @@ pub const AsyncIoUring = struct {
         errdefer allocator.destroy(uring);
         errdefer uring.deinit();
 
-        var jobs = try Pool(JobBundle).init(allocator, size, options.pooling);
+        var jobs: Pool(JobBundle) = try .init(allocator, size, options.pooling);
         errdefer jobs.deinit();
 
         const index = jobs.borrow_assume_unset(0);
diff --git a/src/aio/apis/kqueue.zig b/src/aio/apis/kqueue.zig
@@ -42,7 +42,7 @@ pub const AsyncKqueue = struct {
 
         const events = try allocator.alloc(std.posix.Kevent, options.size_aio_reap_max);
         const changes = try allocator.alloc(std.posix.Kevent, options.size_aio_reap_max);
-        var jobs = try Pool(Job).init(allocator, options.size_tasks_initial + 1, options.pooling);
+        var jobs: Pool(Job) = try .init(allocator, options.size_tasks_initial + 1, options.pooling);
 
         const index = jobs.borrow_assume_unset(0);
         const item = jobs.get_ptr(index);
@@ -503,7 +503,7 @@ pub const AsyncKqueue = struct {
     pub fn to_async(self: *AsyncKqueue) Async {
         return Async{
             .runner = self,
-            .features = AsyncFeatures.init(&.{
+            .features = .init(&.{
                 .timer,
                 .accept,
                 .connect,
diff --git a/src/aio/apis/poll.zig b/src/aio/apis/poll.zig
@@ -53,7 +53,7 @@ pub const AsyncPoll = struct {
                 const server_socket = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.STREAM, 0);
                 defer std.posix.close(server_socket);
 
-                const addr = std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 0);
+                const addr: std.net.Address = .initIp4(.{ 127, 0, 0, 1 }, 0);
                 try std.posix.bind(server_socket, &addr.any, addr.getOsSockLen());
 
                 var binded_addr: std.posix.sockaddr = undefined;
@@ -89,10 +89,10 @@ pub const AsyncPoll = struct {
             try fd_job_map.put(pipe[0], .{ .index = 0, .type = .wake, .task = 0 });
         }
 
-        const timers = TimerQueue.init(allocator, {});
+        const timers: TimerQueue = .init(allocator, {});
         errdefer timers.deinit();
 
-        return AsyncPoll{
+        return .{
             .allocator = allocator,
             .wake_pipe = pipe,
             .fd_list = fd_list,
@@ -405,7 +405,7 @@ pub const AsyncPoll = struct {
     pub fn to_async(self: *AsyncPoll) Async {
         return Async{
             .runner = self,
-            .features = AsyncFeatures.init(&.{
+            .features = .init(&.{
                 .timer,
                 .accept,
                 .connect,
diff --git a/src/channel/spsc.zig b/src/channel/spsc.zig
@@ -107,7 +107,7 @@ pub fn Spsc(comptime T: type) type {
 
         pub fn init(allocator: std.mem.Allocator, size: usize) !Self {
             return .{
-                .ring = try SpscAtomicRing(T).init(allocator, size),
+                .ring = try .init(allocator, size),
 
                 .producer_rt = .{ .raw = null },
                 .producer_index = .{ .raw = 0 },
diff --git a/src/core/atomic_ring.zig b/src/core/atomic_ring.zig
@@ -52,7 +52,7 @@ pub fn SpscAtomicRing(comptime T: type) type {
 
 test "SpscAtomicRing: Fill and Empty" {
     const size: u32 = 128;
-    var ring = try SpscAtomicRing(usize).init(testing.allocator, size);
+    var ring: SpscAtomicRing(usize) = try .init(testing.allocator, size);
     defer ring.deinit();
 
     try testing.expectError(error.RingEmpty, ring.pop());
diff --git a/src/core/ring.zig b/src/core/ring.zig
@@ -78,7 +78,7 @@ pub fn Ring(comptime T: type) type {
 
 test "Ring Send and Recv" {
     const size: u32 = 100;
-    var ring = try Ring(usize).init(testing.allocator, size);
+    var ring: Ring(usize) = try .init(testing.allocator, size);
     defer ring.deinit();
 
     for (0..size) |i| {
diff --git a/src/core/zero_copy.zig b/src/core/zero_copy.zig
@@ -131,13 +131,13 @@ test "ZeroCopy: Growth" {
     var zc: ZeroCopy(u8) = try .init(testing.allocator, 16);
     defer zc.deinit();
 
-    const large_data = &[_]u8{1} ** 32;
+    const large_data: [32]u8 = @splat(1);
     const write_area = try zc.get_write_area(large_data.len);
-    @memcpy(write_area, large_data);
+    @memcpy(write_area, &large_data);
     zc.mark_written(write_area.len);
 
     try testing.expect(zc.capacity >= 32);
-    try testing.expectEqualSlices(u8, large_data, zc.as_slice());
+    try testing.expectEqualSlices(u8, large_data[0..], zc.as_slice());
 }
 
 test "ZeroCopy: Multiple Writes" {
diff --git a/src/runtime/lib.zig b/src/runtime/lib.zig
@@ -33,12 +33,12 @@ pub const Runtime = struct {
     current_task: ?usize = null,
 
     pub fn init(allocator: std.mem.Allocator, aio: Async, options: RuntimeOptions) !Runtime {
-        const scheduler = try Scheduler.init(
+        const scheduler: Scheduler = try .init(
             allocator,
             options.size_tasks_initial,
             options.pooling,
         );
-        const storage = Storage.init(allocator);
+        const storage: Storage = .init(allocator);
 
         return .{
             .allocator = allocator,
diff --git a/src/runtime/scheduler.zig b/src/runtime/scheduler.zig
diff --git a/src/runtime/storage.zig b/src/runtime/storage.zig

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,9 @@ fn log_frame(rt: *Runtime) !void {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`pub fn main() !void {`
`20`		`- const allocator = std.heap.page_allocator;`
	`20`	`+ var gpa: std.heap.DebugAllocator(.{}) = .init;`
	`21`	`+ const allocator = gpa.allocator();`
	`22`	`+ defer _ = gpa.deinit();`
`21`	`23`
`22`	`24`	`var tardy: Tardy = try .init(allocator, .{`
`23`	`25`	`.threading = .single,`