packages feed

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 #-}