Initial project import
This commit is contained in:
Agila Forge Importer committed
commit
23f2d29e32
11957 files changed
+1754577
No files matched your search
@@ -0,0 +1,126 @@
|
||||
module stdatomic
|
||||
|
||||
// The @VEXEROOT/thirdparty/stdatomic contains compatibility headers
|
||||
// for stdatomic, that supports both nix, windows and c++.
|
||||
|
||||
$if windows {
|
||||
#flag -I @VEXEROOT/thirdparty/stdatomic/win
|
||||
#insert "@VEXEROOT/thirdparty/stdatomic/win/atomic.h"
|
||||
} $else {
|
||||
#flag -I @VEXEROOT/thirdparty/stdatomic/nix
|
||||
#insert "@VEXEROOT/thirdparty/stdatomic/nix/atomic.h"
|
||||
}
|
||||
|
||||
$if linux {
|
||||
$if tinyc {
|
||||
$if amd64 {
|
||||
// Redhat/CentOS:
|
||||
#flag $when_first_existing('/usr/lib/gcc/x86_64-redhat-linux/6/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/7/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/8/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/9/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/10/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/11/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/12/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/13/libatomic.a','/usr/lib/gcc/x86_64-redhat-linux/14/libatomic.a')
|
||||
// Gentoo:
|
||||
#flag $when_first_existing('/usr/lib/gcc/x86_64-pc-linux-gnu/6/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/7/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/8/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/9/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/10/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/11/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/12/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/13/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-gnu/14/libatomic.a')
|
||||
// OpenSUSE:
|
||||
#flag $when_first_existing('/usr/lib64/gcc/x86_64-suse-linux/6/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/7/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/8/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/9/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/10/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/11/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/12/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/13/libatomic.a','/usr/lib64/gcc/x86_64-suse-linux/14/libatomic.a')
|
||||
// ALT Linux:
|
||||
#flag $when_first_existing('/usr/lib64/gcc/x86_64-alt-linux/6/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/7/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/8/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/9/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/10/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/11/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/12/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/13/libatomic.a','/usr/lib64/gcc/x86_64-alt-linux/14/libatomic.a')
|
||||
$if musl ? {
|
||||
// Alpine:
|
||||
#flag $when_first_existing('/usr/lib/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/6/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/7/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/8/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/9/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/10/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/11/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/12/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/13/libatomic.a','/usr/lib/gcc/x86_64-pc-linux-musl/14/libatomic.a')
|
||||
#flag @VEXEROOT/thirdparty/stdatomic/nix/atomic.S
|
||||
}
|
||||
} $else $if arm64 {
|
||||
// Note: Use `.so` instead of `.a`.
|
||||
// This is because `libatomic.a` atomic symbols, such as `__atomic_fetch_add_4`, are indirect(IFUNC) symbols:
|
||||
// This can not be handled correctly by `tcc` right now.
|
||||
|
||||
// Symbol table '.symtab' contains 14 entries:
|
||||
// Num: Value Size Type Bind Vis Ndx Name
|
||||
// 0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
|
||||
// 1: 0000000000000000 0 SECTION LOCAL DEFAULT 1
|
||||
// 2: 0000000000000000 0 NOTYPE LOCAL DEFAULT 1 $x
|
||||
// 3: 0000000000000030 12 FUNC LOCAL DEFAULT 1 select_fetch_add_4
|
||||
// 4: 0000000000000040 12 FUNC LOCAL DEFAULT 1 select_add_fetch_4
|
||||
// 5: 0000000000000014 0 NOTYPE LOCAL DEFAULT 6 $d
|
||||
// 6: 0000000000000000 0 SECTION LOCAL DEFAULT 3
|
||||
// 7: 0000000000000000 0 SECTION LOCAL DEFAULT 4
|
||||
// 8: 0000000000000000 0 SECTION LOCAL DEFAULT 5
|
||||
// 9: 0000000000000000 0 SECTION LOCAL DEFAULT 6
|
||||
// 10: 0000000000000000 24 FUNC GLOBAL HIDDEN 1 libat_fetch_add_4
|
||||
// 11: 0000000000000018 24 FUNC GLOBAL HIDDEN 1 libat_add_fetch_4
|
||||
// 12: 0000000000000030 12 IFUNC GLOBAL DEFAULT 1 __atomic_fetch_add_4
|
||||
// 13: 0000000000000040 12 IFUNC GLOBAL DEFAULT 1 __atomic_add_fetch_4
|
||||
|
||||
// Debian/Ubuntu:
|
||||
#flag $when_first_existing('/usr/lib/gcc/aarch64-linux-gnu/6/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/7/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/8/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/9/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/10/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/11/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/12/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/13/libatomic.so','/usr/lib/gcc/aarch64-linux-gnu/14/libatomic.so')
|
||||
// Redhat/CentOS:
|
||||
#flag $when_first_existing('/usr/lib/gcc/aarch64-redhat-linux/6/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/7/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/8/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/9/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/10/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/11/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/12/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/13/libatomic.so','/usr/lib/gcc/aarch64-redhat-linux/14/libatomic.so')
|
||||
// Gentoo:
|
||||
#flag $when_first_existing('/usr/lib/gcc/aarch64-pc-linux-gnu/6/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/7/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/8/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/9/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/10/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/11/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/12/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/13/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-gnu/14/libatomic.so')
|
||||
// OpenSUSE:
|
||||
#flag $when_first_existing('/usr/lib64/gcc/aarch64-suse-linux/6/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/7/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/8/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/9/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/10/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/11/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/12/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/13/libatomic.so','/usr/lib64/gcc/aarch64-suse-linux/14/libatomic.so')
|
||||
// ALT Linux:
|
||||
#flag $when_first_existing('/usr/lib64/gcc/aarch64-alt-linux/6/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/7/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/8/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/9/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/10/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/11/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/12/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/13/libatomic.so','/usr/lib64/gcc/aarch64-alt-linux/14/libatomic.so')
|
||||
$if musl ? {
|
||||
// Alpine:
|
||||
#flag $when_first_existing('/usr/lib/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/6/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/7/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/8/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/9/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/10/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/11/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/12/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/13/libatomic.so','/usr/lib/gcc/aarch64-pc-linux-musl/14/libatomic.so')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The following functions are actually generic in C
|
||||
fn C.atomic_load_ptr(voidptr) voidptr
|
||||
fn C.atomic_store_ptr(voidptr, voidptr)
|
||||
fn C.atomic_compare_exchange_weak_ptr(voidptr, voidptr, isize) bool
|
||||
fn C.atomic_compare_exchange_strong_ptr(voidptr, voidptr, isize) bool
|
||||
fn C.atomic_exchange_ptr(voidptr, voidptr) voidptr
|
||||
fn C.atomic_fetch_add_ptr(voidptr, voidptr) voidptr
|
||||
fn C.atomic_fetch_sub_ptr(voidptr, voidptr) voidptr
|
||||
|
||||
fn C.atomic_load_byte(voidptr) u8
|
||||
fn C.atomic_store_byte(voidptr, u8)
|
||||
fn C.atomic_compare_exchange_weak_byte(voidptr, voidptr, u8) bool
|
||||
fn C.atomic_compare_exchange_strong_byte(voidptr, voidptr, u8) bool
|
||||
fn C.atomic_exchange_byte(voidptr, u8) u8
|
||||
fn C.atomic_fetch_add_byte(voidptr, u8) u8
|
||||
fn C.atomic_fetch_sub_byte(voidptr, u8) u8
|
||||
|
||||
fn C.atomic_load_u16(voidptr) u16
|
||||
fn C.atomic_store_u16(voidptr, u16)
|
||||
fn C.atomic_compare_exchange_weak_u16(voidptr, voidptr, u16) bool
|
||||
fn C.atomic_compare_exchange_strong_u16(voidptr, voidptr, u16) bool
|
||||
fn C.atomic_exchange_u16(voidptr, u16) u16
|
||||
fn C.atomic_fetch_add_u16(voidptr, u16) u16
|
||||
fn C.atomic_fetch_sub_u16(voidptr, u16) u16
|
||||
|
||||
fn C.atomic_load_u32(voidptr) u32
|
||||
fn C.atomic_store_u32(voidptr, u32)
|
||||
fn C.atomic_compare_exchange_weak_u32(voidptr, voidptr, u32) bool
|
||||
fn C.atomic_compare_exchange_strong_u32(voidptr, voidptr, u32) bool
|
||||
fn C.atomic_exchange_u32(voidptr, u32) u32
|
||||
fn C.atomic_fetch_add_u32(voidptr, u32) u32
|
||||
fn C.atomic_fetch_sub_u32(voidptr, u32) u32
|
||||
|
||||
fn C.atomic_load_u64(voidptr) u64
|
||||
fn C.atomic_store_u64(voidptr, u64)
|
||||
fn C.atomic_compare_exchange_weak_u64(voidptr, voidptr, u64) bool
|
||||
fn C.atomic_compare_exchange_strong_u64(voidptr, voidptr, u64) bool
|
||||
fn C.atomic_exchange_u64(voidptr, u64) u64
|
||||
fn C.atomic_fetch_add_u64(voidptr, u64) u64
|
||||
fn C.atomic_fetch_sub_u64(voidptr, u64) u64
|
||||
|
||||
fn C.atomic_thread_fence(i32)
|
||||
fn C.cpu_relax()
|
||||
|
||||
pub const C.memory_order_relaxed i32
|
||||
pub const C.memory_order_acquire i32
|
||||
pub const C.memory_order_release i32
|
||||
|
||||
fn C.ANNOTATE_RWLOCK_CREATE(voidptr)
|
||||
fn C.ANNOTATE_RWLOCK_ACQUIRED(voidptr, i32)
|
||||
fn C.ANNOTATE_RWLOCK_RELEASED(voidptr, i32)
|
||||
fn C.ANNOTATE_RWLOCK_DESTROY(voidptr)
|
||||
|
||||
$if valgrind ? {
|
||||
#flag -I/usr/include/valgrind
|
||||
#include <valgrind/helgrind.h>
|
||||
}
|
||||
@@ -0,0 +1,333 @@
|
||||
module 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 tested
|
||||
// much more.
|
||||
|
||||
// add_u64 adds provided delta as an atomic operation
|
||||
@[inline]
|
||||
pub fn add_u64(ptr &u64, delta int) u64 {
|
||||
C.atomic_fetch_add_u64(voidptr(ptr), delta)
|
||||
return *ptr
|
||||
}
|
||||
|
||||
// sub_u64 subtracts provided delta as an atomic operation
|
||||
@[inline]
|
||||
pub fn sub_u64(ptr &u64, delta int) u64 {
|
||||
C.atomic_fetch_sub_u64(voidptr(ptr), delta)
|
||||
return *ptr
|
||||
}
|
||||
|
||||
// add_i64 adds provided delta as an atomic operation
|
||||
@[inline]
|
||||
pub fn add_i64(ptr &i64, delta int) i64 {
|
||||
C.atomic_fetch_add_u64(voidptr(ptr), delta)
|
||||
return *ptr
|
||||
}
|
||||
|
||||
// add_i64 subtracts provided delta as an atomic operation
|
||||
@[inline]
|
||||
pub fn sub_i64(ptr &i64, delta int) i64 {
|
||||
C.atomic_fetch_sub_u64(voidptr(ptr), delta)
|
||||
return *ptr
|
||||
}
|
||||
|
||||
// atomic store/load operations have to be used when there might be another concurrent access
|
||||
// atomicall set a value
|
||||
@[inline]
|
||||
pub fn store_u64(ptr &u64, val u64) {
|
||||
C.atomic_store_u64(voidptr(ptr), val)
|
||||
}
|
||||
|
||||
// atomicall get a value
|
||||
@[inline]
|
||||
pub fn load_u64(ptr &u64) u64 {
|
||||
return C.atomic_load_u64(voidptr(ptr))
|
||||
}
|
||||
|
||||
// atomicall set a value
|
||||
@[inline]
|
||||
pub fn store_i64(ptr &i64, val i64) {
|
||||
C.atomic_store_u64(voidptr(ptr), val)
|
||||
}
|
||||
|
||||
// atomicall get a value
|
||||
@[inline]
|
||||
pub fn load_i64(ptr &i64) i64 {
|
||||
return i64(C.atomic_load_u64(voidptr(ptr)))
|
||||
}
|
||||
|
||||
@[heap]
|
||||
pub struct AtomicVal[T] {
|
||||
val T
|
||||
}
|
||||
|
||||
// new_atomic creates a new atomic value of `T` type
|
||||
@[inline]
|
||||
pub fn new_atomic[T](val T) &AtomicVal[T] {
|
||||
$if T is $int {
|
||||
return &AtomicVal[T]{
|
||||
val: val
|
||||
}
|
||||
} $else $if T is bool {
|
||||
return &AtomicVal[T]{
|
||||
val: val
|
||||
}
|
||||
} $else $if T is voidptr {
|
||||
return &AtomicVal[T]{
|
||||
val: val
|
||||
}
|
||||
} $else {
|
||||
$compile_error('atomic: only support number, bool, and voidptr types')
|
||||
}
|
||||
return unsafe { nil }
|
||||
}
|
||||
|
||||
// load returns current value of the atomic value
|
||||
@[inline]
|
||||
pub fn (mut a AtomicVal[T]) load() T {
|
||||
$if T is bool {
|
||||
return C.atomic_load_byte(voidptr(&a.val)) != 0
|
||||
} $else $if T is u8 || T is i8 {
|
||||
return T(C.atomic_load_byte(voidptr(&a.val)))
|
||||
} $else $if T is u16 || T is i16 {
|
||||
return T(C.atomic_load_u16(voidptr(&a.val)))
|
||||
} $else $if T is u32 || T is i32 {
|
||||
return T(C.atomic_load_u32(voidptr(&a.val)))
|
||||
} $else $if T is u64 || T is i64 {
|
||||
return T(C.atomic_load_u64(voidptr(&a.val)))
|
||||
} $else $if T is int {
|
||||
if sizeof(int) == 4 {
|
||||
return int(C.atomic_load_u32(voidptr(&a.val)))
|
||||
} else {
|
||||
return int(C.atomic_load_u64(voidptr(&a.val)))
|
||||
}
|
||||
} $else $if T is isize || T is usize {
|
||||
if sizeof(isize) == 4 {
|
||||
return T(C.atomic_load_u32(voidptr(&a.val)))
|
||||
} else {
|
||||
return T(C.atomic_load_u64(voidptr(&a.val)))
|
||||
}
|
||||
} $else $if T is voidptr {
|
||||
// TODO: this should be $if sizeof(T) == 4
|
||||
$if x32 {
|
||||
return T(C.atomic_load_u32(voidptr(&a.val)))
|
||||
} $else {
|
||||
return T(C.atomic_load_u64(voidptr(&a.val)))
|
||||
}
|
||||
}
|
||||
return a.val
|
||||
}
|
||||
|
||||
// store updates the atomic value with `val`
|
||||
@[inline]
|
||||
pub fn (mut a AtomicVal[T]) store(val T) {
|
||||
$if T is bool {
|
||||
C.atomic_store_byte(voidptr(&a.val), u8(val))
|
||||
} $else $if T is u8 || T is i8 {
|
||||
C.atomic_store_byte(voidptr(&a.val), u8(val))
|
||||
} $else $if T is u16 || T is i16 {
|
||||
C.atomic_store_u16(voidptr(&a.val), u16(val))
|
||||
} $else $if T is u32 || T is i32 {
|
||||
C.atomic_store_u32(voidptr(&a.val), u32(val))
|
||||
} $else $if T is u64 || T is i64 {
|
||||
C.atomic_store_u64(voidptr(&a.val), u64(val))
|
||||
} $else $if T is int {
|
||||
if sizeof(int) == 4 {
|
||||
C.atomic_store_u32(voidptr(&a.val), u32(val))
|
||||
} else {
|
||||
C.atomic_store_u64(voidptr(&a.val), u64(val))
|
||||
}
|
||||
} $else $if T is isize || T is usize {
|
||||
if sizeof(isize) == 4 {
|
||||
C.atomic_store_u32(voidptr(&a.val), u32(val))
|
||||
} else {
|
||||
C.atomic_store_u64(voidptr(&a.val), u64(val))
|
||||
}
|
||||
} $else $if T is voidptr {
|
||||
// TODO: this should be $if sizeof(T) == 4
|
||||
$if x32 {
|
||||
C.atomic_store_u32(voidptr(&a.val), u32(val))
|
||||
} $else {
|
||||
C.atomic_store_u64(voidptr(&a.val), u64(val))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// add adds the atomic value with `delta` and returns the previous value
|
||||
@[inline]
|
||||
pub fn (mut a AtomicVal[T]) add(delta T) T {
|
||||
$if T is bool {
|
||||
panic('atomic: add() not supported for bool type')
|
||||
} $else $if T is voidptr {
|
||||
panic('atomic: add() not supported for voidptr type')
|
||||
} $else $if T is u8 || T is i8 {
|
||||
old := C.atomic_fetch_add_byte(voidptr(&a.val), u8(delta))
|
||||
return T(old)
|
||||
} $else $if T is u16 || T is i16 {
|
||||
old := C.atomic_fetch_add_u16(voidptr(&a.val), u16(delta))
|
||||
return T(old)
|
||||
} $else $if T is u32 || T is i32 {
|
||||
old := C.atomic_fetch_add_u32(voidptr(&a.val), u32(delta))
|
||||
return T(old)
|
||||
} $else $if T is u64 || T is i64 {
|
||||
old := C.atomic_fetch_add_u64(voidptr(&a.val), u64(delta))
|
||||
return T(old)
|
||||
} $else $if T is int {
|
||||
if sizeof(int) == 4 {
|
||||
old := C.atomic_fetch_add_u32(voidptr(&a.val), u32(delta))
|
||||
return T(old)
|
||||
} else {
|
||||
old := C.atomic_fetch_add_u64(voidptr(&a.val), u64(delta))
|
||||
return T(old)
|
||||
}
|
||||
} $else $if T is isize || T is usize {
|
||||
if sizeof(isize) == 4 {
|
||||
old := C.atomic_fetch_add_u32(voidptr(&a.val), u32(delta))
|
||||
return T(old)
|
||||
} else {
|
||||
old := C.atomic_fetch_add_u64(voidptr(&a.val), u64(delta))
|
||||
return T(old)
|
||||
}
|
||||
}
|
||||
panic('unreachable')
|
||||
}
|
||||
|
||||
// sub subtracts the atomic value with `delta` and returns the previous value
|
||||
@[inline]
|
||||
pub fn (mut a AtomicVal[T]) sub(delta T) T {
|
||||
$if T is bool {
|
||||
panic('atomic: sub() not supported for bool type')
|
||||
} $else $if T is voidptr {
|
||||
panic('atomic: sub() not supported for voidptr type')
|
||||
} $else $if T is u8 || T is i8 {
|
||||
old := C.atomic_fetch_sub_byte(voidptr(&a.val), u8(delta))
|
||||
return T(old)
|
||||
} $else $if T is u16 || T is i16 {
|
||||
old := C.atomic_fetch_sub_u16(voidptr(&a.val), u16(delta))
|
||||
return T(old)
|
||||
} $else $if T is u32 || T is i32 {
|
||||
old := C.atomic_fetch_sub_u32(voidptr(&a.val), u32(delta))
|
||||
return T(old)
|
||||
} $else $if T is u64 || T is i64 {
|
||||
old := C.atomic_fetch_sub_u64(voidptr(&a.val), u64(delta))
|
||||
return T(old)
|
||||
} $else $if T is int {
|
||||
if sizeof(int) == 4 {
|
||||
old := C.atomic_fetch_sub_u32(voidptr(&a.val), u32(delta))
|
||||
return T(old)
|
||||
} else {
|
||||
old := C.atomic_fetch_sub_u64(voidptr(&a.val), u64(delta))
|
||||
return T(old)
|
||||
}
|
||||
} $else $if T is isize || T is usize {
|
||||
if sizeof(isize) == 4 {
|
||||
old := C.atomic_fetch_sub_u32(voidptr(&a.val), u32(delta))
|
||||
return T(old)
|
||||
} else {
|
||||
old := C.atomic_fetch_sub_u64(voidptr(&a.val), u64(delta))
|
||||
return T(old)
|
||||
}
|
||||
}
|
||||
panic('unreachable')
|
||||
}
|
||||
|
||||
// swap sets the `new` value and returns the previous value
|
||||
@[inline]
|
||||
pub fn (mut a AtomicVal[T]) swap(new T) T {
|
||||
$if T is bool {
|
||||
old := C.atomic_exchange_byte(voidptr(&a.val), u8(new))
|
||||
return old != 0
|
||||
} $else $if T is u8 || T is i8 {
|
||||
old := C.atomic_exchange_byte(voidptr(&a.val), u8(new))
|
||||
return T(old)
|
||||
} $else $if T is u16 || T is i16 {
|
||||
old := C.atomic_exchange_u16(voidptr(&a.val), u16(new))
|
||||
return T(old)
|
||||
} $else $if T is u32 || T is i32 {
|
||||
old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
|
||||
return T(old)
|
||||
} $else $if T is u64 || T is i64 {
|
||||
old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
|
||||
return T(old)
|
||||
} $else $if T is int {
|
||||
if sizeof(int) == 4 {
|
||||
old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
|
||||
return T(old)
|
||||
} else {
|
||||
old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
|
||||
return T(old)
|
||||
}
|
||||
} $else $if T is isize || T is usize {
|
||||
if sizeof(isize) == 4 {
|
||||
old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
|
||||
return T(old)
|
||||
} else {
|
||||
old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
|
||||
return T(old)
|
||||
}
|
||||
} $else $if T is voidptr {
|
||||
// TODO: this should be $if sizeof(T) == 4
|
||||
$if x32 {
|
||||
old := C.atomic_exchange_u32(voidptr(&a.val), u32(new))
|
||||
return T(old)
|
||||
} $else {
|
||||
old := C.atomic_exchange_u64(voidptr(&a.val), u64(new))
|
||||
return T(old)
|
||||
}
|
||||
}
|
||||
panic('unreachable')
|
||||
}
|
||||
|
||||
// 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
|
||||
@[inline]
|
||||
pub fn (mut a AtomicVal[T]) compare_and_swap(expected T, new T) bool {
|
||||
$if T is bool {
|
||||
mut exp := u8(expected)
|
||||
return C.atomic_compare_exchange_strong_byte(voidptr(&a.val), &exp, u8(new))
|
||||
} $else $if T is u8 || T is i8 {
|
||||
mut exp := u8(expected)
|
||||
return C.atomic_compare_exchange_strong_byte(voidptr(&a.val), &exp, u8(new))
|
||||
} $else $if T is u16 || T is i16 {
|
||||
mut exp := u16(expected)
|
||||
return C.atomic_compare_exchange_strong_u16(voidptr(&a.val), &exp, u16(new))
|
||||
} $else $if T is u32 || T is i32 {
|
||||
mut exp := u32(expected)
|
||||
return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
|
||||
} $else $if T is u64 || T is i64 {
|
||||
mut exp := u64(expected)
|
||||
return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
|
||||
} $else $if T is int {
|
||||
if sizeof(int) == 4 {
|
||||
mut exp := u32(expected)
|
||||
return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
|
||||
} else {
|
||||
mut exp := u64(expected)
|
||||
return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
|
||||
}
|
||||
} $else $if T is isize || T is usize {
|
||||
if sizeof(isize) == 4 {
|
||||
mut exp := u32(expected)
|
||||
return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
|
||||
} else {
|
||||
mut exp := u64(expected)
|
||||
return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
|
||||
}
|
||||
} $else $if T is voidptr {
|
||||
// TODO: this should be $if sizeof(T) == 4
|
||||
$if x32 {
|
||||
mut exp := u32(expected)
|
||||
return C.atomic_compare_exchange_strong_u32(voidptr(&a.val), &exp, u32(new))
|
||||
} $else {
|
||||
mut exp := u64(expected)
|
||||
return C.atomic_compare_exchange_strong_u64(voidptr(&a.val), &exp, u64(new))
|
||||
}
|
||||
}
|
||||
panic('unreachable')
|
||||
}
|
||||
@@ -0,0 +1,278 @@
|
||||
import sync
|
||||
import sync.stdatomic
|
||||
|
||||
const iterations_per_cycle = 100_000
|
||||
|
||||
struct Counter {
|
||||
mut:
|
||||
counter u64
|
||||
}
|
||||
|
||||
// without proper synchronization this would fail
|
||||
fn test_count_10_times_1_cycle_should_result_10_cycles_with_sync() {
|
||||
desired_iterations := 10 * iterations_per_cycle
|
||||
mut wg := sync.new_waitgroup()
|
||||
mut counter := &Counter{}
|
||||
wg.add(10)
|
||||
for i := 0; i < 10; i++ {
|
||||
spawn count_one_cycle(mut counter, mut wg)
|
||||
}
|
||||
wg.wait()
|
||||
assert counter.counter == u64(desired_iterations)
|
||||
eprintln(' with synchronization the counter is: ${counter.counter:10} , expectedly == ${desired_iterations:10}')
|
||||
}
|
||||
|
||||
// This test just to make sure that we have an anti-test to prove it works
|
||||
fn test_count_10_times_1_cycle_should_not_be_10_cycles_without_sync() {
|
||||
desired_iterations := 10 * iterations_per_cycle
|
||||
mut wg := sync.new_waitgroup()
|
||||
mut counter := &Counter{}
|
||||
wg.add(10)
|
||||
for i := 0; i < 10; i++ {
|
||||
spawn count_one_cycle_without_sync(mut counter, mut wg)
|
||||
}
|
||||
wg.wait()
|
||||
// Note: we do not assert here, just print, because sometimes by chance counter.counter may be == desired_iterations
|
||||
eprintln('without synchronization the counter is: ${counter.counter:10} , expectedly != ${desired_iterations:10}')
|
||||
}
|
||||
|
||||
fn test_atomic_count_plus_one_u64() {
|
||||
mut c := u64(0)
|
||||
assert stdatomic.add_u64(&c, 1) == 1
|
||||
}
|
||||
|
||||
fn test_atomic_count_plus_one_i64() {
|
||||
mut c := i64(0)
|
||||
assert stdatomic.add_i64(&c, 1) == 1
|
||||
}
|
||||
|
||||
fn test_atomic_count_plus_greater_than_one_u64() {
|
||||
mut c := u64(0)
|
||||
assert stdatomic.add_u64(&c, 10) == 10
|
||||
}
|
||||
|
||||
fn test_atomic_count_plus_greater_than_one_i64() {
|
||||
mut c := i64(0)
|
||||
assert stdatomic.add_i64(&c, 10) == 10
|
||||
}
|
||||
|
||||
fn test_atomic_count_minus_one_u64() {
|
||||
mut c := u64(1)
|
||||
assert stdatomic.sub_u64(&c, 1) == 0
|
||||
}
|
||||
|
||||
fn test_atomic_count_minus_one_i64() {
|
||||
mut c := i64(0)
|
||||
assert stdatomic.sub_i64(&c, 1) == -1
|
||||
}
|
||||
|
||||
fn test_atomic_count_minus_greater_than_one_u64() {
|
||||
mut c := u64(0)
|
||||
stdatomic.store_u64(&c, 10)
|
||||
assert stdatomic.sub_u64(&c, 10) == 0
|
||||
}
|
||||
|
||||
fn test_atomic_count_minus_greater_than_one_i64() {
|
||||
mut c := i64(0)
|
||||
stdatomic.store_i64(&c, 10)
|
||||
assert stdatomic.sub_i64(&c, 20) == -10
|
||||
}
|
||||
|
||||
// count_one_cycle counts the common counter iterations_per_cycle times in thread-safe way
|
||||
fn count_one_cycle(mut counter Counter, mut group sync.WaitGroup) {
|
||||
for i := 0; i < iterations_per_cycle; i++ {
|
||||
stdatomic.add_u64(&counter.counter, 1)
|
||||
}
|
||||
group.done()
|
||||
}
|
||||
|
||||
// count_one_cycle_without_sync counts the common counter iterations_per_cycle times in none thread-safe way
|
||||
fn count_one_cycle_without_sync(mut counter Counter, mut group sync.WaitGroup) {
|
||||
for i := 0; i < iterations_per_cycle; i++ {
|
||||
counter.counter++
|
||||
}
|
||||
group.done()
|
||||
}
|
||||
|
||||
fn test_atomic_vals() {
|
||||
mut v_bool := stdatomic.new_atomic(false)
|
||||
v_bool.store(true)
|
||||
assert v_bool.load() == true
|
||||
v_bool.store(false)
|
||||
assert v_bool.load() == false
|
||||
assert v_bool.swap(true) == false
|
||||
assert v_bool.swap(false) == true
|
||||
assert v_bool.compare_and_swap(false, true) == true
|
||||
assert v_bool.load() == true
|
||||
|
||||
mut v_i8 := stdatomic.new_atomic(i8(-33))
|
||||
v_i8.store(-34)
|
||||
assert v_i8.load() == -34
|
||||
assert v_i8.add(10) == -34
|
||||
assert v_i8.load() == -24
|
||||
assert v_i8.sub(7) == -24
|
||||
assert v_i8.load() == -31
|
||||
mut new_i8 := i8(-20)
|
||||
assert v_i8.swap(new_i8) == -31
|
||||
assert v_i8.swap(-31) == new_i8
|
||||
assert v_i8.compare_and_swap(-31, new_i8) == true
|
||||
assert v_i8.compare_and_swap(new_i8, -32) == true
|
||||
assert v_i8.load() == -32
|
||||
|
||||
mut v_u8 := stdatomic.new_atomic(u8(33))
|
||||
v_u8.store(34)
|
||||
assert v_u8.load() == 34
|
||||
assert v_u8.add(10) == 34
|
||||
assert v_u8.load() == 44
|
||||
assert v_u8.sub(7) == 44
|
||||
assert v_u8.load() == 37
|
||||
mut new_u8 := u8(20)
|
||||
assert v_u8.swap(new_u8) == 37
|
||||
assert v_u8.swap(37) == new_u8
|
||||
assert v_u8.compare_and_swap(37, new_u8) == true
|
||||
assert v_u8.compare_and_swap(new_u8, 38) == true
|
||||
assert v_u8.load() == 38
|
||||
|
||||
mut v_i16 := stdatomic.new_atomic(i16(-333))
|
||||
v_i16.store(-334)
|
||||
assert v_i16.load() == -334
|
||||
assert v_i16.add(10) == -334
|
||||
assert v_i16.load() == -324
|
||||
assert v_i16.sub(7) == -324
|
||||
assert v_i16.load() == -331
|
||||
mut new_i16 := i16(-200)
|
||||
assert v_i16.swap(new_i16) == -331
|
||||
assert v_i16.swap(-331) == new_i16
|
||||
assert v_i16.compare_and_swap(-331, new_i16) == true
|
||||
assert v_i16.compare_and_swap(new_i16, -332) == true
|
||||
assert v_i16.load() == -332
|
||||
|
||||
mut v_u16 := stdatomic.new_atomic(u16(333))
|
||||
v_u16.store(334)
|
||||
assert v_u16.load() == 334
|
||||
assert v_u16.add(10) == 334
|
||||
assert v_u16.load() == 344
|
||||
assert v_u16.sub(7) == 344
|
||||
assert v_u16.load() == 337
|
||||
mut new_u16 := u16(200)
|
||||
assert v_u16.swap(new_u16) == 337
|
||||
assert v_u16.swap(337) == new_u16
|
||||
assert v_u16.compare_and_swap(337, new_u16) == true
|
||||
assert v_u16.compare_and_swap(new_u16, 332) == true
|
||||
assert v_u16.load() == 332
|
||||
|
||||
mut v_i32 := stdatomic.new_atomic(i32(-3333))
|
||||
v_i32.store(-3334)
|
||||
assert v_i32.load() == -3334
|
||||
assert v_i32.add(10) == -3334
|
||||
assert v_i32.load() == -3324
|
||||
assert v_i32.sub(7) == -3324
|
||||
assert v_i32.load() == -3331
|
||||
mut new_i32 := i32(-2000)
|
||||
assert v_i32.swap(new_i32) == -3331
|
||||
assert v_i32.swap(-3331) == new_i32
|
||||
assert v_i32.compare_and_swap(-3331, new_i32) == true
|
||||
assert v_i32.compare_and_swap(new_i32, -3332) == true
|
||||
assert v_i32.load() == -3332
|
||||
|
||||
mut v_u32 := stdatomic.new_atomic(u32(3333))
|
||||
v_u32.store(3334)
|
||||
assert v_u32.load() == 3334
|
||||
assert v_u32.add(10) == 3334
|
||||
assert v_u32.load() == 3344
|
||||
assert v_u32.sub(7) == 3344
|
||||
assert v_u32.load() == 3337
|
||||
mut new_u32 := u32(2000)
|
||||
assert v_u32.swap(new_u32) == 3337
|
||||
assert v_u32.swap(3337) == new_u32
|
||||
assert v_u32.compare_and_swap(3337, new_u32) == true
|
||||
assert v_u32.compare_and_swap(new_u32, 3338) == true
|
||||
assert v_u32.load() == 3338
|
||||
|
||||
mut v_i64 := stdatomic.new_atomic(i64(-33333))
|
||||
v_i64.store(-33334)
|
||||
assert v_i64.load() == -33334
|
||||
assert v_i64.add(10) == -33334
|
||||
assert v_i64.load() == -33324
|
||||
assert v_i64.sub(7) == -33324
|
||||
assert v_i64.load() == -33331
|
||||
mut new_i64 := i64(-20000)
|
||||
assert v_i64.swap(new_i64) == -33331
|
||||
assert v_i64.swap(-33331) == new_i64
|
||||
assert v_i64.compare_and_swap(-33331, new_i64) == true
|
||||
assert v_i64.compare_and_swap(new_i64, -33332) == true
|
||||
assert v_i64.load() == -33332
|
||||
|
||||
mut v_u64 := stdatomic.new_atomic(u64(33333))
|
||||
v_u64.store(33334)
|
||||
assert v_u64.load() == 33334
|
||||
assert v_u64.add(10) == 33334
|
||||
assert v_u64.load() == 33344
|
||||
assert v_u64.sub(7) == 33344
|
||||
assert v_u64.load() == 33337
|
||||
mut new_u64 := u64(20000)
|
||||
assert v_u64.swap(new_u64) == 33337
|
||||
assert v_u64.swap(33337) == new_u64
|
||||
assert v_u64.compare_and_swap(33337, new_u64) == true
|
||||
assert v_u64.compare_and_swap(new_u64, 33338) == true
|
||||
assert v_u64.load() == 33338
|
||||
|
||||
mut v_int := stdatomic.new_atomic(int(-44))
|
||||
v_int.store(-45)
|
||||
assert v_int.load() == -45
|
||||
assert v_int.add(10) == -45
|
||||
assert v_int.load() == -35
|
||||
assert v_int.sub(7) == -35
|
||||
assert v_int.load() == -42
|
||||
mut new_int := int(-40000)
|
||||
assert v_int.swap(new_int) == -42
|
||||
assert v_int.swap(-42) == new_int
|
||||
assert v_int.compare_and_swap(-42, new_int) == true
|
||||
assert v_int.compare_and_swap(new_int, -40001) == true
|
||||
assert v_int.load() == -40001
|
||||
|
||||
mut v_isize := stdatomic.new_atomic(isize(-55))
|
||||
v_isize.store(-56)
|
||||
assert v_isize.load() == -56
|
||||
assert v_isize.add(10) == -56
|
||||
assert v_isize.load() == -46
|
||||
assert v_isize.sub(7) == -46
|
||||
assert v_isize.load() == -53
|
||||
mut new_isize := isize(-50000)
|
||||
assert v_isize.swap(new_isize) == -53
|
||||
assert v_isize.swap(-53) == new_isize
|
||||
assert v_isize.compare_and_swap(-53, new_isize) == true
|
||||
assert v_isize.compare_and_swap(new_isize, -50001) == true
|
||||
assert v_isize.load() == -50001
|
||||
|
||||
mut v_usize := stdatomic.new_atomic(usize(55))
|
||||
v_usize.store(56)
|
||||
assert v_usize.load() == 56
|
||||
assert v_usize.add(10) == 56
|
||||
assert v_usize.load() == 66
|
||||
assert v_usize.sub(7) == 66
|
||||
assert v_usize.load() == 59
|
||||
mut new_usize := usize(50000)
|
||||
assert v_usize.swap(new_usize) == 59
|
||||
assert v_usize.swap(59) == new_usize
|
||||
assert v_usize.compare_and_swap(59, new_usize) == true
|
||||
assert v_usize.compare_and_swap(new_usize, 60) == true
|
||||
assert v_usize.load() == 60
|
||||
|
||||
mut val_1 := int(100)
|
||||
mut ptr_1 := voidptr(&val_1)
|
||||
mut val_2 := int(200)
|
||||
mut ptr_2 := voidptr(&val_2)
|
||||
mut v_voidptr := stdatomic.new_atomic(ptr_1)
|
||||
assert v_voidptr.load() == ptr_1
|
||||
v_voidptr.store(ptr_2)
|
||||
assert v_voidptr.load() == ptr_2
|
||||
assert v_voidptr.swap(ptr_1) == ptr_2
|
||||
assert v_voidptr.swap(ptr_2) == ptr_1
|
||||
assert v_voidptr.compare_and_swap(ptr_2, ptr_1) == true
|
||||
assert v_voidptr.load() == ptr_1
|
||||
|
||||
// just for compile
|
||||
C.atomic_thread_fence(C.memory_order_relaxed)
|
||||
C.cpu_relax()
|
||||
}
|
||||
Reference in new issue
Block a user