Commit d821446cf92b9b8974ec4a3e5d7be883d1741b4e | zig

author	Lukas Lalinsky <lukas@lalinsky.com> 2026-02-19 12:07:54+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-04-16 13:37:23-07:00
log	d821446cf92b9b8974ec4a3e5d7be883d1741b4e
tree	4d92045a58d4301849dca96d90006b926d92fd80
parent	a8226cd536f50fd14c059812388b87bf99324d51

Implement `Condition.waitTimeout`

I'd have preferred if `vtable.futexWait` returned `error.Timeout`, since
all the OS-level APIs provide it. However, if I keep the vtable untouched,
I had to determine the timeout case by post-checking the deadline.
It's fine functionally, but one extra syscall that be avoided at
cost of changing the vtable and all the futex implementations.

2 files changed, 69 insertions(+), 9 deletions(-)

lib
- std
  - Io.zig
  - Io
    test.zig

lib/std/Io.zig+25-9

 @@ -1682,19 +1682,27 @@ pub const Condition = struct {
     };
     pub fn wait(cond: *Condition, io: Io, mutex: *Mutex) Cancelable!void {
-        try waitInner(cond, io, mutex, false);
+        waitInner(cond, io, mutex, .{ .timeout = .none }) catch |err| switch (err) {
+            error.Timeout => unreachable,
+            error.Canceled => return error.Canceled,
+        };
+    }
+    pub fn waitTimeout(cond: *Condition, io: Io, mutex: *Mutex, timeout: Timeout) (Cancelable || Timeout.Error)!void {
+        return waitInner(cond, io, mutex, .{ .timeout = timeout.toDeadline(io) });
     }
     /// Same as `wait`, except does not introduce a cancelation point.
     ///
     /// For a description of cancelation and cancelation points, see `Future.cancel`.
     pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
-        waitInner(cond, io, mutex, true) catch |err| switch (err) {
+        waitInner(cond, io, mutex, .uncancelable) catch |err| switch (err) {
+            error.Timeout => unreachable,
             error.Canceled => unreachable,
         };
     }
-    fn waitInner(cond: *Condition, io: Io, mutex: *Mutex, uncancelable: bool) Cancelable!void {
+    fn waitInner(cond: *Condition, io: Io, mutex: *Mutex, mode: union(enum) { uncancelable, timeout: Timeout }) (Cancelable || Timeout.Error)!void {
         var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
         {
 @@ -1706,10 +1714,10 @@ pub const Condition = struct {
         defer mutex.lockUncancelable(io);
         while (true) {
-            const result = if (uncancelable)
+            const result = switch (mode) {
-                io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch)
+                .uncancelable => io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch),
-            else
+                .timeout => |t| io.futexWaitTimeout(u32, &cond.epoch.raw, epoch, t),
-                io.futexWait(u32, &cond.epoch.raw, epoch);
+            };
             epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
 @@ -1729,13 +1737,21 @@ pub const Condition = struct {
             }
             // There are no more signals available; this was a spurious wakeup or an error. If it
-            // was an error, we will remove ourselves as a waiter and return that error. Otherwise,
+            // was an error, we will remove ourselves as a waiter and return that error. If a
-            // we'll loop back to the futex wait.
+            // timeout was specified and the deadline has passed, we remove ourselves as a waiter
+            // and return `error.Timeout`. Otherwise, we'll loop back to the futex wait.
             result catch |err| {
                 const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
                 assert(prev_state.waiters > 0); // underflow caused by illegal state
                 return err;
             };
+            if (mode == .timeout and mode.timeout != .none) {
+                if (mode.timeout.deadline.untilNow(io).raw.nanoseconds >= 0) {
+                    const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
+                    assert(prev_state.waiters > 0); // underflow caused by illegal state
+                    return error.Timeout;
+                }
+            }
         }
     }

lib/std/Io/test.zig+44

...	@@ -971,3 +971,47 @@ test "Select.cancel with no tasks, no deadlock" {	...	@@ -971,3 +971,47 @@ test "Select.cancel with no tasks, no deadlock" {
971	var select: Io.Select(U) = .init(io, &.{});	971	var select: Io.Select(U) = .init(io, &.{});
972	try expectEqual(null, select.cancel());	972	try expectEqual(null, select.cancel());
973	}	973	}
		974
		975	test "Condition" {
		976	if (builtin.single_threaded) return error.SkipZigTest;
		977	const io = testing.io;
		978
		979	const TestContext = struct {
		980	ready: Io.Event = .unset,
		981	mutex: Io.Mutex = .init,
		982	cond: Io.Condition = .init,
		983	value: u32 = 0,
		984
		985	fn worker(ctx: *@This()) !void {
		986	defer ctx.ready.set(io);
		987
		988	try ctx.mutex.lock(io);
		989	defer ctx.mutex.unlock(io);
		990
		991	try expectError(error.Timeout, ctx.cond.waitTimeout(io, &ctx.mutex, .{ .duration = .{
		992	.raw = .fromMilliseconds(1),
		993	.clock = .awake,
		994	} }));
		995	try expectEqual(0, ctx.value);
		996
		997	ctx.ready.set(io);
		998
		999	while (ctx.value == 0) try ctx.cond.wait(io, &ctx.mutex);
		1000	try expectEqual(1, ctx.value);
		1001	}
		1002	};
		1003
		1004	var ctx: TestContext = .{};
		1005
		1006	var future = try io.concurrent(TestContext.worker, .{&ctx});
		1007	defer future.cancel(io) catch {};
		1008
		1009	try ctx.ready.wait(io);
		1010
		1011	try ctx.mutex.lock(io);
		1012	ctx.value = 1;
		1013	ctx.mutex.unlock(io);
		1014	ctx.cond.signal(io);
		1015
		1016	try future.await(io);
		1017	}