188 lines
2.8 KiB
V
188 lines
2.8 KiB
V
// vtest build: !(macos || windows)
|
|
|
|
module atomics
|
|
|
|
fn test_load_u64_basic() {
|
|
mut x := u64(1234567890123)
|
|
assert load_u64(&x) == 1234567890123
|
|
}
|
|
|
|
fn test_store_u64_basic() {
|
|
mut x := u64(1)
|
|
store_u64(&x, 999999)
|
|
assert x == 999999
|
|
}
|
|
|
|
fn test_swap_u64_basic() {
|
|
mut x := u64(123)
|
|
old := swap_u64(&x, 999)
|
|
assert old == 123
|
|
assert x == 999
|
|
}
|
|
|
|
fn test_swap_u64_same() {
|
|
mut x := u64(777777)
|
|
old := swap_u64(&x, 777777)
|
|
assert old == 777777
|
|
assert x == 777777
|
|
}
|
|
|
|
fn test_add_u64_basic() {
|
|
mut x := u64(0)
|
|
for _ in 0 .. 1000 {
|
|
add_u64(&x, 2)
|
|
}
|
|
assert x == 2000
|
|
}
|
|
|
|
fn test_add_u64_wraparound() {
|
|
mut x := u64(0xffffffffffffffff)
|
|
add_u64(&x, 1)
|
|
assert x == 0
|
|
}
|
|
|
|
fn test_add_u64_return() {
|
|
mut x := u64(10)
|
|
r := add_u64(&x, 100)
|
|
assert r == 110
|
|
assert x == 110
|
|
}
|
|
|
|
fn test_cas_u64_basic() {
|
|
mut x := u64(111)
|
|
assert cas_u64(&x, 111, 222)
|
|
assert x == 222
|
|
}
|
|
|
|
fn test_cas_u64_fail() {
|
|
mut x := u64(500)
|
|
assert !cas_u64(&x, 100, 200)
|
|
assert x == 500
|
|
}
|
|
|
|
fn test_cas_u64_nochange_fail() {
|
|
mut x := u64(999)
|
|
cas_u64(&x, 1, 2)
|
|
assert x == 999
|
|
}
|
|
|
|
fn test_cas_u64_boundary() {
|
|
mut x := u64(0xffffffffffffffff)
|
|
assert cas_u64(&x, 0xffffffffffffffff, 0)
|
|
assert x == 0
|
|
}
|
|
|
|
fn test_add_u64_concurrent() {
|
|
mut x := u64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &u64) {
|
|
for _ in 0 .. 100_000 {
|
|
add_u64(px, 1)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 800_000
|
|
}
|
|
|
|
fn test_swap_u64_concurrent() {
|
|
mut x := u64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &u64) {
|
|
for _ in 0 .. 50_000 {
|
|
swap_u64(px, 123456)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 123456
|
|
}
|
|
|
|
fn test_cas_u64_concurrent_inc() {
|
|
mut x := u64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &u64) {
|
|
for _ in 0 .. 50_000 {
|
|
for {
|
|
old := load_u64(px)
|
|
if cas_u64(px, old, old + 1) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 400_000
|
|
}
|
|
|
|
fn test_cas_u64_contended_flip() {
|
|
mut x := u64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 4 {
|
|
threads << spawn fn (px &u64) {
|
|
for _ in 0 .. 200_000 {
|
|
cas_u64(px, 0, 1)
|
|
cas_u64(px, 1, 0)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 0 || x == 1
|
|
}
|
|
|
|
fn test_and_u64_concurrent() {
|
|
mut x := u64(0xffffffffffffffff)
|
|
mut threads := []thread{}
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &u64) {
|
|
for _ in 0 .. 100_000 {
|
|
and_u64(px, 0x00ff00ff00ff00ff)
|
|
}
|
|
}(&x)
|
|
}
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
assert x == 0x00ff00ff00ff00ff
|
|
}
|
|
|
|
fn test_or_u64_concurrent() {
|
|
mut x := u64(0)
|
|
mut threads := []thread{}
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &u64) {
|
|
for _ in 0 .. 100_000 {
|
|
or_u64(px, 0xfedcba9876543210)
|
|
}
|
|
}(&x)
|
|
}
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
assert x == u64(0xfedcba9876543210)
|
|
}
|