@shd101wyy/yo 0.1.30 → 0.1.32

package/std/sync/atomic.yo

@@ -0,0 +1,557 @@
+//! High-level `Atomic*` wrappers for thread-safe shared mutable values.
+pragma(Pragma.AllowUnsafe);
+
+{
+  atomic_bool,
+  atomic_int,
+  atomic_size_t,
+  atomic_llong,
+  atomic_schar,
+  atomic_short,
+  atomic_uchar,
+  atomic_ushort,
+  atomic_uint,
+  atomic_ullong,
+  atomic_ptrdiff_t,
+  atomic_load_explicit,
+  atomic_store_explicit,
+  atomic_exchange_explicit,
+  atomic_compare_exchange_strong_explicit,
+  atomic_fetch_add_explicit,
+  atomic_fetch_sub_explicit,
+  __yo_atomic_load_int,
+  __yo_atomic_store_int,
+  __yo_atomic_exchange_int,
+  __yo_atomic_compare_exchange_int,
+  __yo_atomic_load_size_t,
+  __yo_atomic_store_size_t,
+  __yo_atomic_exchange_size_t,
+  __yo_atomic_compare_exchange_size_t,
+  __yo_atomic_load_llong,
+  __yo_atomic_store_llong,
+  __yo_atomic_exchange_llong,
+  __yo_atomic_compare_exchange_llong,
+  __yo_atomic_load_schar,
+  __yo_atomic_store_schar,
+  __yo_atomic_exchange_schar,
+  __yo_atomic_compare_exchange_schar,
+  __yo_atomic_load_short,
+  __yo_atomic_store_short,
+  __yo_atomic_exchange_short,
+  __yo_atomic_compare_exchange_short,
+  __yo_atomic_load_uchar,
+  __yo_atomic_store_uchar,
+  __yo_atomic_exchange_uchar,
+  __yo_atomic_compare_exchange_uchar,
+  __yo_atomic_load_ushort,
+  __yo_atomic_store_ushort,
+  __yo_atomic_exchange_ushort,
+  __yo_atomic_compare_exchange_ushort,
+  __yo_atomic_load_uint,
+  __yo_atomic_store_uint,
+  __yo_atomic_exchange_uint,
+  __yo_atomic_compare_exchange_uint,
+  __yo_atomic_load_ullong,
+  __yo_atomic_store_ullong,
+  __yo_atomic_exchange_ullong,
+  __yo_atomic_compare_exchange_ullong,
+  __yo_atomic_load_ptrdiff,
+  __yo_atomic_store_ptrdiff,
+  __yo_atomic_exchange_ptrdiff,
+  __yo_atomic_compare_exchange_ptrdiff,
+  memory_order,
+  memory_order_relaxed,
+  memory_order_consume,
+  memory_order_acquire,
+  memory_order_release,
+  memory_order_acq_rel,
+  memory_order_seq_cst
+} :: import("std/libc/stdatomic");
+
+MemoryOrder :: enum(Relaxed, Consume, Acquire, Release, AcqRel, SeqCst);
+impl(
+  MemoryOrder,
+  to_c_order : (fn(self : Self) -> memory_order)(
+    match(
+      self,
+      (.Relaxed) => memory_order_relaxed,
+      (.Consume) => memory_order_consume,
+      (.Acquire) => memory_order_acquire,
+      (.Release) => memory_order_release,
+      (.AcqRel) => memory_order_acq_rel,
+      (.SeqCst) => memory_order_seq_cst
+    )
+  )
+);
+
+// ============================================================================
+// AtomicBool
+// ============================================================================
+AtomicBool :: atomic(object((*) : atomic_bool));
+impl(
+  AtomicBool,
+  new : (fn(value : bool) -> Self)({
+    v := Self(false);
+    cond(value => unsafe(atomic_store_explicit(&(v.*), true, memory_order_release)), true => ());
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> bool)(
+    unsafe(atomic_load_explicit(&(self.*), order.to_c_order())) == true
+  ),
+  store : (fn(ref(self) : Self, value : bool, order : MemoryOrder) -> unit)(
+    unsafe(atomic_store_explicit(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : bool, order : MemoryOrder) -> bool)(
+    unsafe(atomic_exchange_explicit(&(self.*), value, order.to_c_order())) == true
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : bool,
+      new_value : bool,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      atomic_compare_exchange_strong_explicit(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicI8
+// ============================================================================
+AtomicI8 :: atomic(object((*) : atomic_schar));
+impl(
+  AtomicI8,
+  new : (fn(value : i8) -> Self)({
+    v := Self(i8(0));
+    unsafe(__yo_atomic_store_schar(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> i8)(
+    unsafe(i8(__yo_atomic_load_schar(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : i8, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_schar(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : i8, order : MemoryOrder) -> i8)(
+    unsafe(i8(__yo_atomic_exchange_schar(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : i8,
+      new_value : i8,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_schar(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicI16
+// ============================================================================
+AtomicI16 :: atomic(object((*) : atomic_short));
+impl(
+  AtomicI16,
+  new : (fn(value : i16) -> Self)({
+    v := Self(i16(0));
+    unsafe(__yo_atomic_store_short(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> i16)(
+    unsafe(i16(__yo_atomic_load_short(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : i16, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_short(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : i16, order : MemoryOrder) -> i16)(
+    unsafe(i16(__yo_atomic_exchange_short(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : i16,
+      new_value : i16,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_short(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicI32
+// ============================================================================
+AtomicI32 :: atomic(object((*) : atomic_int));
+impl(
+  AtomicI32,
+  new : (fn(value : i32) -> Self)({
+    v := Self(i32(0));
+    unsafe(__yo_atomic_store_int(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> i32)(
+    unsafe(i32(__yo_atomic_load_int(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : i32, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_int(&(self.*), value, order.to_c_order()))
+  ),
+  fetch_add : (fn(ref(self) : Self, value : i32, order : MemoryOrder) -> i32)(
+    unsafe(i32(atomic_fetch_add_explicit(&(self.*), int(value), order.to_c_order())))
+  ),
+  fetch_sub : (fn(ref(self) : Self, value : i32, order : MemoryOrder) -> i32)(
+    unsafe(i32(atomic_fetch_sub_explicit(&(self.*), int(value), order.to_c_order())))
+  ),
+  swap : (fn(ref(self) : Self, value : i32, order : MemoryOrder) -> i32)(
+    unsafe(i32(__yo_atomic_exchange_int(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : i32,
+      new_value : i32,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_int(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicI64
+// ============================================================================
+AtomicI64 :: atomic(object((*) : atomic_llong));
+impl(
+  AtomicI64,
+  new : (fn(value : i64) -> Self)({
+    v := Self(i64(0));
+    unsafe(__yo_atomic_store_llong(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> i64)(
+    unsafe(i64(__yo_atomic_load_llong(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : i64, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_llong(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : i64, order : MemoryOrder) -> i64)(
+    unsafe(i64(__yo_atomic_exchange_llong(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : i64,
+      new_value : i64,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_llong(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicU8
+// ============================================================================
+AtomicU8 :: atomic(object((*) : atomic_uchar));
+impl(
+  AtomicU8,
+  new : (fn(value : u8) -> Self)({
+    v := Self(u8(0));
+    unsafe(__yo_atomic_store_uchar(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> u8)(
+    unsafe(u8(__yo_atomic_load_uchar(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : u8, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_uchar(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : u8, order : MemoryOrder) -> u8)(
+    unsafe(u8(__yo_atomic_exchange_uchar(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : u8,
+      new_value : u8,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_uchar(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicU16
+// ============================================================================
+AtomicU16 :: atomic(object((*) : atomic_ushort));
+impl(
+  AtomicU16,
+  new : (fn(value : u16) -> Self)({
+    v := Self(u16(0));
+    unsafe(__yo_atomic_store_ushort(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> u16)(
+    unsafe(u16(__yo_atomic_load_ushort(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : u16, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_ushort(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : u16, order : MemoryOrder) -> u16)(
+    unsafe(u16(__yo_atomic_exchange_ushort(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : u16,
+      new_value : u16,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_ushort(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicU32
+// ============================================================================
+AtomicU32 :: atomic(object((*) : atomic_uint));
+impl(
+  AtomicU32,
+  new : (fn(value : u32) -> Self)({
+    v := Self(u32(0));
+    unsafe(__yo_atomic_store_uint(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> u32)(
+    unsafe(u32(__yo_atomic_load_uint(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : u32, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_uint(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : u32, order : MemoryOrder) -> u32)(
+    unsafe(u32(__yo_atomic_exchange_uint(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : u32,
+      new_value : u32,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_uint(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicU64
+// ============================================================================
+AtomicU64 :: atomic(object((*) : atomic_ullong));
+impl(
+  AtomicU64,
+  new : (fn(value : u64) -> Self)({
+    v := Self(u64(0));
+    unsafe(__yo_atomic_store_ullong(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> u64)(
+    unsafe(u64(__yo_atomic_load_ullong(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : u64, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_ullong(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : u64, order : MemoryOrder) -> u64)(
+    unsafe(u64(__yo_atomic_exchange_ullong(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : u64,
+      new_value : u64,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_ullong(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicUsize
+// ============================================================================
+AtomicUsize :: atomic(object((*) : atomic_size_t));
+impl(
+  AtomicUsize,
+  new : (fn(value : usize) -> Self)({
+    v := Self(usize(0));
+    unsafe(__yo_atomic_store_size_t(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> usize)(
+    unsafe(usize(__yo_atomic_load_size_t(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : usize, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_size_t(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : usize, order : MemoryOrder) -> usize)(
+    unsafe(usize(__yo_atomic_exchange_size_t(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : usize,
+      new_value : usize,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_size_t(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+// ============================================================================
+// AtomicIsize
+// ============================================================================
+AtomicIsize :: atomic(object((*) : atomic_ptrdiff_t));
+impl(
+  AtomicIsize,
+  new : (fn(value : isize) -> Self)({
+    v := Self(isize(0));
+    unsafe(__yo_atomic_store_ptrdiff(&(v.*), value, memory_order_release));
+    v
+  }),
+  load : (fn(ref(self) : Self, order : MemoryOrder) -> isize)(
+    unsafe(isize(__yo_atomic_load_ptrdiff(&(self.*), order.to_c_order())))
+  ),
+  store : (fn(ref(self) : Self, value : isize, order : MemoryOrder) -> unit)(
+    unsafe(__yo_atomic_store_ptrdiff(&(self.*), value, order.to_c_order()))
+  ),
+  swap : (fn(ref(self) : Self, value : isize, order : MemoryOrder) -> isize)(
+    unsafe(isize(__yo_atomic_exchange_ptrdiff(&(self.*), value, order.to_c_order())))
+  ),
+  compare_exchange : (
+    fn(
+      ref(self) : Self,
+      ref(expected) : isize,
+      new_value : isize,
+      success : MemoryOrder,
+      failure : MemoryOrder
+    ) -> bool
+  )(
+    unsafe(
+      __yo_atomic_compare_exchange_ptrdiff(
+        &(self.*),
+        &(expected),
+        new_value,
+        success.to_c_order(),
+        failure.to_c_order()
+      )
+    )
+  )
+);
+
+export(
+  AtomicBool,
+  AtomicI8,
+  AtomicI16,
+  AtomicI32,
+  AtomicI64,
+  AtomicU8,
+  AtomicU16,
+  AtomicU32,
+  AtomicU64,
+  AtomicUsize,
+  AtomicIsize,
+  MemoryOrder
+);