atomic-counter-0.1.2.4: Mutable counters that can be modified with atomic operatinos

Copyright | (c) Sergey Vinokurov 2022
License | Apache-2.0 (see LICENSE)
Maintainer | serg.foo@gmail.com
Safe Haskell | None
Language | Haskell2010

Control.Concurrent.Counter.Unlifted

Contents

- Create
- Read/write
- Arithmetic operations
- Bitwise operations
- Compare

Description

Counters that support some atomic operations. Safe to use from multiple threads and likely faster than using `IORef` or `TVar` for the same operation (terms and conditions apply).

This module defines unlifted newtype wrapper and corresponding operations, they're not suitable for use with e.g. monads or being stored in other data structures that expect lifted types. For general use start with `Counter` module.

Synopsis

- data Counter s :: UnliftedType
- new :: Int# -> State# s -> (# State# s, Counter s #)
- get :: Counter s -> State# s -> (# State# s, Int# #)
- set :: Counter s -> Int# -> State# s -> (# State# s #)
- cas :: Counter s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
- add :: Counter s -> Int# -> State# s -> (# State# s, Int# #)
- sub :: Counter s -> Int# -> State# s -> (# State# s, Int# #)
- and :: Counter s -> Int# -> State# s -> (# State# s, Int# #)
- or :: Counter s -> Int# -> State# s -> (# State# s, Int# #)
- xor :: Counter s -> Int# -> State# s -> (# State# s, Int# #)
- nand :: Counter s -> Int# -> State# s -> (# State# s, Int# #)
- sameCounter :: Counter s -> Counter s -> Bool

# Documentation

data Counter s :: UnliftedType Source #

Memory location that supports select few atomic operations.

# Create

new :: Int# -> State# s -> (# State# s, Counter s #) Source #

Create new counter with initial value.

# Read/write

get :: Counter s -> State# s -> (# State# s, Int# #) Source #

Atomically read the counter's value.

set :: Counter s -> Int# -> State# s -> (# State# s #) Source #

Atomically assign new value to the counter.

cas :: Counter s -> Int# -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomic compare and swap, i.e. write the new value if the current value matches the provided old value. Returns the value of the element before the operation

Since: 0.1.2

# Arithmetic operations

add :: Counter s -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomically add an amount to the counter and return its old value.

sub :: Counter s -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomically subtract an amount from the counter and return its old value.

# Bitwise operations

and :: Counter s -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomically combine old value with a new one via bitwise and. Returns old counter value.

or :: Counter s -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomically combine old value with a new one via bitwise or. Returns old counter value.

xor :: Counter s -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomically combine old value with a new one via bitwise xor. Returns old counter value.

nand :: Counter s -> Int# -> State# s -> (# State# s, Int# #) Source #

Atomically combine old value with a new one via bitwise nand. Returns old counter value.

# Compare

sameCounter :: Counter s -> Counter s -> Bool Source #

Compare the underlying pointers of two counters.