hoare-0.2.0.0: lib/Control/Concurrent/Channel/Metrics.hs
-- |
-- Stability : experimental
--
-- Wrappers around "Control.Concurrent.Channel.Split" that gather metrics
-- at handoffs between threads.
module Control.Concurrent.Channel.Metrics (
ReaderMetrics(..),
newReaderMetrics,
readChannel,
drainChannel,
WriterMetrics(..),
newWriterMetrics,
writeChannel,
overwriteChannel,
consumeChannel,
consumeChannelBatches,
consumeChannelBatches',
stateConsumeChannel,
stateConsumeChannelBatches,
stateConsumeChannelBatches',
feedChannel,
evalFeedChannel
) where
import Control.Concurrent.Async
import Control.Concurrent.STM
import Control.DeepSeq
import Control.Exception (evaluate)
import Control.Monad
import Data.Functor ((<&>))
import Data.IORef
import Data.Maybe
import Data.Word
import System.Clock.Seconds
import Control.Concurrent.Channel qualified as C
import Control.Concurrent.Channel.Overwrite
import Control.Concurrent.Channel.Split (Reader, Writer)
import Control.Concurrent.Channel.Split qualified as CS
import Control.Concurrent.Channel.Try
data ReaderMetrics = ReaderMetrics {
elapsedWait :: !Seconds,
totalRead :: !Word64,
waitedFor :: !Word64
}
newReaderMetrics :: ReaderMetrics
newReaderMetrics = ReaderMetrics 0 0 0
mlen :: Maybe a -> Word64
mlen j = if isJust j then 1 else 0
delayedReader :: Word64 -> Seconds -> ReaderMetrics -> ReaderMetrics
delayedReader n dt m = if wasFirst then m1 else mrest where
wasFirst = m.totalRead == 0
-- Don't count blocking for the first item against our wait.
m1 = ReaderMetrics{elapsedWait = 0, totalRead = n, waitedFor = 0}
mrest = m{
elapsedWait = m.elapsedWait + dt,
totalRead = m.totalRead + n,
waitedFor = m.waitedFor + n
}
readChannel :: (C.Channel c) => Reader c a -> ReaderMetrics -> IO (Maybe a, ReaderMetrics)
readChannel r !m = timedAtomically (CS.readChannel r) <&> \case
(v, Nothing) -> (v, m{totalRead = m.totalRead + mlen v})
(v, Just dt) -> (v, delayedReader (mlen v) dt m)
wlen :: [a] -> Word64
wlen vs = fromIntegral $ length vs
drainChannel :: (C.Channel c) => Reader c a -> ReaderMetrics -> IO ([a], ReaderMetrics)
drainChannel r !m = timedAtomically (CS.drainChannel r) <&> \case
(vs, Nothing) -> (vs, m{totalRead = m.totalRead + wlen vs})
(vs, Just dt) -> (vs, delayedReader (wlen vs) dt m)
data WriterMetrics = WriterMetrics {
elapsedBlocked :: !Seconds,
totalWritten :: !Word64,
wereBlocked :: !Word64,
totalOverwritten :: !Word64
}
newWriterMetrics :: WriterMetrics
newWriterMetrics = WriterMetrics 0 0 0 0
-- Substantially simpler than `delayedReader` since a channel presumably never starts blocked,
-- so we don't have to ignore the first guy.
delayedWriter :: Seconds -> WriterMetrics -> WriterMetrics
delayedWriter dt m = m{
elapsedBlocked = m.elapsedBlocked + dt,
totalWritten = m.totalWritten + 1,
wereBlocked = m.wereBlocked + 1
}
writeChannel :: (C.Channel c) => Writer c a -> a -> WriterMetrics -> IO (Bool, WriterMetrics)
writeChannel w v !m = timedAtomically (CS.writeChannel w v) <&> \case
(True, Nothing) -> (True, m{totalWritten = m.totalWritten + 1})
(True, Just dt) -> (True, delayedWriter dt m)
(False, Nothing) -> (False, m)
(False, Just dt) -> (False, m{elapsedBlocked = m.elapsedBlocked + dt})
overwriteChannel :: (C.Channel c) => Writer c a -> a -> WriterMetrics -> STM (OverwriteResult a, WriterMetrics)
overwriteChannel w v !m = CS.overwriteChannel w v <&> \case
Closed -> (Closed, m)
Wrote -> (Wrote, m{totalWritten = m.totalWritten + 1})
o@(Overwrote _) -> (o, m{
totalWritten = m.totalWritten + 1,
totalOverwritten = m.totalOverwritten + 1
})
consumeChannel :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ReaderMetrics
consumeChannel r f = go newReaderMetrics where
go :: ReaderMetrics -> IO ReaderMetrics
go !m = readChannel r m >>= \case
(Just v, m') -> f v >> go m'
(Nothing, m') -> pure m'
consumeChannelBatches :: (C.Channel c) => Reader c a -> ([a] -> IO ()) -> IO ReaderMetrics
consumeChannelBatches r f = go newReaderMetrics where
go :: ReaderMetrics -> IO ReaderMetrics
go !m = drainChannel r m >>= \case
([], m') -> pure m'
(vs, m') -> f vs >> go m'
consumeChannelBatches' :: (C.Channel c) => Reader c a -> (a -> IO ()) -> IO ReaderMetrics
consumeChannelBatches' r f = consumeChannelBatches r $ mapM_ f
stateConsumeChannel :: forall a c s. (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO (s, ReaderMetrics)
stateConsumeChannel r initialState f = go initialState newReaderMetrics where
go :: s -> ReaderMetrics -> IO (s, ReaderMetrics)
go !state !m = readChannel r m >>= \case
(Just v, m') -> do
next <- f state v
go next m'
(Nothing, m') -> pure (state, m')
stateConsumeChannelBatches :: forall a c s. (C.Channel c) => Reader c a -> s -> (s -> [a] -> IO s) -> IO (s, ReaderMetrics)
stateConsumeChannelBatches r initialState f = go initialState newReaderMetrics where
go :: s -> ReaderMetrics -> IO (s, ReaderMetrics)
go !state !m = drainChannel r m >>= \case
([], m') -> pure (state, m')
(vs, m') -> do
next <- f state vs
go next m'
stateConsumeChannelBatches' :: (C.Channel c) => Reader c a -> s -> (s -> a -> IO s) -> IO (s, ReaderMetrics)
stateConsumeChannelBatches' r initialState f = stateConsumeChannelBatches r initialState $ foldM (\ !s v -> f s v)
feedChannel' :: (C.Channel c) => Writer c a -> IO (Maybe a) -> IORef WriterMetrics -> IO ()
feedChannel' w f mr = f >>= \case
Just v -> do
m <- readIORef mr
(stillOpen, m') <- writeChannel w v m
writeIORef mr m'
when stillOpen $ feedChannel' w f mr
Nothing -> atomically $ CS.closeChannel w
feedChannel :: (C.Channel c) => Writer c a -> IO (Maybe a) -> IO WriterMetrics
feedChannel w f = do
-- Stop when the consumer closes the channel, even if f blocks.
-- For example, f can block for a long time on a network socket.
let chanClosed = atomically $ CS.isClosedChannel w >>= check
mr <- newIORef newWriterMetrics
race_ (feedChannel' w f mr) chanClosed
readIORef mr
evalFeedChannel :: (C.Channel c, NFData a) => Writer c a -> IO (Maybe a) -> IO WriterMetrics
evalFeedChannel w f = feedChannel w f' where
f' = f >>= evaluate . force
{-# INLINE evalFeedChannel #-}