Data.Atomics.Counter.Foreign

This implementation stores an unboxed counter and uses FFI operations to modify its contents. It has the advantage that it can use true fetch-and-add operations. It has the disadvantage of extra overhead due to FFI calls.

For more documentation, see the module Data.Atomics.Counter, which exports the same interface as this module.

Documentation

type AtomicCounter = ForeignPtr Int

The type of mutable atomic counters.

type CTicket = Int

You should not depend on this type. It varies between different implementations of atomic counters.

newCounter :: Int -> IO AtomicCounter

Create a new counter initialized to the given value.

readCounterForCAS :: AtomicCounter -> IO CTicket

Just like the Data.Atomics CAS interface, this routine returns an opaque ticket that can be used in CAS operations.

readCounter :: AtomicCounter -> IO Int

Equivalent to readCounterForCAS followed by peekCTicket.

peekCTicket :: CTicket -> Int

Opaque tickets cannot be constructed, but they can be destructed into values.

writeCounter :: AtomicCounter -> Int -> IO ()

Make a non-atomic write to the counter. No memory-barrier.

casCounter :: AtomicCounter -> CTicket -> Int -> IO (Bool, CTicket)

Compare and swap for the counter ADT.

incrCounter :: Int -> AtomicCounter -> IO Int

Increment the counter by a given amount. Returns the original value before the increment.

Note that UNLIKE with boxed implementations of counters, where increment is based on CAS, this increment is O(1). Fetch-and-add does not require a retry loop like CAS.

incrCounter_ :: Int -> AtomicCounter -> IO ()

An alternate version for when you don't care about the old value.