222 lines
3.2 KiB
V
222 lines
3.2 KiB
V
// vtest build: !(macos || windows)
|
|
|
|
module atomics
|
|
|
|
fn test_cas_i32_basic() {
|
|
mut x := i32(10)
|
|
ok := cas_i32(&x, 10, 20)
|
|
assert ok == true
|
|
assert x == 20
|
|
}
|
|
|
|
fn test_cas_fail() {
|
|
mut x := i32(5)
|
|
assert !cas_i32(&x, 10, 42)
|
|
assert x == 5
|
|
}
|
|
|
|
fn test_cas_fail_memory_unchanged() {
|
|
mut x := i32(7)
|
|
cas_i32(&x, 1, 2)
|
|
assert x == 7
|
|
}
|
|
|
|
fn test_cas_exact_match() {
|
|
mut x := i32(-1)
|
|
assert !cas_i32(&x, 0, 999)
|
|
assert x == -1
|
|
}
|
|
|
|
fn test_cas_twice() {
|
|
mut x := i32(1)
|
|
assert cas_i32(&x, 1, 2)
|
|
assert cas_i32(&x, 2, 3)
|
|
assert x == 3
|
|
}
|
|
|
|
fn test_cas_with_negative() {
|
|
mut x := i32(-123)
|
|
assert cas_i32(&x, -123, 8)
|
|
assert x == 8
|
|
}
|
|
|
|
fn test_add_i32_basic() {
|
|
mut x := i32(0)
|
|
for _ in 0 .. 1000 {
|
|
add_i32(&x, 1)
|
|
}
|
|
assert x == 1000
|
|
}
|
|
|
|
fn test_add_i32_negative() {
|
|
mut x := i32(10)
|
|
add_i32(&x, -3)
|
|
assert x == 7
|
|
}
|
|
|
|
fn test_add_i32_return_value() {
|
|
mut x := i32(5)
|
|
r := add_i32(&x, 7)
|
|
assert r == 12
|
|
assert x == 12
|
|
}
|
|
|
|
fn test_add_i32_overflow_wraps() {
|
|
mut x := i32(2147483647)
|
|
add_i32(&x, 1)
|
|
assert x == -2147483648
|
|
}
|
|
|
|
fn test_swap_i32_basic() {
|
|
mut x := i32(5)
|
|
old := swap_i32(&x, 99)
|
|
assert old == 5
|
|
assert x == 99
|
|
}
|
|
|
|
fn test_swap_i32_twice() {
|
|
mut x := i32(1)
|
|
assert swap_i32(&x, 2) == 1
|
|
assert swap_i32(&x, 3) == 2
|
|
assert x == 3
|
|
}
|
|
|
|
fn test_swap_i32_with_cas() {
|
|
mut x := i32(10)
|
|
assert cas_i32(&x, 10, 20)
|
|
old := swap_i32(&x, 30)
|
|
assert old == 20
|
|
assert x == 30
|
|
}
|
|
|
|
fn test_load_i32_basic() {
|
|
mut x := i32(123456)
|
|
assert load_i32(&x) == 123456
|
|
}
|
|
|
|
fn test_store_i32_basic() {
|
|
mut x := i32(5)
|
|
store_i32(&x, 777)
|
|
assert x == 777
|
|
}
|
|
|
|
fn test_add_i32_concurrent() {
|
|
mut x := i32(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 9 {
|
|
threads << spawn fn (ptr &i32) {
|
|
for _ in 0 .. 100_000 {
|
|
add_i32(ptr, 1)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 900_000
|
|
}
|
|
|
|
fn test_swap_i32_concurrent() {
|
|
mut x := i32(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (ptr &i32) {
|
|
for _ in 0 .. 50_000 {
|
|
swap_i32(ptr, 123)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 123
|
|
}
|
|
|
|
fn test_cas_i32_concurrent() {
|
|
mut x := i32(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (ptr &i32) {
|
|
for _ in 0 .. 100_000 {
|
|
for {
|
|
old := load_i32(ptr)
|
|
if cas_i32(ptr, old, old + 1) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 800_000
|
|
}
|
|
|
|
fn test_load_store_i32_concurrent() {
|
|
mut x := i32(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 4 {
|
|
threads << spawn fn (px &i32) {
|
|
for _ in 0 .. 50_000 {
|
|
add_i32(px, 1)
|
|
}
|
|
}(&x)
|
|
}
|
|
for _ in 0 .. 4 {
|
|
threads << spawn fn (px &i32) {
|
|
for _ in 0 .. 50_000 {
|
|
_ = load_i32(px)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 4 * 50_000
|
|
}
|
|
|
|
fn test_and_i32_concurrent() {
|
|
mut x := i32(0x7fffffff)
|
|
mut threads := []thread{}
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i32) {
|
|
for _ in 0 .. 100_000 {
|
|
and_i32(px, 0x0fffffff)
|
|
}
|
|
}(&x)
|
|
}
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
assert x == 0x0fffffff
|
|
}
|
|
|
|
fn test_or_i32_concurrent() {
|
|
mut x := i32(0)
|
|
mut threads := []thread{}
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i32) {
|
|
for _ in 0 .. 100_000 {
|
|
or_i32(px, 0x12345678)
|
|
}
|
|
}(&x)
|
|
}
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
assert x == 0x12345678
|
|
}
|