Loc (kcas.Kcas.Loc)

type !'a t

Type of shared memory locations.

val make : ?mode:Mode.t -> 'a -> 'a t

make initial creates a new shared memory location with the initial value.

The optional mode argument defaults to Mode.obstruction_free. If explicitly specified as Mode.lock_free, the location will always be accessed using the lock-free operating mode. This may improve performance in rare cases where a location is updated frequently and obstruction-free read-only accesses would almost certainly suffer from interference.

val make_array : ?mode:Mode.t -> int -> 'a -> 'a t array

make_array n initial creates an array of n new shared memory locations with the initial value.

val get_mode : 'a t -> Mode.t

get_mode r returns the operating mode of the shared memory location r.

val get_id : 'a t -> int

get_id r returns the unique id of the shared memory location r.

val get : 'a t -> 'a

get r reads the current value of the shared memory location r.

val get_as : ?timeoutf:float -> ('a -> 'b) -> 'a t -> 'b

get_as f loc is equivalent to f (get loc). The given function f may raise the Retry.Later exception to signal that the conditional load should be retried only after the location has been modified outside of the conditional load. It is also safe for the given function f to raise any other exception to abort the conditional load.

val compare_and_set : 'a t -> 'a -> 'a -> bool

compare_and_set r before after atomically updates the shared memory location r to the after value if the current value of r is the before value.

val update : ?timeoutf:float -> ?backoff:Backoff.t -> 'a t -> ('a -> 'a) -> 'a

update r f repeats let b = get r in compare_and_set r b (f b) until it succeeds and then returns the b value. The given function f may raise the Retry.Later exception to signal that the update should only be retried after the location has been modified outside of the update. It is also safe for the given function f to raise any other exception to abort the update.

val modify : 
  ?timeoutf:float ->
  ?backoff:Backoff.t ->
  'a t ->
  ('a -> 'a) ->
  unit

modify r f is equivalent to update r f |> ignore.

val exchange : ?backoff:Backoff.t -> 'a t -> 'a -> 'a

exchange r after atomically updates the shared memory location r to the after value and returns the current value (before the exchange).

val set : ?backoff:Backoff.t -> 'a t -> 'a -> unit

set r after atomically updates the shared memory location r to the after value.

val fetch_and_add : ?backoff:Backoff.t -> int t -> int -> int

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

val incr : ?backoff:Backoff.t -> int t -> unit

incr r atomically increments r.

val decr : ?backoff:Backoff.t -> int t -> unit

decr r atomically decrements r.