Implement basic criterion benchmarking suite

Author: Russoul

timeseries-io/bench/Bench.hs

@@ -0,0 +1,62 @@
+{-# OPTIONS_GHC -Wno-name-shadowing #-}
+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}
+{-# OPTIONS_GHC -Wno-deprecations #-}
+import           Cardano.Logging (forHuman)
+import           Cardano.Logging.Resources (ResourceStats, Resources (..), readResourceStats)
+import           Cardano.Timeseries.Import.PlainCBOR
+import           Cardano.Timeseries.Query (interp)
+import           Cardano.Timeseries.Query.Expr (Expr)
+import           Cardano.Timeseries.Query.Parser (expr)
+import           Cardano.Timeseries.Query.Value (Error, Value)
+import           Cardano.Timeseries.Store
+import           Cardano.Timeseries.Store.Flat (Flat, Point (instant, name))
+import           Cardano.Timeseries.Store.Parser (points)
+import           Cardano.Timeseries.Store.Tree (fromFlat)
+
+import           Control.Monad (forever)
+import           Control.Monad.Except (runExceptT)
+import           Control.Monad.State.Strict (evalState)
+import           Data.Attoparsec (skipMany)
+import           Data.Attoparsec.Text (decimal, endOfInput, parseOnly, space)
+import           Data.Either (fromRight)
+import           Data.Foldable (for_, traverse_)
+import           Data.Text (pack)
+import           GHC.List (foldl')
+import           System.Exit (die)
+import           System.IO (hFlush, stdout)
+
+import           Criterion.Main
+
+-- Given a snapshots file
+-- Given a query string
+-- Bench mark evaluation of the query
+
+snapshotsFile :: String
+snapshotsFile = "data/6nodes_4hours_1mininterval.cbor"
+
+query :: String
+query = "\
+  \let start = milliseconds 1762173870000 in \
+  \let period = minutes 10 in \
+  \let F = range Forge_forged_counter \
+  \(fast_forward epoch start) \
+  \(fast_forward epoch (add_duration start period)) in \
+  \increase F"
+
+action :: Store s Double => (s, Expr) -> Value
+action (store, query) =
+  let Right !x = evalState (runExceptT $ interp store mempty query 0) 0 in x
+
+main :: IO ()
+main = do
+  content <- readFileSnapshots snapshotsFile
+  let flatStore = snapshotsToFlatStore content
+  let treeStore = fromFlat flatStore
+  case parseOnly (expr <* skipMany space <* endOfInput) (pack query) of
+    Left err -> putStrLn err
+    Right !query -> defaultMain
+      [
+        bench "flat" $ nf action (flatStore, query),
+        bench "tree" $ nf action (treeStore, query)
+      ]
+

timeseries-io/data/6nodes_4hours_1mininterval.cbor

@@ -2,16 +2,20 @@ module Cardano.Timeseries.Domain.Instant(Instant(..), InstantVector, mostRecent,
 
 import           Cardano.Timeseries.Domain.Types (SeriesIdentifier, Timestamp)
 
+import           Control.DeepSeq (NFData)
 import qualified Data.Set as Set
 import           Data.Text (Text, intercalate, pack)
 import           Data.Vector
+import           GHC.Generics (Generic)
 
 -- | One datapoint in a series.
 data Instant a = Instant {
   labels :: SeriesIdentifier,
   timestamp :: Timestamp,
   value :: a
-} deriving (Show, Eq, Functor, Foldable, Traversable)
+} deriving (Show, Eq, Functor, Foldable, Traversable, Generic)
+
+instance NFData a => NFData (Instant a)
 
 -- | Do the instant vectors share a series?
 share :: Instant a -> Instant b -> Bool

timeseries-io/src/Cardano/Timeseries/Domain/Instant.hs

@@ -4,21 +4,25 @@
 module Cardano.Timeseries.Domain.Timeseries(Timeseries(..), TimeseriesVector,
   transpose, toVector, oldest, newest, eachOldest, eachNewest) where
 
-import           Cardano.Timeseries.Domain.Instant (InstantVector, Instant (Instant))
+import           Cardano.Timeseries.Domain.Instant (Instant (Instant), InstantVector)
 import qualified Cardano.Timeseries.Domain.Instant as Instant
 import           Cardano.Timeseries.Domain.Types
 
+import           Control.DeepSeq (NFData)
 import           Data.List (find, maximumBy, minimumBy)
 import           Data.Set
 import qualified Data.Set as Set
 import           Data.Vector (Vector)
 import qualified Data.Vector as Vector
+import           GHC.Generics (Generic)
 
 -- | A collection of datapoints sharing a series.
 data Timeseries a = Timeseries {
   labels :: SeriesIdentifier,
   dat :: [(Timestamp, a)]
-} deriving (Show, Functor, Foldable, Traversable)
+} deriving (Show, Functor, Foldable, Traversable, Generic)
+
+instance NFData a => NFData (Timeseries a)
 
 oldest :: Timeseries a -> Maybe (Instant a)
 oldest Timeseries{..} | Prelude.null dat = Nothing

timeseries-io/src/Cardano/Timeseries/Domain/Timeseries.hs

@@ -7,6 +7,8 @@ import           Control.Monad.Except (ExceptT)
 import           Control.Monad.State.Strict (State)
 import           Data.Text (unpack)
 import           Data.Word (Word64)
+import Control.DeepSeq (NFData)
+import GHC.Generics (Generic)
 
 type Error = String
 type FunctionValue = Value -> ExceptT Error (State Int) Value
@@ -30,7 +32,9 @@ data Value where
   -- | Timestamp (milliseconds since epoch)
   Timestamp :: Word64 -> Value
   -- | Function
-  Function :: FunctionValue -> Value
+  Function :: FunctionValue -> Value deriving Generic
+
+instance NFData Value
 
 instance Show Value where
   show (Scalar x) = show x

timeseries-io/src/Cardano/Timeseries/Query/Value.hs

@@ -22,7 +22,6 @@ common common
       LambdaCase
       NamedFieldPuns
       OverloadedStrings
-      StrictData
       Strict
 
 library
@@ -40,7 +39,8 @@ library
       containers,
       mtl,
       trace-resources,
-      trace-dispatcher
+      trace-dispatcher,
+      deepseq
 
     exposed-modules:
       Cardano.Timeseries.Domain.Instant,
@@ -99,4 +99,5 @@ benchmark timeseries-io-bench
       mtl,
       trace-resources,
       trace-dispatcher,
-      timeseries-io
+      timeseries-io,
+      criterion