194 lines
2.9 KiB
V
194 lines
2.9 KiB
V
// vtest build: !(macos || windows)
|
|
|
|
module atomics
|
|
|
|
fn test_load_i64_basic() {
|
|
mut x := i64(1234567890123)
|
|
assert load_i64(&x) == 1234567890123
|
|
}
|
|
|
|
fn test_store_i64_basic() {
|
|
mut x := i64(1)
|
|
store_i64(&x, 9999999)
|
|
assert x == 9999999
|
|
}
|
|
|
|
fn test_swap_i64_basic() {
|
|
mut x := i64(50)
|
|
old := swap_i64(&x, 777)
|
|
assert old == 50
|
|
assert x == 777
|
|
}
|
|
|
|
fn test_swap_i64_same_value() {
|
|
mut x := i64(-123)
|
|
old := swap_i64(&x, -123)
|
|
assert old == -123
|
|
assert x == -123
|
|
}
|
|
|
|
fn test_add_i64_basic() {
|
|
mut x := i64(0)
|
|
for _ in 0 .. 1000 {
|
|
add_i64(&x, 3)
|
|
}
|
|
assert x == 3000
|
|
}
|
|
|
|
fn test_add_i64_negative_delta() {
|
|
mut x := i64(100)
|
|
add_i64(&x, -7)
|
|
assert x == 93
|
|
}
|
|
|
|
fn test_add_i64_wraparound_behavior() {
|
|
mut x := i64(0x7fffffffffffffff)
|
|
add_i64(&x, 1)
|
|
assert x == -0x8000000000000000
|
|
}
|
|
|
|
fn test_add_i64_return_value() {
|
|
mut x := i64(10)
|
|
r := add_i64(&x, 100)
|
|
assert r == 110
|
|
assert x == 110
|
|
}
|
|
|
|
fn test_cas_i64_basic() {
|
|
mut x := i64(111)
|
|
assert cas_i64(&x, 111, 222)
|
|
assert x == 222
|
|
}
|
|
|
|
fn test_cas_i64_fail() {
|
|
mut x := i64(555)
|
|
assert !cas_i64(&x, 123, 999)
|
|
assert x == 555
|
|
}
|
|
|
|
fn test_cas_i64_nochange_on_fail() {
|
|
mut x := i64(-999)
|
|
cas_i64(&x, 1, 5)
|
|
assert x == -999
|
|
}
|
|
|
|
fn test_cas_i64_negative_values() {
|
|
mut x := i64(-123456)
|
|
assert cas_i64(&x, -123456, 777)
|
|
assert x == 777
|
|
}
|
|
|
|
fn test_add_i64_concurrent() {
|
|
mut x := i64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i64) {
|
|
for _ in 0 .. 100_000 {
|
|
add_i64(px, 1)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 800_000
|
|
}
|
|
|
|
fn test_swap_i64_concurrent() {
|
|
mut x := i64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i64) {
|
|
for _ in 0 .. 50_000 {
|
|
swap_i64(px, 12345)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 12345
|
|
}
|
|
|
|
fn test_cas_i64_concurrent_inc() {
|
|
mut x := i64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i64) {
|
|
for _ in 0 .. 50_000 {
|
|
for {
|
|
old := load_i64(px)
|
|
if cas_i64(px, old, old + 1) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 400_000
|
|
}
|
|
|
|
fn test_cas_i64_contended_flip() {
|
|
mut x := i64(0)
|
|
mut threads := []thread{}
|
|
|
|
for _ in 0 .. 4 {
|
|
threads << spawn fn (px &i64) {
|
|
for _ in 0 .. 200_000 {
|
|
cas_i64(px, 0, 1)
|
|
cas_i64(px, 1, 0)
|
|
}
|
|
}(&x)
|
|
}
|
|
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
|
|
assert x == 0 || x == 1
|
|
}
|
|
|
|
fn test_and_i64_concurrent() {
|
|
mut x := i64(0x7fffffffffffffff)
|
|
mut threads := []thread{}
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i64) {
|
|
for _ in 0 .. 100_000 {
|
|
and_i64(px, 0x00ffffffffffffff)
|
|
}
|
|
}(&x)
|
|
}
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
assert x == 0x00ffffffffffffff
|
|
}
|
|
|
|
fn test_or_i64_concurrent() {
|
|
mut x := i64(0)
|
|
mut threads := []thread{}
|
|
for _ in 0 .. 8 {
|
|
threads << spawn fn (px &i64) {
|
|
for _ in 0 .. 100_000 {
|
|
or_i64(px, 0x0123456789abcdef)
|
|
}
|
|
}(&x)
|
|
}
|
|
for t in threads {
|
|
t.wait()
|
|
}
|
|
assert x == 0x0123456789abcdef
|
|
}
|