Control.Concurrent.PriorityChansConverger.PriorityChansConverger

This module wraps STM PCC with IO. Some locks are added to balance heavyweight transactions, to reduce "waste efforts".

PriorityChansConverger ADT and it's administration

data PCC_Lock

Constructors

PCC_Lock

PCC_IOInterruptableRead

PCC_IOInterruptableWrite

Instances

Eq PCC_Lock

Ord PCC_Lock

Show PCC_Lock

data Ord k => PriorityChansConverger k e

Wrapper around PriorityChansConvergerSTM. Added locks. Show instance is defined using unsafePerformIO.

Constructors

PriorityChansConverger

Fields

pccSTM :: PriorityChansConvergerSTM k e

pccLocks :: Map PCC_Lock (MVar ())

reportIfPossible :: Ord k => PriorityChansConverger k e -> String -> IO ()

maybeObserveExceptions :: Ord k => PriorityChansConverger k e -> FunctionName -> IO a -> IO a

newPriorityChansConverger :: Ord k => Map k (StartPriority, ChanCapacity) -> IO (PriorityChansConverger k e)

Wrapper around newPriorityChansConverger_wCUIS constructor.

newPriorityChansConverger = newPriorityChansConverger_wCUIS Nothing

newPriorityChansConverger_wCUIS :: Ord k => Maybe ConcurrentUISupport -> Map k (StartPriority, ChanCapacity) -> IO (PriorityChansConverger k e)

Wrapper around newPriorityChansConvergerSTM_wCUIS constructor. With an option to enable utility ConcurrentUISupport (which is useful for debugging)

type FunctionName = String

type LockUserName = FunctionName

lockPCC :: Ord k => LockUserName -> [PCC_Lock] -> PriorityChansConverger k e -> IO ()

Sort the locks and lock them.

WARNING !!! Asynchronous exceptions may cause loss of locks!

unlockPCC :: Ord k => LockUserName -> [PCC_Lock] -> PriorityChansConverger k e -> IO ()

Reverse sort the locks and unlock them.

WARNING !!! Asynchronous exceptions may cause loss of locks!

withLockedDo :: Ord k => LockUserName -> [PCC_Lock] -> PriorityChansConverger k e -> IO a -> IO a

Locking IO action wrapper.

WARNING !!! Asynchronous exceptions may cause loss of locks!

PriorityChansConverger mutation

isOfStructPCC :: Ord k => Map k (StartPriority, ChanCapacity) -> PriorityChansConverger k e -> IO (PCC_ContainsGivenSpecification, NothingElseIsInStruct)

Wrapper around isOfStructPCC_STM. Used locks: none.

mutatePCC :: Ord k => Map k (StartPriority, ChanCapacity) -> PriorityChansConverger k e -> IO (PriorityChansConverger k e)

Wrapper around mutatePCC_STM. Used locks: [PCC_Lock]

PriorityChansConverger I/O

writeInPCC :: Ord k => PermitToBlock -> k -> e -> PriorityChansConverger k e -> IO (Maybe FailureReasonWPCC)

Wrapper around writeInPCC_STM. Used locks: if blocking, then [] else [PCC_Lock].

If blocking is enabled, may block, when there is no free space in PriorityChan.

stmInterruptableWriteInPCC :: Ord k => STM InterruptShouldWe -> k -> e -> PriorityChansConverger k e -> IO (Either () (Maybe FailureReasonWPCC))

Wrapper around interruptableWriteInPCC_STM. Used locks: []

Blocking write.

Do not put the control of the STM InterruptShouldWe under PCC_Lock. Keep there False, if you don't want to get Left () in return. Put there True, whenever you want to stop waiting.

interruptableWriteInPCC :: Ord k => (Chan a, a -> InterruptShouldWe) -> k -> e -> PriorityChansConverger k e -> IO (Either () (Maybe FailureReasonWPCC))

Wrapper around stmInterruptableWriteInPCC. Used locks: [PCC_IOInterruptableWrite]

Blocking read.

Creates a TVar Bool to control the interruptability of write operation. Spawns additional thread, which cyclicly reads given Chan and checks, if it signals terminating condition - if so, then using interrupter TVar stops trying to write in PCC. Temporary thread gets terminated at the end.

readFromPCC :: Ord k => PermitToBlock -> PriorityChansConverger k e -> IO (Maybe (k, e))

Wrapper around readFromPCC_STM. Used locks: if blocking, then [] else [PCC_Lock].

stmInterruptableReadFromPCC :: Ord k => STM InterruptShouldWe -> PriorityChansConverger k e -> IO (Either () (k, e))

Wrapper around interruptableReadFromPCC_STM. Used locks: []

Blocking read.

interruptableReadFromPCC :: Ord k => (Chan a, a -> InterruptShouldWe) -> PriorityChansConverger k e -> IO (Either () (k, e))

Wrapper around stmInterruptableReadFromPCC. Used locks: [PCC_IOInterruptableRead]

Blocking read.

Creates a TVar Bool to control the interruptability of read operation. Spawns additional thread, which cyclicly reads given Chan and checks, if it signals terminating condition - if so, then using interrupter TVar stops trying to write in PCC. Temporary thread gets terminated at the end.

flushPCC2List :: Ord k => PriorityChansConverger k e -> IO [(k, e)]

Wrapper around flushPCC2List_STM. Used locks: [PCC_Lock]

Lazy (doublecheck that).

flushPCC2List' :: Ord k => PriorityChansConverger k e -> IO [(k, e)]

Wrapper around flushPCC2List_STM' (see Control.Concurrent.PriorityChansConverger.PriorityChansConverger). Used locks: [PCC_Lock]

Strict. Should be a bit faster than flushPCC2List.

fastFlushPCC2List' :: Ord k => PriorityChansConverger k e -> IO [(k, e)]

Wrapper around fastFlushPCC2List_STM' (see Control.Concurrent.PriorityChansConverger.PriorityChansConverger). Used locks: [PCC_Lock]

Strict. This is a fast flush, it doesn't deal with priorities.

isEmptyPCC :: Ord k => PriorityChansConverger k e -> IO Bool

Wrapper around isEmptyPCC_STM. Used locks: none

freeSpaceInPCCInput :: Ord k => PriorityChansConverger k e -> k -> IO (Maybe ChanContentAmountMeasure)

Wrapper around freeSpaceInPCCInput_STM. Used locks: none

filterOutPCCElements' :: Ord k => PriorityChansConverger k e -> (e -> TakeElementOutShouldWe) -> IO [(k, e)]

Wrapper around filterOutPCCElements_STM' (see Control.Concurrent.PriorityChansConverger.PriorityChansConverger). Used locks: [PCC_Lock]

Strict.

Take everything, applu filter, return what's left in the PCC, return what's taken out.

PriorityChansConverger representation

showPCC :: (Ord k, Show k, Show e) => PriorityChansConverger k e -> IO String

Wrapper around showPCC. Used locks: none