{-# LINE 1 "System/Metrics/Distribution.hsc" #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE UnboxedTuples #-}
{-# OPTIONS_GHC -funbox-strict-fields #-}




-- | This module defines a type for tracking statistics about a series
-- of events. An event could be handling of a request and the value
-- associated with the event -- the value you'd pass to 'add' -- could
-- be the amount of time spent serving that request (e.g. in
-- milliseconds). All operations are thread safe.
module System.Metrics.Distribution
    ( Distribution
    , new
    , add
    , addN
    , read

      -- * Gathered statistics
    , Stats
    , mean
    , variance
    , count
    , sum
    , min
    , max
    ) where

import Control.Monad (forM_, replicateM)
import Prelude hiding (max, min, read, sum)

import Foreign.Storable (sizeOf)

import GHC.Float
import GHC.Int (Int(..), Int64(..))
import GHC.IO
import GHC.Prim

import Data.Array
import System.Metrics.Distribution.Internal (Stats(..))
import System.Metrics.ThreadId

-- Three cases for these definitions
-- 64-bit, GHC has Int64
-- 64-bit, GHC doesn't have Int64
-- 32-bit

-- 64-bit machine, Int ~ Int64, do it the fast way:

{-# LINE 54 "System/Metrics/Distribution.hsc" #-}


{-# LINE 56 "System/Metrics/Distribution.hsc" #-}
int64ToDouble :: Int64# -> Double#
int64ToDouble :: Int64# -> Double#
int64ToDouble Int64#
i = Int# -> Double#
int2Double# (Int64# -> Int#
int64ToInt# Int64#
i)

intToInt64 :: Int# -> Int64#
intToInt64 :: Int# -> Int64#
intToInt64 = Int# -> Int64#
intToInt64#

plusInt64 :: Int64# -> Int64# -> Int64#
plusInt64 :: Int64# -> Int64# -> Int64#
plusInt64 = Int64# -> Int64# -> Int64#
plusInt64#

eqInt64 :: Int64# -> Int64# -> Int#
eqInt64 :: Int64# -> Int64# -> Int#
eqInt64 = Int64# -> Int64# -> Int#
eqInt64#

readInt64Array :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array :: forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array = MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array#

writeInt64Array :: MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeInt64Array :: forall d.
MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeInt64Array = MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
forall d.
MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeInt64Array#


{-# LINE 93 "System/Metrics/Distribution.hsc" #-}


{-# LINE 117 "System/Metrics/Distribution.hsc" #-}

-- | An metric for tracking events.
newtype Distribution = Distribution { Distribution -> Array Stripe
unD :: Array Stripe }

newtype Stripe = Stripe { Stripe -> Distrib
stripeD :: Distrib }

data Distrib = Distrib (MutableByteArray# RealWorld)

unI :: Int -> Int#
unI :: Int -> Int#
unI (I# Int#
x) = Int#
x
{-# INLINE unI #-}

distribLen :: Int
distribLen :: Int
distribLen = ((Int
56))
{-# LINE 131 "System/Metrics/Distribution.hsc" #-}

lockPos :: Int
lockPos :: Int
lockPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
0))
{-# LINE 134 "System/Metrics/Distribution.hsc" #-}
              (Int -> Int
forall a. Storable a => a -> Int
sizeOf (Int
forall a. HasCallStack => a
undefined :: Int))

countPos :: Int
countPos :: Int
countPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
8))
{-# LINE 138 "System/Metrics/Distribution.hsc" #-}
               (Int64 -> Int
forall a. Storable a => a -> Int
sizeOf (Int64
forall a. HasCallStack => a
undefined :: Int64))

meanPos :: Int
meanPos :: Int
meanPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
16))
{-# LINE 142 "System/Metrics/Distribution.hsc" #-}
              (Double -> Int
forall a. Storable a => a -> Int
sizeOf (Double
forall a. HasCallStack => a
undefined :: Double))

sumSqDeltaPos :: Int
sumSqDeltaPos :: Int
sumSqDeltaPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
24))
{-# LINE 146 "System/Metrics/Distribution.hsc" #-}
                    (Double -> Int
forall a. Storable a => a -> Int
sizeOf (Double
forall a. HasCallStack => a
undefined :: Double))

sumPos :: Int
sumPos :: Int
sumPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
32))
{-# LINE 150 "System/Metrics/Distribution.hsc" #-}
             (Double -> Int
forall a. Storable a => a -> Int
sizeOf (Double
forall a. HasCallStack => a
undefined :: Double))

minPos :: Int
minPos :: Int
minPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
40))
{-# LINE 154 "System/Metrics/Distribution.hsc" #-}
             (Double -> Int
forall a. Storable a => a -> Int
sizeOf (Double
forall a. HasCallStack => a
undefined :: Double))

maxPos :: Int
maxPos :: Int
maxPos = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div ((Int
48))
{-# LINE 158 "System/Metrics/Distribution.hsc" #-}
             (Double -> Int
forall a. Storable a => a -> Int
sizeOf (Double
forall a. HasCallStack => a
undefined :: Double))

newDistrib :: IO Distrib
newDistrib :: IO Distrib
newDistrib = (State# RealWorld -> (# State# RealWorld, Distrib #)) -> IO Distrib
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Distrib #))
 -> IO Distrib)
-> (State# RealWorld -> (# State# RealWorld, Distrib #))
-> IO Distrib
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s ->
    case Int#
-> State# RealWorld
-> (# State# RealWorld, MutableByteArray# RealWorld #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# (Int -> Int#
unI Int
distribLen) State# RealWorld
s of { (# State# RealWorld
s1, MutableByteArray# RealWorld
mba #) ->
    -- probably unnecessary
    case MutableByteArray# RealWorld
-> Int# -> Int# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
atomicWriteIntArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
lockPos) Int#
0# State# RealWorld
s1 of { State# RealWorld
s2 ->
    case MutableByteArray# RealWorld
-> Int# -> Int64# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeInt64Array MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
countPos) (Int# -> Int64#
intToInt64 Int#
0#) State# RealWorld
s2 of { State# RealWorld
s3 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
meanPos) Double#
0.0## State# RealWorld
s3 of { State# RealWorld
s4 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumSqDeltaPos) Double#
0.0## State# RealWorld
s4 of { State# RealWorld
s5 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumPos) Double#
0.0## State# RealWorld
s5 of { State# RealWorld
s6 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
minPos) Double#
0.0## State# RealWorld
s6 of { State# RealWorld
s7 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
maxPos) Double#
0.0## State# RealWorld
s7 of { State# RealWorld
s8 ->
    (# State# RealWorld
s8, MutableByteArray# RealWorld -> Distrib
Distrib MutableByteArray# RealWorld
mba #) }}}}}}}}

newStripe :: IO Stripe
newStripe :: IO Stripe
newStripe = do
    Distrib
d <- IO Distrib
newDistrib
    Stripe -> IO Stripe
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Stripe -> IO Stripe) -> Stripe -> IO Stripe
forall a b. (a -> b) -> a -> b
$! Stripe
        { stripeD :: Distrib
stripeD = Distrib
d
        }

-- | Number of lock stripes. Should be greater or equal to the number
-- of HECs.
numStripes :: Int
numStripes :: Int
numStripes = Int
8

-- | Get the stripe to use for this thread.
myStripe :: Distribution -> IO Stripe
myStripe :: Distribution -> IO Stripe
myStripe Distribution
distrib = do
    Int
tid <- IO Int
myCapability
    Stripe -> IO Stripe
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Stripe -> IO Stripe) -> Stripe -> IO Stripe
forall a b. (a -> b) -> a -> b
$! Distribution -> Array Stripe
unD Distribution
distrib Array Stripe -> Int -> Stripe
forall a. Array a -> Int -> a
`index` (Int
tid Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
numStripes)

------------------------------------------------------------------------
-- Exposed API

-- | Create a new distribution.
new :: IO Distribution
new :: IO Distribution
new = (Array Stripe -> Distribution
Distribution (Array Stripe -> Distribution)
-> ([Stripe] -> Array Stripe) -> [Stripe] -> Distribution
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Stripe] -> Array Stripe
forall a. Int -> [a] -> Array a
fromList Int
numStripes) ([Stripe] -> Distribution) -> IO [Stripe] -> IO Distribution
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap`
      Int -> IO Stripe -> IO [Stripe]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
numStripes IO Stripe
newStripe

-- | Add a value to the distribution.
add :: Distribution -> Double -> IO ()
add :: Distribution -> Double -> IO ()
add Distribution
distrib Double
val = Distribution -> Double -> Int64 -> IO ()
addN Distribution
distrib Double
val Int64
1

{-# INLINE spinLock #-}
spinLock :: MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinLock :: MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinLock MutableByteArray# RealWorld
mba = \State# RealWorld
s ->
    case MutableByteArray# RealWorld
-> Int#
-> Int#
-> Int#
-> State# RealWorld
-> (# State# RealWorld, Int# #)
forall d.
MutableByteArray# d
-> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)
casIntArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
lockPos) Int#
0# Int#
1# State# RealWorld
s of { (# State# RealWorld
s1, Int#
r #) ->
    case Int#
r of { Int#
0# -> State# RealWorld
s1; Int#
_ ->
    case State# RealWorld -> State# RealWorld
yield# State# RealWorld
s1 of { State# RealWorld
s2 ->
    MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinLock MutableByteArray# RealWorld
mba State# RealWorld
s2 }}}

{-# INLINE spinUnlock #-}
spinUnlock :: MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinUnlock :: MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinUnlock MutableByteArray# RealWorld
mba = \State# RealWorld
s ->
    case MutableByteArray# RealWorld
-> Int# -> Int# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeIntArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
lockPos) Int#
0# State# RealWorld
s of { State# RealWorld
s2 -> State# RealWorld
s2 }


-- | Add the same value to the distribution N times.
--   Mean and variance are computed according to
--   http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm
addN :: Distribution -> Double -> Int64 -> IO ()
addN :: Distribution -> Double -> Int64 -> IO ()
addN Distribution
distribution (D# Double#
val) (I64# Int64#
n) = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s ->
    case Distribution -> IO Stripe
myStripe Distribution
distribution of { (IO State# RealWorld -> (# State# RealWorld, Stripe #)
myStripe') ->
    case State# RealWorld -> (# State# RealWorld, Stripe #)
myStripe' State# RealWorld
s of { (# State# RealWorld
s1, (Stripe (Distrib MutableByteArray# RealWorld
mba)) #) ->
    case MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinLock MutableByteArray# RealWorld
mba State# RealWorld
s1 of { State# RealWorld
s2 ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Int64# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
countPos) State# RealWorld
s2 of { (# State# RealWorld
s3, Int64#
count #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
meanPos) State# RealWorld
s3 of { (# State# RealWorld
s4, Double#
mean #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumSqDeltaPos) State# RealWorld
s4 of { (# State# RealWorld
s5, Double#
sumSqDelta #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumPos) State# RealWorld
s5 of { (# State# RealWorld
s6, Double#
dSum #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
minPos) State# RealWorld
s6 of { (# State# RealWorld
s7, Double#
dMin #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
maxPos) State# RealWorld
s7 of { (# State# RealWorld
s8, Double#
dMax #) ->
    case Int64# -> Int64# -> Int64#
plusInt64 Int64#
count Int64#
n of { Int64#
count' ->
    case Double#
val Double# -> Double# -> Double#
-## Double#
mean of { Double#
delta ->
    case Double#
mean Double# -> Double# -> Double#
+## ((Int64# -> Double#
int64ToDouble Int64#
n) Double# -> Double# -> Double#
*## Double#
delta Double# -> Double# -> Double#
/## (Int64# -> Double#
int64ToDouble Int64#
count')) of { Double#
mean' ->
    case Double#
sumSqDelta Double# -> Double# -> Double#
+## (Double#
delta Double# -> Double# -> Double#
*## (Double#
val Double# -> Double# -> Double#
-## Double#
mean') Double# -> Double# -> Double#
*## (Int64# -> Double#
int64ToDouble Int64#
n)) of { Double#
sumSqDelta' ->
    case MutableByteArray# RealWorld
-> Int# -> Int64# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeInt64Array MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
countPos) Int64#
count' State# RealWorld
s8 of { State# RealWorld
s9 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
meanPos) Double#
mean' State# RealWorld
s9 of { State# RealWorld
s10 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumSqDeltaPos) Double#
sumSqDelta' State# RealWorld
s10 of { State# RealWorld
s11 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumPos) (Double#
dSum Double# -> Double# -> Double#
+## Double#
val) State# RealWorld
s11 of { State# RealWorld
s12 ->
    case (case Double#
val Double# -> Double# -> Int#
<## Double#
dMin of { Int#
0# -> Double#
dMin; Int#
_ -> Double#
val }) of { Double#
dMin' ->
    case (case Double#
val Double# -> Double# -> Int#
>## Double#
dMax of { Int#
0# -> Double#
dMax; Int#
_ -> Double#
val }) of { Double#
dMax' ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
minPos) Double#
dMin' State# RealWorld
s12 of { State# RealWorld
s13 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
maxPos) Double#
dMax' State# RealWorld
s13 of { State# RealWorld
s14 ->
    case MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinUnlock MutableByteArray# RealWorld
mba State# RealWorld
s14 of { State# RealWorld
s15 ->
    (# State# RealWorld
s15, () #) }}}}}}}}}}}}}}}}}}}}}}

-- | Combine 'b' with 'a', writing the result in 'a'. Takes the lock of
--   'b' while combining, but doesn't otherwise modify 'b'. 'a' is
--   assumed to not be used concurrently.
--   See also:
--   http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Parallel_algorithm
combine :: Distrib -> Distrib -> IO ()
combine :: Distrib -> Distrib -> IO ()
combine (Distrib MutableByteArray# RealWorld
bMBA) (Distrib MutableByteArray# RealWorld
aMBA) = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s ->
    case MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinLock MutableByteArray# RealWorld
bMBA State# RealWorld
s of { State# RealWorld
s1 ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Int64# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
countPos) State# RealWorld
s1 of { (# State# RealWorld
s2, Int64#
aCount #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Int64# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array MutableByteArray# RealWorld
bMBA (Int -> Int#
unI Int
countPos) State# RealWorld
s2 of { (# State# RealWorld
s3, Int64#
bCount #) ->
    case Int64# -> Int64# -> Int64#
plusInt64 Int64#
aCount Int64#
bCount of { Int64#
count' ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
meanPos) State# RealWorld
s3 of { (# State# RealWorld
s4, Double#
aMean #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
bMBA (Int -> Int#
unI Int
meanPos) State# RealWorld
s4 of { (# State# RealWorld
s5, Double#
bMean #) ->
    case Double#
bMean Double# -> Double# -> Double#
-## Double#
aMean of { Double#
delta ->
    case (   (((Int64# -> Double#
int64ToDouble Int64#
aCount) Double# -> Double# -> Double#
*## Double#
aMean) Double# -> Double# -> Double#
+## ((Int64# -> Double#
int64ToDouble Int64#
bCount) Double# -> Double# -> Double#
*## Double#
bMean))
         Double# -> Double# -> Double#
/## (Int64# -> Double#
int64ToDouble Int64#
count')
         ) of { Double#
mean' ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
sumSqDeltaPos) State# RealWorld
s5 of { (# State# RealWorld
s6, Double#
aSumSqDelta #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
bMBA (Int -> Int#
unI Int
sumSqDeltaPos) State# RealWorld
s6 of { (# State# RealWorld
s7, Double#
bSumSqDelta #) ->
    case (   Double#
aSumSqDelta 
         Double# -> Double# -> Double#
+## Double#
bSumSqDelta
         Double# -> Double# -> Double#
+## (   Double#
delta
               Double# -> Double# -> Double#
*## Double#
delta
               Double# -> Double# -> Double#
*## (   (Int64# -> Double#
int64ToDouble Int64#
aCount) Double# -> Double# -> Double#
*## (Int64# -> Double#
int64ToDouble Int64#
bCount)
                     Double# -> Double# -> Double#
/## (Int64# -> Double#
int64ToDouble Int64#
count')
                     )
               )
         ) of { Double#
sumSqDelta' ->
    case MutableByteArray# RealWorld
-> Int# -> Int64# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
writeInt64Array MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
countPos) Int64#
count' State# RealWorld
s7 of { State# RealWorld
s8 ->
    case (case Int64# -> Int64# -> Int#
eqInt64 Int64#
count' (Int# -> Int64#
intToInt64 Int#
0#) of { Int#
0# -> Double#
mean'; Int#
_ -> Double#
0.0## }) of { Double#
writeMean ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
meanPos) Double#
writeMean State# RealWorld
s8 of { State# RealWorld
s9 ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
sumSqDeltaPos) Double#
sumSqDelta' State# RealWorld
s9 of { State# RealWorld
s10 ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
sumPos) State# RealWorld
s10 of { (# State# RealWorld
s11, Double#
aSum #) ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
bMBA (Int -> Int#
unI Int
sumPos) State# RealWorld
s11 of { (# State# RealWorld
s12, Double#
bSum #) ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
sumPos) (Double#
aSum Double# -> Double# -> Double#
+## Double#
bSum) State# RealWorld
s12 of { State# RealWorld
s13 ->
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
bMBA (Int -> Int#
unI Int
minPos) State# RealWorld
s13 of { (# State# RealWorld
s14, Double#
bMin #) ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
minPos) Double#
bMin State# RealWorld
s14 of { State# RealWorld
s15 ->
    -- This is slightly hacky, but ok: see
    -- 813aa426be78e8abcf1c7cdd43433bcffa07828e
    case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
bMBA (Int -> Int#
unI Int
maxPos) State# RealWorld
s15 of { (# State# RealWorld
s16, Double#
bMax #) ->
    case MutableByteArray# RealWorld
-> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# RealWorld
aMBA (Int -> Int#
unI Int
maxPos) Double#
bMax State# RealWorld
s16 of { State# RealWorld
s17 ->
    case MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
spinUnlock MutableByteArray# RealWorld
bMBA State# RealWorld
s17 of { State# RealWorld
s18 ->
    (# State# RealWorld
s18, () #) }}}}}}}}}}}}}}}}}}}}}}}

-- | Get the current statistical summary for the event being tracked.
read :: Distribution -> IO Stats
read :: Distribution -> IO Stats
read Distribution
distrib = do
    result :: Distrib
result@(Distrib MutableByteArray# RealWorld
mba) <- IO Distrib
newDistrib
    [Stripe] -> (Stripe -> IO ()) -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (Array Stripe -> [Stripe]
forall a. Array a -> [a]
toList (Array Stripe -> [Stripe]) -> Array Stripe -> [Stripe]
forall a b. (a -> b) -> a -> b
$ Distribution -> Array Stripe
unD Distribution
distrib) ((Stripe -> IO ()) -> IO ()) -> (Stripe -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \(Stripe Distrib
d) ->
        Distrib -> Distrib -> IO ()
combine Distrib
d Distrib
result
    (State# RealWorld -> (# State# RealWorld, Stats #)) -> IO Stats
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Stats #)) -> IO Stats)
-> (State# RealWorld -> (# State# RealWorld, Stats #)) -> IO Stats
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s ->
        case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Int64# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
readInt64Array MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
countPos) State# RealWorld
s of { (# State# RealWorld
s1, Int64#
count #) ->
        case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
meanPos) State# RealWorld
s1 of { (# State# RealWorld
s2, Double#
mean #) ->
        case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumSqDeltaPos) State# RealWorld
s2 of { (# State# RealWorld
s3, Double#
sumSqDelta #) ->
        case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
sumPos) State# RealWorld
s3 of { (# State# RealWorld
s4, Double#
dSum #) ->
        case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
minPos) State# RealWorld
s4 of { (# State# RealWorld
s5, Double#
dMin #) ->
        case MutableByteArray# RealWorld
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# RealWorld
mba (Int -> Int#
unI Int
maxPos) State# RealWorld
s5 of { (# State# RealWorld
s6, Double#
dMax #) ->
        (# State# RealWorld
s6
        , Stats { mean :: Double
mean = (Double# -> Double
D# Double#
mean)
                , variance :: Double
variance = if (Int64# -> Int64
I64# Int64#
count) Int64 -> Int64 -> Bool
forall a. Eq a => a -> a -> Bool
== Int64
0 then Double
0.0
                             else (Double# -> Double
D# Double#
sumSqDelta) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (Double# -> Double
D# (Int64# -> Double#
int64ToDouble Int64#
count))
                , count :: Int64
count = (Int64# -> Int64
I64# Int64#
count)
                , sum :: Double
sum = (Double# -> Double
D# Double#
dSum)
                , min :: Double
min = (Double# -> Double
D# Double#
dMin)
                , max :: Double
max = (Double# -> Double
D# Double#
dMax)
                }
        #) }}}}}}