packages feed

kenshou-measure-0.1.0.0: src/Kenshou/Measure/Load/Closed.hs

{-# LANGUAGE BangPatterns #-}

module Kenshou.Measure.Load.Closed (runClosed) where

import Control.Concurrent (threadDelay)
import Control.Concurrent.Async
import Control.Exception (SomeAsyncException, SomeException, fromException, throwIO, try)
import Control.Monad (forM, when)
import Data.IORef
import Data.Word (Word64)
import Kenshou.Measure.Clock
import Kenshou.Measure.Load.Series
import Kenshou.Measure.Load.Types
import Kenshou.Measure.Phase
import Kenshou.Measure.Recorder
import Kenshou.Measure.Session
import System.Timeout (timeout)

runClosed :: Measurement -> ClosedConfig -> Operation -> IO LoadReport
runClosed measurement config operation = do
  opHandle <- registerOp (measurementRecorder measurement) operation.name
  offered <- newIORef 0
  completed <- newIORef 0
  failed <- newIORef 0
  steadyCompleted <- newIORef 0
  maxLag <- newIORef 0
  loadSeries <- openLoadSeries measurement
  let phaseClock = measurementPhaseClock measurement
      plan = (measurementConfig measurement).defaultPhases
  enterPhase phaseClock WarmUp
  sampleLoadSeries loadSeries measurement offered offered completed failed maxLag
  workers <- forM [0 .. config.workers - 1] \workerId -> do
    workerRecorder <- newWorkerRecorder opHandle workerId
    async do
      when (config.staggerNs > 0) (sleepNanos (fromIntegral workerId * config.staggerNs `div` fromIntegral (max 1 config.workers)))
      workerLoop phaseClock workerRecorder workerId 0 offered completed failed steadyCompleted
  sleepNanos (unNanos plan.warmUp)
  enterPhase phaseClock Steady
  sampleLoadSeries loadSeries measurement offered offered completed failed maxLag
  case plan.steady of
    SteadyFor duration -> sleepNanos (unNanos duration)
    SteadyCount target -> waitForCount steadyCompleted target
  enterPhase phaseClock Drain
  sampleLoadSeries loadSeries measurement offered offered completed failed maxLag
  let drainMicros = fromIntegral (min (unNanos plan.drain `div` 1_000) (fromIntegral (maxBound :: Int)))
  drained <- timeout drainMicros (mapM_ wait workers)
  case drained of
    Just () -> pure ()
    Nothing -> mapM_ cancel workers
  enterPhase phaseClock Done
  sampleLoadSeries loadSeries measurement offered offered completed failed maxLag
  closeLoadSeries loadSeries
  offeredValue <- readIORef offered
  completedValue <- readIORef completed
  failedValue <- readIORef failed
  let report = (emptyLoadReport (ClosedLoop config)) {offered = offeredValue, started = offeredValue, completed = completedValue, failed = failedValue}
  appendLoadReport measurement report
  pure report
  where
    workerLoop phaseClock workerRecorder workerId sequenceNumber offered completed failed steadyCompleted = do
      phase <- currentPhase phaseClock
      case phase of
        Drain -> pure ()
        Done -> pure ()
        _ -> do
          intended <- nowNs
          increment offered
          result <- try (operation.run workerId sequenceNumber)
          ended <- nowNs
          opResult <- case result of
            Left err | Just (_ :: SomeAsyncException) <- fromException err -> throwIO err
            Left (_ :: SomeException) -> pure (OpFailed (ErrorCause "exception"))
            Right value -> pure value
          recordOp workerRecorder intended intended ended opResult
          increment completed
          case opResult of OpFailed _ -> increment failed; OpOk _ -> pure ()
          when (phase == Steady) (increment steadyCompleted)
          when (config.thinkTimeNs > 0) (sleepNanos config.thinkTimeNs)
          workerLoop phaseClock workerRecorder workerId (sequenceNumber + 1) offered completed failed steadyCompleted

increment :: IORef Word64 -> IO ()
increment counter = atomicModifyIORef' counter (\value -> let !next = value + 1 in (next, ()))

waitForCount :: IORef Word64 -> Word64 -> IO ()
waitForCount counter target = do
  current <- readIORef counter
  if current >= target then pure () else threadDelay 1_000 >> waitForCount counter target

sleepNanos :: Word64 -> IO ()
sleepNanos duration = nowNs >>= sleepUntilNs . (+ duration)

unNanos :: Nanos -> Word64
unNanos (Nanos value) = value