Module sync/barrier

Reusable N-party barrier — the generation model, the same one Rust's std::sync::Barrier and POSIX pthread_barrier_t carry.

Every thread that calls wait() blocks until parties threads have called it. All of them are then released together, the barrier resets, and it can be used again for the next round. Exactly one of the released threads — the last to arrive, which is the one that tripped the barrier — gets true back from wait(), so a caller can nominate a single thread to do the between-rounds bookkeeping (Rust spells this BarrierWaitResult::is_leader).

{ Barrier } :: import "std/sync/barrier";
{ Thread } :: import "std/thread";

b := Barrier.new(i32(3));
t1 := Thread(unit).spawn((io) => { b.wait(); });
t2 := Thread(unit).spawn((io) => { b.wait(); });
b.wait();  // the third party — all three proceed from here
t1.join();
t2.join();

Stability

stable — new, wait, parties, generation and waiting follow the generation model std::sync::Barrier and pthread_barrier_t both carry, and wait's single true is Rust's BarrierWaitResult::is_leader without the wrapper struct. generation and waiting are observability, so they are honest about being a SNAPSHOT: by the time you read either, another party may have arrived.