kenshou-measure-0.1.0.0: src/Kenshou/Measure/Sampler.hs
module Kenshou.Measure.Sampler
( Sampler (..),
SamplerConfig (..),
SamplerReport (..),
SamplingHandle,
startSampling,
stopSampling,
)
where
import Control.Concurrent.Async
import Control.Concurrent.STM
import Control.Exception (finally)
import Control.Monad (forM_)
import Data.IORef
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Word (Word64)
import Kenshou.Measure.Clock
import Kenshou.Measure.Phase
import Kenshou.Measure.Sampler.Csv
import Kenshou.Measure.Sampler.Host
import Kenshou.Measure.Sampler.Postgres
import Kenshou.Measure.Sampler.Process
import Kenshou.Measure.Sampler.Rts
import System.FilePath ((</>))
data Sampler = Sampler
{ name :: Text,
sample :: [Text] -> IO ()
}
data SamplerConfig = SamplerConfig
{ runDir :: FilePath,
origin :: Origin,
intervalMs :: Int,
postgres :: Maybe PgSamplerConfig,
extraSamplers :: [Sampler],
phaseClock :: PhaseClock,
declareArtifact :: FilePath -> Text -> IO (),
logLine :: Text -> IO ()
}
data SamplerReport = SamplerReport
{ rtsAvailable :: Bool,
processAvailable :: Bool,
hostAvailable :: Bool,
postgresAvailable :: Bool,
pgStatementsAvailable :: Bool,
ticks :: Word64
}
deriving stock (Eq, Show)
data Event = Boundary | Scheduled | Stop
data SamplingHandle = SamplingHandle
{ threads :: [Async ()],
events :: TChan Event,
closeResources :: IO (),
report :: IO SamplerReport
}
startSampling :: SamplerConfig -> IO SamplingHandle
startSampling config = do
let seriesDir = config.runDir </> "series"
path name = seriesDir </> name
declare name = config.declareArtifact (path name) "text/csv"
events <- newBroadcastTChanIO
phaseEvents <- atomically (dupTChan events)
postgresEvents <- atomically (dupTChan events)
addBoundaryListener config.phaseClock (atomically (writeTChan events Boundary))
samplerWriter <- openCsv (path "sampler.csv") ["t_mono_ns", "t_wall_ms", "phase", "scheduled_mono_ns", "late_ns", "cost_ns", "wall_minus_mono_ns"]
declare "sampler.csv"
rts <- openRtsSampler (path "rts.csv")
forM_ rts (const (declare "rts.csv"))
process <- openProcessSampler (path "proc.csv")
declare "proc.csv"
host <- openHostSampler (path "host.csv")
forM_ host (const (declare "host.csv"))
previousClockDelta <- newIORef Nothing
tickCount <- newIORef 0
mainThread <- async (mainLoop config phaseEvents samplerWriter rts process host previousClockDelta tickCount 1)
postgresResult <- case config.postgres of
Nothing -> pure Nothing
Just pgConfig -> do
opened <- openPostgresSampler seriesDir pgConfig config.logLine
case opened of
Left err -> config.logLine ("PostgreSQL sampler unavailable: " <> err) >> pure Nothing
Right sampler -> do
mapM_ declare (postgresArtifactNames (postgresHasStatements sampler))
thread <- async (postgresLoop config postgresEvents sampler 1 `finally` closePostgresSampler sampler)
pure (Just (thread, postgresHasStatements sampler))
let closeResources = do
closeCsv samplerWriter
forM_ rts closeRtsSampler
closeProcessSampler process
forM_ host closeHostSampler
readReport = do
count <- readIORef tickCount
pure
SamplerReport
{ rtsAvailable = maybe False (const True) rts,
processAvailable = True,
hostAvailable = maybe False (const True) host,
postgresAvailable = maybe False (const True) postgresResult,
pgStatementsAvailable = maybe False snd postgresResult,
ticks = count
}
pure
SamplingHandle
{ threads = mainThread : maybe [] (pure . fst) postgresResult,
events,
closeResources,
report = readReport
}
stopSampling :: SamplingHandle -> IO SamplerReport
stopSampling handle = do
atomically (writeTChan handle.events Stop)
mapM_ wait handle.threads `finally` handle.closeResources
handle.report
mainLoop :: SamplerConfig -> TChan Event -> CsvWriter -> Maybe RtsSampler -> ProcessSampler -> Maybe HostSampler -> IORef (Maybe Integer) -> IORef Word64 -> Word64 -> IO ()
mainLoop config events samplerWriter rts process host previousClockDelta tickCount tickNumber = do
let intervalNs = fromIntegral config.intervalMs * 1_000_000
scheduled = config.origin.monoNs + tickNumber * intervalNs
event <- waitForEvent events scheduled
case event of
Stop -> pure ()
Boundary -> nowNs >>= sampleAll >> mainLoop config events samplerWriter rts process host previousClockDelta tickCount tickNumber
Scheduled -> sampleAll scheduled >> mainLoop config events samplerWriter rts process host previousClockDelta tickCount (tickNumber + 1)
where
sampleAll scheduled = do
started <- nowNs
(_, prefix) <- timestampColumns config.origin config.phaseClock
forM_ rts (`sampleRts` prefix)
sampleProcess process prefix
forM_ host (`sampleHost` prefix)
forM_ config.extraSamplers (\sampler -> sampler.sample prefix)
ended <- nowNs
wallOrigin <- captureOrigin
let delta = fromIntegral wallOrigin.wallUnixNs - fromIntegral wallOrigin.monoNs
previous <- readIORef previousClockDelta
writeIORef previousClockDelta (Just delta)
let clockChange = maybe 0 (delta -) previous
value = Text.pack . show
appendCsv samplerWriter (prefix <> fmap value [scheduled - min scheduled config.origin.monoNs, started - min started scheduled, ended - started] <> [Text.pack (show clockChange)])
atomicModifyIORef' tickCount (\count -> (count + 1, ()))
postgresLoop :: SamplerConfig -> TChan Event -> PostgresSampler -> Word64 -> IO ()
postgresLoop config events sampler tickNumber = do
let intervalNs = fromIntegral config.intervalMs * 1_000_000
scheduled = config.origin.monoNs + tickNumber * intervalNs
event <- waitForEvent events scheduled
case event of
Stop -> pure ()
Boundary -> sampleNow True >> postgresLoop config events sampler tickNumber
Scheduled -> sampleNow (postgresPeriodic sampler && tickNumber `mod` 10 == 0) >> postgresLoop config events sampler (tickNumber + 1)
where
sampleNow includeStatements = do
(_, prefix) <- timestampColumns config.origin config.phaseClock
samplePostgres sampler prefix includeStatements
waitForEvent :: TChan Event -> Word64 -> IO Event
waitForEvent events deadline = do
current <- nowNs
let remainingNs = deadline - min deadline current
remainingMicros = fromIntegral (min (fromIntegral (maxBound :: Int)) ((remainingNs + 999) `div` 1_000))
elapsed <- registerDelay remainingMicros
atomically $
readTChan events
`orElse` do
readTVar elapsed >>= check
pure Scheduled