simulation: sim stats calculations now opt-in with --analize flag

Author: Saizan

simulation/ouroboros-leios-sim.cabal

@@ -178,6 +178,7 @@ executable ols
     , base
     , containers
     , data-default
+    , filepath
     , optparse-applicative
     , ouroboros-leios-sim
     , random

simulation/src/Diffusion.hs

@@ -93,23 +93,28 @@ stableChainHashes chains =
    in map blockHash $ Chain.toNewestFirst stable_chain
 
 diffusionDataFromMap ::
+  Bool ->
   Map NodeId StakeFraction ->
   Map id (msg, NodeId, Time, [(NodeId, Time)]) ->
   DiffusionData id
-diffusionDataFromMap stakes arrivals = DiffusionData{..}
+diffusionDataFromMap analize stakes arrivals = DiffusionData{..}
  where
   entries =
     [ DiffusionEntry{..}
     | (block_id, (_, NodeId node_id, Time created, ts)) <- Map.toList arrivals
     , let adoptions = map (second (\(Time t) -> t)) ts
     ]
-  latency_per_stake = map (diffusionEntryToLatencyPerStake stakes) entries
+  latency_per_stake
+    | analize = map (diffusionEntryToLatencyPerStake stakes) entries
+    | otherwise = []
   avg ts = sum ts / fromIntegral (length ts)
-  average_latencies =
-    Map.map avg $
-      Map.fromListWith
-        (++)
-        [ (p, [d])
-        | l <- latency_per_stake
-        , (Just d, p) <- l.latencies
-        ]
+  average_latencies
+    | analize =
+        Map.map avg $
+          Map.fromListWith
+            (++)
+            [ (p, [d])
+            | l <- latency_per_stake
+            , (Just d, p) <- l.latencies
+            ]
+    | otherwise = Map.empty

simulation/src/LeiosProtocol/Short/VizSimP2P.hs

@@ -19,6 +19,7 @@ module LeiosProtocol.Short.VizSimP2P where
 import Chan.Driver
 import Control.Arrow ((&&&))
 import Control.Exception
+import Control.Monad
 import Data.Aeson
 import Data.Array.Unboxed (Ix, UArray, accumArray, (!))
 import Data.Bifunctor
@@ -84,7 +85,6 @@ import PraosProtocol.ExamplesPraosP2P ()
 import PraosProtocol.PraosNode (PraosMessage (..))
 import Sample
 import SimTypes (LabelLink (LabelLink), LabelNode (LabelNode), NodeId (..), Point (..), World (..))
-import System.FilePath (dropExtension, (<.>))
 import System.Random (StdGen, uniformR)
 import System.Random.Stateful (mkStdGen)
 import Text.Printf (printf)
@@ -988,51 +988,75 @@ data LeiosData = LeiosData
   }
   deriving (Generic, ToJSON, FromJSON)
 
