Std.Data.PrimIORef

This package provide fast unboxed references for IO monad and atomic operations for Counter type. Unboxed reference is implemented using single cell MutableByteArray s to eliminate indirection overhead which MutVar# s a carry, on the otherhand unboxed reference only support limited type(instances of Prim class).

Atomic operations on Counter type are implemented using fetch-and-add primitives, which is much faster than a CAS loop(atomicModifyIORef). Beside basic atomic counter usage, you can also leverage idempotence of and 0, or (-1) to make a concurrent flag.

Unboxed IO references

data PrimIORef a

A mutable variable in the IO monad which can hold an instance of Prim.

newPrimIORef :: Prim a => a -> IO (PrimIORef a)

Build a new PrimIORef

readPrimIORef :: Prim a => PrimIORef a -> IO a

Read the value of an PrimIORef

writePrimIORef :: Prim a => PrimIORef a -> a -> IO ()

Write a new value into an PrimIORef

modifyPrimIORef :: Prim a => PrimIORef a -> (a -> a) -> IO ()

Mutate the contents of an IORef.

Unboxed reference is always strict on the value it hold.

Atomic operations for PrimIORef Int

type Counter = PrimIORef Int

Alias for 'PrimIORef Int' which support several atomic operations.

newCounter :: Int -> IO Counter

Build a new Counter

return value BEFORE atomic operation

atomicAddCounter :: Counter -> Int -> IO Int

Atomically add a Counter, return the value BEFORE added.

atomicSubCounter :: Counter -> Int -> IO Int

Atomically sub a Counter, return the value BEFORE subbed.

atomicAndCounter :: Counter -> Int -> IO Int

Atomically and a Counter, return the value BEFORE anded.

atomicNandCounter :: Counter -> Int -> IO Int

Atomically nand a Counter, return the value BEFORE nanded.

atomicOrCounter :: Counter -> Int -> IO Int

Atomically or a Counter, return the value BEFORE ored.

atomicXorCounter :: Counter -> Int -> IO Int

Atomically xor a Counter, return the value BEFORE xored.

return value AFTER atomic operation

atomicAddCounter' :: Counter -> Int -> IO Int

Atomically add a Counter, return the value AFTER added.

atomicSubCounter' :: Counter -> Int -> IO Int

Atomically sub a Counter, return the value AFTER subbed.

atomicAndCounter' :: Counter -> Int -> IO Int

Atomically and a Counter, return the value AFTER anded.

atomicNandCounter' :: Counter -> Int -> IO Int

Atomically nand a Counter, return the value AFTER nanded.

atomicOrCounter' :: Counter -> Int -> IO Int

Atomically or a Counter, return the value AFTER ored.

atomicXorCounter' :: Counter -> Int -> IO Int

Atomically xor a Counter, return the value AFTER xored.

without returning

atomicAddCounter_ :: Counter -> Int -> IO ()

Atomically add a Counter.

atomicSubCounter_ :: Counter -> Int -> IO ()

Atomically sub a Counter

atomicAndCounter_ :: Counter -> Int -> IO ()

Atomically and a Counter

atomicNandCounter_ :: Counter -> Int -> IO ()

Atomically nand a Counter

atomicOrCounter_ :: Counter -> Int -> IO ()

Atomically or a Counter

atomicXorCounter_ :: Counter -> Int -> IO ()

Atomically xor a Counter