Atomics

V has no special support for atomics, yet, nevertheless it’s possible to treat variables as atomics by calling C functions from V. The standard C11 atomic functions like atomic_store() are usually defined with the help of macros and C compiler magic to provide a kind of overloaded C functions. Since V does not support overloading functions by intention there are wrapper functions defined in C headers named atomic.h that are part of the V compiler infrastructure.

There are dedicated wrappers for all unsigned integer types and for pointers. (byte is not fully supported on Windows) – the function names include the type name as suffix. e.g. C.atomic_load_ptr() or C.atomic_fetch_add_u64().

To use these functions the C header for the used OS has to be included and the functions that are intended to be used have to be declared. Example:

  1. // globals
  2. $if windows {
  3.     #include "@VEXEROOT/thirdparty/stdatomic/win/atomic.h"
  4. } $else {
  5.     #include "@VEXEROOT/thirdparty/stdatomic/nix/atomic.h"
  6. }
  8. // declare functions we want to use - V does not parse the C header
  9. fn C.atomic_store_u32(&u32, u32)
  10. fn C.atomic_load_u32(&u32) u32
  11. fn C.atomic_compare_exchange_weak_u32(&u32, &u32, u32) bool
  12. fn C.atomic_compare_exchange_strong_u32(&u32, &u32, u32) bool
  14. const num_iterations = 10000000
  16. // see section "Global Variables" below
  17. __global (
  18.     atom u32 // ordinary variable but used as atomic
  19. )
  21. fn change() int {
  22.     mut races_won_by_change := 0
  23.     for {
  24.         mut cmp := u32(17) // addressable value to compare with and to store the found value
  25.         // atomic version of `if atom == 17 { atom = 23 races_won_by_change++ } else { cmp = atom }`
  26.         if C.atomic_compare_exchange_strong_u32(&atom, &cmp, 23) {
  27.             races_won_by_change++
  28.         } else {
  29.             if cmp == 31 {
  30.                 break
  31.             }
  32.             cmp = 17 // re-assign because overwritten with value of atom
  33.         }
  34.     }
  35.     return races_won_by_change
  36. }
  38. fn main() {
  39.     C.atomic_store_u32(&atom, 17)
  40.     t := go change()
  41.     mut races_won_by_main := 0
  42.     mut cmp17 := u32(17)
  43.     mut cmp23 := u32(23)
  44.     for i in 0 .. num_iterations {
  45.         // atomic version of `if atom == 17 { atom = 23 races_won_by_main++ }`
  46.         if C.atomic_compare_exchange_strong_u32(&atom, &cmp17, 23) {
  47.             races_won_by_main++
  48.         } else {
  49.             cmp17 = 17
  50.         }
  51.         desir := if i == num_iterations - 1 { u32(31) } else { u32(17) }
  52.         // atomic version of `for atom != 23 {} atom = desir`
  53.         for !C.atomic_compare_exchange_weak_u32(&atom, &cmp23, desir) {
  54.             cmp23 = 23
  55.         }
  56.     }
  57.     races_won_by_change := t.wait()
  58.     atom_new := C.atomic_load_u32(&atom)
  59.     println('atom: $atom_new, #exchanges: ${races_won_by_main + races_won_by_change}')
  60.     // prints `atom: 31, #exchanges: 10000000`)
  61.     println('races won by\n- `main()`: $races_won_by_main\n- `change()`: $races_won_by_change')
  62. }

In this example both main() and the spawned thread change() try to replace a value of 17 in the global atom with a value of 23. The replacement in the opposite direction is done exactly 10000000 times. The last replacement will be with 31 which makes the spawned thread finish.

It is not predictable how many replacements occur in which thread, but the sum will always be 10000000. (With the non-atomic commands from the comments the value will be higher or the program will hang – dependent on the compiler optimization used.)