std.atomics

atomic ops; rmw returns the previous value; helpers are seq-cst

Relaxed

pub Relaxed :: 0

orderings for core::atomic_*; must be comptime-known

Acquire

pub Acquire :: 1

Release

pub Release :: 2

AcqRel

pub AcqRel  :: 3

SeqCst

pub SeqCst  :: 4

Native

pub Native :: constraint($T)

int, float, bool or pointer, at most word-sized

Numeric

pub Numeric :: constraint($T)

int or float, for add/sub/mul/div

Integer

pub Integer :: constraint($T)

int only: bitwise, shifts, min/max

Boolean

pub Boolean :: constraint($T)

for flag helpers

load

pub load :: fn($T: Native, p: *T) -> T

store

pub store :: fn($T: Native, p: *T, v: T)

load_acquire

pub load_acquire :: fn($T: Native, p: *T) -> T

acquire load; pairs with store_release

store_release

pub store_release :: fn($T: Native, p: *T, v: T)

release store; pairs with load_acquire

swap

pub swap :: fn($T: Native, p: *T, v: T) -> T

returns the previous value

compare_exchange

pub compare_exchange :: fn($T: Native, p: *T, expected: T, desired: T) -> bool

true if *p was expected and is now desired

compare_exchange_value

pub compare_exchange_value :: fn($T: Native, p: *T, expected: T, desired: T) -> T

returns the observed value (== expected on success)

fetch_add

pub fetch_add :: fn($T: Numeric, p: *T, v: T) -> T

native for ints and floats

fetch_sub

pub fetch_sub :: fn($T: Numeric, p: *T, v: T) -> T

fetch_mul

pub fetch_mul :: fn($T: Numeric, p: *T, v: T) -> T

no hardware atomic; cas retry loop

fetch_div

pub fetch_div :: fn($T: Numeric, p: *T, v: T) -> T

fetch_max

pub fetch_max :: fn($T: Integer, p: *T, v: T) -> T

min / max (ints; signedness from T)

fetch_min

pub fetch_min :: fn($T: Integer, p: *T, v: T) -> T

fetch_and

pub fetch_and :: fn($T: Integer, p: *T, v: T) -> T

bitwise (ints; returns the previous value)

fetch_or

pub fetch_or :: fn($T: Integer, p: *T, v: T) -> T

fetch_xor

pub fetch_xor :: fn($T: Integer, p: *T, v: T) -> T

fetch_nand

pub fetch_nand :: fn($T: Integer, p: *T, v: T) -> T

fetch_shl

pub fetch_shl :: fn($T: Integer, p: *T, bits: T) -> T

no hardware atomic; cas retry loops

fetch_shr

pub fetch_shr :: fn($T: Integer, p: *T, bits: T) -> T

fence

pub fence :: fn()

seq-cst fence

fence_acquire

pub fence_acquire :: fn()

nothing after it moves before it

fence_release

pub fence_release :: fn()

nothing before it moves after it

is_set

pub is_set :: fn(flag: *u32) -> bool

test_and_set

pub test_and_set :: fn(flag: *u32) -> bool

sets to 1; returns whether it was already set

clear

pub clear :: fn(flag: *u32)

wait_until_set

pub wait_until_set :: fn(flag: *u32)

busy-waits

wait_until_eq

pub wait_until_eq :: fn(flag: *u32, value: u32)

busy-waits until *flag == value

spin_lock

pub spin_lock :: fn(lock: *u32)

spins on test_and_set until it wins 0 -> 1

spin_unlock

pub spin_unlock :: fn(lock: *u32)

Atomic

pub Atomic :: struct($T: Native) {
    value: T,
}

typed atomic cell; methods skip the Integer/Numeric checks the free fns do

Atomic.make

pub make :: fn(v: T) -> Self

Atomic.get

pub get :: fn(self: *Self) -> T

Atomic.set

pub set :: fn(self: *Self, v: T)

Atomic.get_acquire

pub get_acquire :: fn(self: *Self) -> T

Atomic.set_release

pub set_release :: fn(self: *Self, v: T)

Atomic.exchange

pub exchange :: fn(self: *Self, v: T) -> T

Atomic.cas

pub cas :: fn(self: *Self, expected: T, desired: T) -> bool

cas: bool and observed-value variants

Atomic.cas_value

pub cas_value :: fn(self: *Self, expected: T, desired: T) -> T

Atomic.add

pub add :: fn(self: *Self, v: T) -> T

arithmetic; returns the previous value

Atomic.sub

pub sub :: fn(self: *Self, v: T) -> T

Atomic.mul

pub mul :: fn(self: *Self, v: T) -> T

Atomic.div

pub div :: fn(self: *Self, v: T) -> T

Atomic.max

pub max :: fn(self: *Self, v: T) -> T

min / max + bitwise; returns the previous value

Atomic.min

pub min :: fn(self: *Self, v: T) -> T

Atomic.and

pub and :: fn(self: *Self, v: T) -> T

Atomic.or

pub or :: fn(self: *Self, v: T) -> T

Atomic.xor

pub xor :: fn(self: *Self, v: T) -> T

Atomic.nand

pub nand :: fn(self: *Self, v: T) -> T