-exampleSim :: Bool -> StdGen -> OnDisk.Config -> P2PNetwork -> Bool -> Time -> FilePath -> IO ()
-exampleSim doLog seed cfg p2pNetwork@P2PNetwork{..} emitControl stop@(Time stop') fp = do
-  let trace = exampleTrace2 seed cfg p2pNetwork
-  let sampleModel =
+data SimOutputConfig = SimOutputConfig
+  { logFile :: Maybe FilePath
+  , emitControl :: Bool
+  , dataFile :: Maybe FilePath
+  , analize :: Bool
+  , stop :: Time
+  }
+
+exampleSim :: StdGen -> OnDisk.Config -> P2PNetwork -> SimOutputConfig -> IO ()
+exampleSim seed cfg p2pNetwork@P2PNetwork{..} SimOutputConfig{stop = stop@(Time stop'), ..} = do
+  case dataFile of
+    Just fp ->
+      runModel
         SampleModel
           { initState = LeiosSimState IMap.empty Map.empty Map.empty Map.empty Map.empty Map.empty Map.empty
           , accumState = \t e s -> accumLeiosSimState t e s{chains = accumChains t e s.chains}
-          , renderState
+          , renderState = renderState fp
+          }
+    Nothing ->
+      runModel
+        SampleModel
+          { initState = ()
+          , accumState = \_ _ s -> s
+          , renderState = const (return ())
           }
-  runSampleModel' traceFile (logLeiosEvent p2pNodeNames emitControl) sampleModel stop trace
  where
-  traceFile
-    | doLog = Just (dropExtension fp <.> "log")
-    | otherwise = Nothing
-  renderState LeiosSimState{..} = do
+  runModel :: SampleModel LeiosEvent state -> IO ()
+  runModel model =
+    runSampleModel' logFile (logLeiosEvent p2pNodeNames emitControl) model stop $
+      exampleTrace2 seed cfg p2pNetwork
+  renderState fp LeiosSimState{..} = do
     let
-      ib_diffusion = diffusionDataFromMap p2pNodeStakes ibDiffusionLatency
-      eb_diffusion = diffusionDataFromMap p2pNodeStakes ebDiffusionLatency
-      vt_diffusion = diffusionDataFromMap p2pNodeStakes voteDiffusionLatency
-      rb_diffusion = coerce $ diffusionDataFromMap p2pNodeStakes rbDiffusionLatency
+      ib_diffusion = diffusionDataFromMap analize p2pNodeStakes ibDiffusionLatency
+      eb_diffusion = diffusionDataFromMap analize p2pNodeStakes ebDiffusionLatency
+      vt_diffusion = diffusionDataFromMap analize p2pNodeStakes voteDiffusionLatency
+      rb_diffusion = coerce $ diffusionDataFromMap analize p2pNodeStakes rbDiffusionLatency
       stable_chain_hashes = coerce $ stableChainHashes chains
       network = p2pNetworkToSomeTopology (fromIntegral $ Map.size p2pNodeStakes * 1000) p2pNetwork
-      (cpuUseSegments, Map.toAscList -> cpuUseCdfAvg) =
-        intervalsToSegmentsAndCdfAvg
-          Set.toList
-          (sum . ILMap.elems . fst)
-          (realToFrac stop')
-          nodeCpuUsage
       config = cfg
-      (transmittedBpsSegments, Map.toAscList -> transmittedBpsCdfAvg) =
-        intervalsToSegmentsAndCdfAvg
-          (uniformBins 20)
-          (\(im, i) -> assert (all (`ILMap.subsumes` i) $ ILMap.keys im) $ msgsTransmittedToBps . fst $ (im, i))
-          stop'
-          (Map.map (.messagesTransmitted) dataTransmittedPerNode)
-      (transmittedMsgsSegments, Map.toAscList -> transmittedMsgsCdfAvg) =
-        intervalsToSegmentsAndCdfAvg
-          Set.toList
-          (length . ILMap.elems . fst)
-          stop'
-          (Map.map (.messagesTransmitted) dataTransmittedPerNode)
+      maybeDoAnalysis :: (b, [a]) -> (b, [a])
+      maybeDoAnalysis = if analize then id else second (const [])
+      (cpuUseSegments, cpuUseCdfAvg) =
+        maybeDoAnalysis $
+          second Map.toAscList $
+            intervalsToSegmentsAndCdfAvg
+              Set.toList
+              (sum . ILMap.elems . fst)
+              (realToFrac stop')
+              nodeCpuUsage
+      (transmittedBpsSegments, transmittedBpsCdfAvg) =
+        maybeDoAnalysis $
+          second Map.toAscList $
+            intervalsToSegmentsAndCdfAvg
+              (uniformBins 20)
+              (\(im, i) -> assert (all (`ILMap.subsumes` i) $ ILMap.keys im) $ msgsTransmittedToBps . fst $ (im, i))
+              stop'
+              (Map.map (.messagesTransmitted) dataTransmittedPerNode)
+      (transmittedMsgsSegments, transmittedMsgsCdfAvg) =
+        maybeDoAnalysis $
+          second Map.toAscList $
+            intervalsToSegmentsAndCdfAvg
+              Set.toList
+              (length . ILMap.elems . fst)
+              stop'
+              (Map.map (.messagesTransmitted) dataTransmittedPerNode)
     let diffusionData = LeiosData{..}
     encodeFile fp diffusionData
     putStrLn $ "Data written to " ++ fp
-    reportAll diffusionData
+    when analize $ reportAll diffusionData
   reportAll LeiosData{..} = do
     sequence_ $
       [ uncurry report ("IB", ib_diffusion)

simulation/src/Main.hs

@@ -13,7 +13,7 @@ import Data.Aeson (eitherDecodeFileStrict')
 import Data.Default (Default (..))
 import Data.List (find)
 import qualified Data.Map as Map
-import Data.Maybe (fromMaybe)
+import Data.Maybe (fromMaybe, listToMaybe)
 import qualified ExamplesRelay
 import qualified ExamplesRelayP2P
 import qualified ExamplesTCP
@@ -64,6 +64,7 @@ import qualified PraosProtocol.VizSimChainSync as VizChainSync
 import qualified PraosProtocol.VizSimPraos as VizPraos
 import SimTypes
 import System.Exit (exitFailure)
+import System.FilePath
 import System.IO (hPutStrLn, stderr)
 import qualified System.Random as Random
 import TimeCompat
@@ -366,7 +367,15 @@ runSimOptions SimOptions{..} = case simCommand of
     let (rng1, rng2) = Random.split rng0
     config <- execConfigOptions configOptions
     p2pNetwork <- execTopologyOptions rng1 topologyOptions
-    VizShortLeiosP2P.exampleSim (not skipLog) rng2 config p2pNetwork emitControl simOutputSeconds simOutputFile
+    let outputCfg =
+          VizShortLeiosP2P.SimOutputConfig
+            { logFile = listToMaybe [dropExtension simOutputFile <.> "log" | not skipLog]
+            , emitControl
+            , dataFile = Just simOutputFile
+            , analize
+            , stop = simOutputSeconds
+            }
+    VizShortLeiosP2P.exampleSim rng2 config p2pNetwork outputCfg
 
 parserSimOptions :: Parser SimOptions
 parserSimOptions =
@@ -400,6 +409,7 @@ data SimCommand
       , topologyOptions :: TopologyOptions
       , emitControl :: Bool
       , skipLog :: Bool
+      , analize :: Bool
       }
 
 parserSimCommand :: Parser SimCommand
@@ -427,6 +437,7 @@ parserShortLeios =
     <*> parserTopologyOptions
     <*> switch (long "log-control" <> help "Include control messages in log.")
     <*> switch (long "no-log" <> help "Do not output event log.")
+    <*> switch (long "analize" <> help "Calculate metrics and statistics.")
 
 data ConfigOptions
   = LeiosConfigFile FilePath