sync.stdatomic #

Implement the atomic operations. For now TCC does not support the atomic versions on nix so it uses locks to simulate the same behavior.

On windows tcc can simulate with other atomic operations.

Note: this implementations should be regarded as alpha stage and be testedmuch more.

fn add_i64(ptr &i64, delta int) i64

add_i64 adds provided delta as an atomic operation

fn add_u64(ptr &u64, delta int) u64

add_u64 adds provided delta as an atomic operation

fn fetch_add_u64(ptr &u64, delta u64) u64

fetch_add_u64 atomically adds delta and returns the previous value.

fn fetch_sub_u64(ptr &u64, delta u64) u64

fetch_sub_u64 atomically subtracts delta and returns the previous value.

fn load_i64(ptr &i64) i64

atomicall get a value

fn load_u64(ptr &u64) u64

atomicall get a value

fn new_atomic[T](val T) &AtomicVal[T]

new_atomic creates a new atomic value of T type

fn store_i64(ptr &i64, val i64)

atomicall set a value

fn store_u64(ptr &u64, val u64)

atomic store/load operations have to be used when there might be another concurrent access atomicall set a value

fn sub_i64(ptr &i64, delta int) i64

sub_i64 subtracts provided delta as an atomic operation

fn sub_u64(ptr &u64, delta int) u64

sub_u64 subtracts provided delta as an atomic operation

fn (mut a AtomicVal[T]) load() T

load returns current value of the atomic value

fn (mut a AtomicVal[T]) store(val T)

store updates the atomic value with val

fn (mut a AtomicVal[T]) add(delta T) T

add adds the atomic value with delta and returns the previous value

fn (mut a AtomicVal[T]) sub(delta T) T

sub subtracts the atomic value with delta and returns the previous value

fn (mut a AtomicVal[T]) swap(new T) T

swap sets the new value and returns the previous value

fn (mut a AtomicVal[T]) compare_and_swap(expected T, new T) bool

compare_and_swap executes the compare-and-swap(CAS) operation if atomic value == expected, then it will be set to new, and return true else return false, and the atomic value remains unchanged

struct AtomicVal[T] {
	val T
}