Module Atomic

module Atomic: sig .. end

This module provides a purely sequential implementation of the concurrent atomic references provided by the Multicore OCaml standard library:

https://github.com/ocaml-multicore/ocaml-multicore/blob/parallel_minor_gc/stdlib/atomic.mli

This sequential implementation is provided in the interest of compatibility: when people will start writing code to run on Multicore, it would be nice if their use of Atomic was backward-compatible with older versions of OCaml without having to import additional compatibility layers.

type t('a);

An atomic (mutable) reference to a value of type 'a.

let make: 'a => t('a);

Create an atomic reference.

let get: t('a) => 'a;

Get the current value of the atomic reference.

let set: (t('a), 'a) => unit;

Set a new value for the atomic reference.

let exchange: (t('a), 'a) => 'a;

Set a new value for the atomic reference, and return the current value.

let compare_and_set: (t('a), 'a, 'a) => bool;

compare_and_set r seen v sets the new value of r to v only if its current value is physically equal to seen -- the comparison and the set occur atomically. Returns true if the comparison succeeded (so the set happened) and false otherwise.

let fetch_and_add: (t(int), int) => int;

fetch_and_add r n atomically increments the value of r by n, and returns the current value (before the increment).

let incr: t(int) => unit;

incr r atomically increments the value of r by 1.

let decr: t(int) => unit;

decr r atomically decrements the value of r by 1.