MVar package:primitive
Primitive operations on
MVar. This module provides a similar
interface to
Control.Concurrent.MVar. However, the functions
are generalized to work in any
PrimMonad instead of only
working in
IO. Note that all of the functions here are
completely deterministic. Users of
MVar are responsible for
designing abstractions that guarantee determinism in the presence of
multi-threading.
For a more detailed explanation, see
Control.Concurrent.MVar.
A synchronizing variable, used for communication between concurrent
threads. It can be thought of as a box, which may be empty or full.
Check whether a given
MVar is empty.
Notice that the boolean value returned is just a snapshot of the state
of the
MVar. By the time you get to react on its result, the
MVar may have been filled (or emptied) - so be extremely
careful when using this operation. Use
tryTakeMVar instead if
possible.
Create a new
MVar that is initially empty.
Create a new
MVar that holds the supplied argument.
Put a value into an
MVar. If the
MVar is currently full,
putMVar will wait until it becomes empty.
There are two further important properties of
putMVar:
- putMVar is single-wakeup. That is, if there are multiple
threads blocked in putMVar, and the MVar becomes empty,
only one thread will be woken up. The runtime guarantees that the
woken thread completes its putMVar operation.
- When multiple threads are blocked on an MVar, they are
woken up in FIFO order. This is useful for providing fairness
properties of abstractions built using MVars.
Atomically read the contents of an
MVar. If the
MVar is
currently empty,
readMVar will wait until it is full.
readMVar is guaranteed to receive the next
putMVar.
Multiple Wakeup: readMVar is multiple-wakeup, so when
multiple readers are blocked on an
MVar, all of them are woken
up at the same time.
- It is single-wakeup instead of multiple-wakeup.
- It might not receive the value from the next call to
putMVar if there is already a pending thread blocked on
takeMVar.
- If another thread puts a value in the MVar in between the
calls to takeMVar and putMVar, that value may be
overridden.
Return the contents of the
MVar. If the
MVar is
currently empty,
takeMVar will wait until it is full. After a
takeMVar, the
MVar is left empty.
There are two further important properties of
takeMVar:
- takeMVar is single-wakeup. That is, if there are multiple
threads blocked in takeMVar, and the MVar becomes full,
only one thread will be woken up. The runtime guarantees that the
woken thread completes its takeMVar operation.
- When multiple threads are blocked on an MVar, they are
woken up in FIFO order. This is useful for providing fairness
properties of abstractions built using MVars.
A non-blocking version of
putMVar. The
tryPutMVar
function attempts to put the value
a into the
MVar,
returning
True if it was successful, or
False otherwise.
A non-blocking version of
readMVar. The
tryReadMVar
function returns immediately, with
Nothing if the
MVar
was empty, or
Just a if the
MVar was full with
contents
a.
- It is single-wakeup instead of multiple-wakeup.
- In the presence of other threads calling putMVar,
tryReadMVar may block.
- If another thread puts a value in the MVar in between the
calls to tryTakeMVar and putMVar, that value may be
overridden.
Variant of
MutVar that has one less indirection for primitive
types. The difference is illustrated by comparing
MutVar Int
and
PrimVar Int:
- MutVar Int: MutVar# --> I#
- PrimVar Int: MutableByteArray#
This module is adapted from a module in Edward Kmett's
prim-ref library.
A
PrimVar behaves like a single-element mutable primitive
array.
Create a pinned primitive reference with the appropriate alignment for
its contents.
Create a pinned primitive reference.
Create a primitive reference.