sync.Counter

sync.zig

pub const Counter = struct {
    const Self = @This();

    state: isize = 0,
    event: Event = .{},

    pub fn add(self: *Self, delta: isize) void {
        var state = @atomicLoad(isize, &self.state, .Monotonic);
        var new_state: isize = undefined;

        while (true) {
            new_state = state + delta;

            state = @cmpxchgWeak(
                isize,
                &self.state,
                state,
                new_state,
                .Monotonic,
                .Monotonic,
            ) orelse break;
        }

        if (new_state == 0) {
            self.event.notify();
        }
    }

    pub fn wait(self: *Self) void {
        self.event.wait();
    }
};

pub const Event = struct {
    state: ?*pike.Task = null,

    var notified: pike.Task = undefined;

    pub fn wait(self: *Event) void {
        var task = pike.Task.init(@frame());
        suspend {
            var state = @atomicLoad(?*pike.Task, &self.state, .Monotonic);
            while (true) {
                const new_state = if (state == &notified) null else if (state == null) &task else unreachable;

                state = @cmpxchgWeak(
                    ?*pike.Task,
                    &self.state,
                    state,
                    new_state,
                    .Release,
                    .Monotonic,
                ) orelse {
                    if (new_state == null) pike.dispatch(&task, .{});
                    break;
                };
            }
        }
    }

    pub fn notify(self: *Event) void {
        var state = @atomicLoad(?*pike.Task, &self.state, .Monotonic);
        while (true) {
            if (state == &notified)
                return;

            const new_state = if (state == null) &notified else null;
            state = @cmpxchgWeak(
                ?*pike.Task,
                &self.state,
                state,
                new_state,
                .Acquire,
                .Monotonic,
            ) orelse {
                if (state) |task| pike.dispatch(task, .{});
                break;
            };
        }
    }
};