`Kcas_data.Accumulator`

Scalable accumulator.

A scalable accumulator can be used to scalably accumulate an integer value in parallel as long as the accumulated value is read infrequently.

`val make : ?n_way:int -> int -> t`

`make n`

returns a new accumulator whose initial value is `n`

.

The optional `n_way`

argument can be used to specify a desired level of parallelism, i.e. maximum number of non-interfering parallel updates. The default value is chosen to strike a balance between scalability and memory use and a given value may be adjusted by the implementation.

`val n_way_of : t -> int`

`n_way_of a`

returns the maximum number of non-interfering parallel updates supported by the accumulator `a`

.

**NOTE**: The returned value may not be the same as given to `make`

.

`module Tx : sig ... end`

Transactions on accumulators.

`module Xt : sig ... end`

Explicit transaction log passing on accumulators.

`val add : t -> int -> unit`

`add a n`

increments the value of the accumulator `a`

by `n`

. `add`

operations can be performed scalably in parallel.

`val incr : t -> unit`

`incr a`

is equivalent to `add a 1`

.

`val decr : t -> unit`

`decr a`

is equivalent to `add a (-1)`

.

`val get : t -> int`

`get a`

returns the current value of the accumulator.

**CAUTION**: Performing a `get`

is expensive and can limit scalability.

`val set : t -> int -> unit`

`set a n`

sets the current value of the accumulator `a`

to `n`

.