Weigh

Framework for seeing how much a function allocates.

Example:

import Weigh
main =
  mainWith (do func "integers count 0" count 0
               func "integers count 1" count 1
               func "integers count 2" count 2
               func "integers count 3" count 3
               func "integers count 10" count 10
               func "integers count 100" count 100)
  where count :: Integer -> ()
        count 0 = ()
        count a = count (a - 1)

Main entry points

mainWith :: Weigh a -> IO ()

Just run the measuring and print a report. Uses weighResults.

weighResults :: Weigh a -> IO ([(Weight, Maybe String)], Config)

Run the measuring and return all the results, each one may have an error.

Configuration

setColumns :: [Column] -> Weigh ()

Set the config. Default is: defaultConfig.

data Column

Table column.

Constructors

Case

Allocated

GCs

Live

Check

Max

Instances

Enum Column

Methods

succ :: Column -> Column

pred :: Column -> Column

toEnum :: Int -> Column

fromEnum :: Column -> Int

enumFrom :: Column -> [Column]

enumFromThen :: Column -> Column -> [Column]

enumFromTo :: Column -> Column -> [Column]

enumFromThenTo :: Column -> Column -> Column -> [Column]

Eq Column

Methods

(==) :: Column -> Column -> Bool

(/=) :: Column -> Column -> Bool

Show Column

Methods

showsPrec :: Int -> Column -> ShowS

show :: Column -> String

showList :: [Column] -> ShowS

Simple combinators

func

Arguments

:: NFData a

=> String

Name of the case.

-> (b -> a)

Function that does some action to measure.

-> b

Argument to that function.

-> Weigh ()

Weigh a function applied to an argument.

Implemented in terms of validateFunc.

io

Arguments

:: NFData a

=> String

Name of the case.

-> (b -> IO a)

Aciton that does some IO to measure.

-> b

Argument to that function.

-> Weigh ()

Weigh an action applied to an argument.

Implemented in terms of validateAction.

value

Arguments

:: NFData a

=> String

Name for the value.

-> a

The value to measure.

-> Weigh ()

Weigh a value.

Implemented in terms of action.

action

Arguments

:: NFData a

=> String

Name for the value.

-> IO a

The action to measure.

-> Weigh ()

Weigh an IO action.

Implemented in terms of validateAction.

Validating combinators

validateAction

Arguments

:: NFData a

=> String

Name of the action.

-> (b -> IO a)

The function which performs some IO.

-> b

Argument to the function. Doesn't have to be forced.

-> (Weight -> Maybe String)

A validating function, returns maybe an error.

-> Weigh ()

Weigh an IO action, validating the result.

validateFunc

Arguments

:: NFData a

=> String

Name of the function.

-> (b -> a)

The function which calculates something.

-> b

Argument to the function. Doesn't have to be forced.

-> (Weight -> Maybe String)

A validating function, returns maybe an error.

-> Weigh ()

Weigh a function, validating the result

Validators

maxAllocs

Arguments

:: Int64

The upper bound.

-> Weight -> Maybe String

Make a validator that set sthe maximum allocations.

Types

data Weigh a

Weigh specification monad.

Instances

Monad Weigh

Methods

(>>=) :: Weigh a -> (a -> Weigh b) -> Weigh b

(>>) :: Weigh a -> Weigh b -> Weigh b

return :: a -> Weigh a

fail :: String -> Weigh a

Functor Weigh

Methods

fmap :: (a -> b) -> Weigh a -> Weigh b

(<$) :: a -> Weigh b -> Weigh a

Applicative Weigh

Methods

pure :: a -> Weigh a

(<*>) :: Weigh (a -> b) -> Weigh a -> Weigh b

(*>) :: Weigh a -> Weigh b -> Weigh b

(<*) :: Weigh a -> Weigh b -> Weigh a

data Weight

How much a computation weighed in at.

Constructors

Weight

Fields

• weightLabel :: !String
• weightAllocatedBytes :: !Int64
• weightGCs :: !Int64
• weightLiveBytes :: !Int64
• weightMaxBytes :: !Int64

Instances

Read Weight

Methods

readsPrec :: Int -> ReadS Weight

readList :: ReadS [Weight]

readPrec :: ReadPrec Weight

readListPrec :: ReadPrec [Weight]

Show Weight

Methods

showsPrec :: Int -> Weight -> ShowS

show :: Weight -> String

showList :: [Weight] -> ShowS

Handy utilities

commas :: (Num a, Integral a, Show a) => a -> String

Formatting an integral number to 1,000,000, etc.

Internals

weighDispatch

Arguments

:: [String]

Program arguments.

-> [(String, Action)]

Weigh name:action mapping.

-> IO (Maybe [Weight])

Weigh a set of actions. The value of the actions are forced completely to ensure they are fully allocated.

weighFunc

Arguments

:: NFData a

=> (b -> a)

A function whose memory use we want to measure.

-> b

Argument to the function. Doesn't have to be forced.

-> IO (Int64, Int64, Int64, Int64)

Bytes allocated and garbage collections.

Weigh a pure function. This function is heavily documented inside.

weighAction

Arguments

:: NFData a

=> (b -> IO a)

A function whose memory use we want to measure.

-> b

Argument to the function. Doesn't have to be forced.

-> IO (Int64, Int64, Int64, Int64)

Bytes allocated and garbage collections.

Weigh a pure function. This function is heavily documented inside.