dca396ed1f
compare_exchange/_weak wired end-to-end except LLVM emission (bails loudly;
A.2b makes it real). New IR op atomic_cmpxchg + AtomicCmpxchg{ptr, cmp, new,
val_ty, success_ordering, failure_ordering, weak}; result type = ?T (null =
SUCCESS, failure carries the actual value for retry). print arm; emit dispatch
-> emitAtomicCmpxchg (BAILS). comptime_vm arm does real single-thread CAS (read
actual / compare / store-on-equal / build ?T: success->none, failure->some;
weak == strong at comptime). Recognizer extended (atomic_cmpxchg/_weak, 6 args)
-- CAS restricted to INTEGER T (loud reject); BOTH orderings resolved via
atomicOrderingFromNode; dual-ordering validation (failure may not be
release/acq_rel nor stronger than success, via atomicOrderingRank). Methods
compare_exchange/_weak on Atomic($T) with comptime $success/$failure: Ordering.
examples/1702 locked to the bail; examples/1186 locks a rejected ordering pair.
Suite green (718/0).
82 lines
4.9 KiB
Plaintext
82 lines
4.9 KiB
Plaintext
// Atomics — `Atomic($T)` wrapper + `Ordering`, over the compiler's atomic
|
|
// load/store (later: rmw/cas/fence) IR ops. Consumers reach these through
|
|
// std.sx (`Atomic` / `Ordering` re-exports), never by importing this file.
|
|
//
|
|
// Atomicity is a property of the OPERATION, not the storage: `Atomic(T)` is a
|
|
// transparent 1-field wrapper with `T`'s exact layout/size/align. The ops are
|
|
// `#builtin` intrinsics recognized by name at lower-time
|
|
// (`tryLowerAtomicIntrinsic`, src/ir/lower/call.zig) and emitted as dedicated
|
|
// atomic IR ops; the `Ordering` argument MUST be a constant enum literal.
|
|
#import "modules/std/core.sx";
|
|
|
|
Ordering :: enum {
|
|
relaxed; // → LLVM Monotonic
|
|
acquire; // → LLVM Acquire
|
|
release; // → LLVM Release
|
|
acq_rel; // → LLVM AcquireRelease
|
|
seq_cst; // → LLVM SequentiallyConsistent
|
|
}
|
|
|
|
// Compiler intrinsics. Not called directly by users — `Atomic(T)`'s methods
|
|
// forward to them. Recognized by name in lowering; the `Ordering` arg MUST be a
|
|
// constant enum literal (a non-literal is a loud diagnostic).
|
|
atomic_load :: ($T: Type, ptr: *T, o: Ordering) -> T #builtin;
|
|
atomic_store :: ($T: Type, ptr: *T, v: T, o: Ordering) #builtin;
|
|
|
|
// Read-modify-write intrinsics — integer T only. Each returns the OLD value.
|
|
// `min`/`max` are signed or unsigned per T. (No `nand`.)
|
|
atomic_fetch_add :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
atomic_fetch_sub :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
atomic_fetch_and :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
atomic_fetch_or :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
atomic_fetch_xor :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
atomic_fetch_min :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
atomic_fetch_max :: ($T: Type, ptr: *T, operand: T, o: Ordering) -> T #builtin;
|
|
|
|
// Compare-exchange intrinsics — integer T only. The result is `?T`:
|
|
// `null` = SUCCESS (the stored value equalled `expected`, replaced by `desired`);
|
|
// a present value is the ACTUAL current value on failure (for a retry loop).
|
|
// `_weak` may fail spuriously (LLVM `cmpxchg weak`) — use it inside a retry loop.
|
|
// Two orderings: `success` (applied when the exchange happens) and `failure`
|
|
// (the load when it doesn't). The failure ordering may not be .release / .acq_rel
|
|
// and may not be stronger than the success ordering (LLVM rule, enforced at lower).
|
|
atomic_cmpxchg :: ($T: Type, ptr: *T, expected: T, desired: T, success: Ordering, failure: Ordering) -> ?T #builtin;
|
|
atomic_cmpxchg_weak :: ($T: Type, ptr: *T, expected: T, desired: T, success: Ordering, failure: Ordering) -> ?T #builtin;
|
|
|
|
// The ordering is a COMPTIME value param (`$o`): it must be known at compile
|
|
// time because LLVM atomic ordering is an instruction attribute, not a runtime
|
|
// operand. It is explicit (Rust-style — no default), so the caller always states
|
|
// the ordering: `a.load(.acquire)`, `a.store(v, .release)`. An invalid
|
|
// combination (`a.load(.release)`) is a compile error.
|
|
Atomic :: struct ($T: Type) {
|
|
value: T;
|
|
|
|
init :: (v: T) -> Atomic(T) {
|
|
return .{ value = v };
|
|
}
|
|
|
|
load :: (self: *Atomic(T), $o: Ordering) -> T {
|
|
return atomic_load(T, @self.value, o);
|
|
}
|
|
|
|
store :: (self: *Atomic(T), v: T, $o: Ordering) {
|
|
atomic_store(T, @self.value, v, o);
|
|
}
|
|
|
|
// Read-modify-write (integer T). Each returns the value BEFORE the update.
|
|
fetch_add :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_add(T, @self.value, v, o); }
|
|
fetch_sub :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_sub(T, @self.value, v, o); }
|
|
fetch_and :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_and(T, @self.value, v, o); }
|
|
fetch_or :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_or(T, @self.value, v, o); }
|
|
fetch_xor :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_xor(T, @self.value, v, o); }
|
|
fetch_min :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_min(T, @self.value, v, o); }
|
|
fetch_max :: (self: *Atomic(T), v: T, $o: Ordering) -> T { return atomic_fetch_max(T, @self.value, v, o); }
|
|
|
|
// Compare-exchange (integer T). Returns `?T`: `null` on success (the value
|
|
// equalled `expected` and is now `desired`); on failure the ACTUAL current
|
|
// value (retry with it). `compare_exchange_weak` may fail spuriously — use it
|
|
// inside a retry loop. `$success` / `$failure` are comptime ordering params.
|
|
compare_exchange :: (self: *Atomic(T), expected: T, desired: T, $success: Ordering, $failure: Ordering) -> ?T { return atomic_cmpxchg(T, @self.value, expected, desired, success, failure); }
|
|
compare_exchange_weak :: (self: *Atomic(T), expected: T, desired: T, $success: Ordering, $failure: Ordering) -> ?T { return atomic_cmpxchg_weak(T, @self.value, expected, desired, success, failure); }
|
|
}
|