úÎ!\ÐZ -      !"#$%&'()*+,SafeDb7gperfan unwrapped Word64perf•tick_ measures the number of cycles it takes to read the rdtsc chip twice: the difference is then how long it took to read the clock the second time..Below are indicative measurements using tick_:onetick <- tick_ticks' <- replicateM 10 tick_%manyticks <- replicateM 1000000 tick_8let average = L.fold ((/) <$> L.sum <*> L.genericLength)2let avticks = average (fromIntegral <$> manyticks) ÿ one tick_: 78 cycles next 10: [20,18,20,20,20,20,18,16,20,20] average over 1m: 20.08 cycles 99.999% perc: 7,986 99.9% perc: 50.97 99th perc: 24.99 40th perc: 18.37 [min, 10th, 20th, .. 90th, max]: 12.00 16.60 17.39 17.88 18.37 18.86 19.46 20.11 20.75 23.04 5.447e5ÿ The distribution of tick_ measurements is highly skewed, with the maximum being around 50k cycles, which is of the order of a GC. The important point on the distribution is around the 30th to 50th percentile, where you get a clean measure, usually free of GC activity and cache miss-firesperf¼Warm up the register, to avoid a high first measurement. Without a warmup, one or more larger values can occur at the start of a measurement spree, and often are in the zone of an L2 miss.,t <- tick_ -- first measure can be very high_ <- warmup 100/t <- tick_ -- should be around 20 (3k for ghci)perfqtick where the arguments are lazy, so measurement may include evaluation of thunks that may constitute f and/or aperfZ`tick f a` strictly evaluates f and a, then deeply evaluates f a, returning a (Cycle, f a)_ <- warmup 100(cs, _) <- tick f aÿNote that feeding the same computation through tick twice may kick off sharing (aka memoization aka let floating). Given the importance of sharing to GHC optimisations this is the intended behaviour. If you want to turn this off then see -fno-full-laziness (and maybe -fno-cse).perf'measures and deeply evaluates an `IO a`(cs, _) <- tickIO (pure (f a))perfn measurements of a tick3returns a list of Cycles and the last evaluated f aÿÏGHC is very good at finding ways to share computation, and anything measuring a computation multiple times is a prime candidate for aggresive ghc treatment. Internally, ticks uses a noinline pragma and a noinline version of to help reduce the chances of memoization, but this is an inexact science in the hands of he author, at least, so interpret with caution. The use of noinline interposes an extra function call, which can highly skew very fast computations. let n = 1000(cs, fa) <- ticks n f aÏBaseline speed can be highly sensitive to the nature of the function trimmings. Polymorphic functions can tend to be slightly slower, and functions with lambda expressions can experience dramatic slowdowns. ¾fMono :: Int -> Int fMono x = foldl' (+) 0 [1 .. x] fPoly :: (Enum b, Num b, Additive b) => b -> b fPoly x = foldl' (+) 0 [1 .. x] fLambda :: Int -> Int fLambda = \x -> foldl' (+) 0 [1 .. x]perfn measuremenst of a tickIO>returns an IO tuple; list of Cycles and the last evaluated f a"(cs, fa) <- ticksIO n (pure $ f a) perfWmake a series of measurements on a list of a's to be applied to f, for a tick function.UTends to be fragile to sharing issues, but very useful to determine computation Order ns ticks n f [1,10,100,1000]-perfaverage of an Integral foldable cAv <- average <$> ticks n f a perf WHNF versions perf WHNF version perf WHNF version perf WHNF versionperf WHNF version  SafeDEXbIò perfA Measure consists of a monadic effect prior to measuring, a monadic effect to finalise the measurement, and the value measured•For example, the measure specified below will return 1 every time measurement is requested, thus forming the base of a simple counter for loopy code.(let count = Measure 0 (pure ()) (pure 1)perf Lightweight  class.perfMeasure a single effect."r <- runMeasure count (pure "joy")r (1,"joy")perf/Measure once, but run an effect multiple times.)r <- runMeasureN 1000 count (pure "joys")r (1,"joys")perf9cost of a measurement in terms of the Measure's own unitsr <- cost countr1perfa measure using .* from System.CPUTime (unit is picoseconds)7r <- runMeasure cputime (pure $ foldl' (+) 0 [0..1000]) (34000000,500500)perfa measure using / (unit is 0 which prints as seconds)8r <- runMeasure realtime (pure $ foldl' (+) 0 [0..1000]) (0.000046s,500500)perfa  used to count iterationsr <- runMeasure count (pure ())r(1,())perfa  using the 1# CPU register (units are in cycles)&r <- runMeasureN 1000 cycles (pure ()) :(120540,()) -- ghci-level (18673,()) -- compiled with -O2None@ADMbYX"perf(The obligatory transformer over Identity#perf„PerfT is polymorphic in the type of measurement being performed. The monad stores and produces a Map of labelled measurement values$perfALift a monadic computation to a PerfT m, providing a label and a .%perfVLift a monadic computation to a PerfT m, and carry out the computation multiple times.&perf;Consume the PerfT layer and return a (result, measurement).:set -XOverloadedStringsM(cs, result) <- runPerfT $ perf "sum" cycles (pure $ foldl' (+) 0 [0..10000]) $(50005000,fromList [("sum",562028)])'perf…Consume the PerfT layer and return the original monadic result. Fingers crossed, PerfT structure should be completely compiled away.Hresult <- evalPerfT $ perf "sum" cycles (pure $ foldl' (+) 0 [0..10000]) 50005000(perf1Consume a PerfT layer and return the measurement.Dcs <- execPerfT $ perf "sum" cycles (pure $ foldl' (+) 0 [0..10000]) fromList [("sum",562028)]% "#$%&'(#"$%&'(2      !"#$%&'()*+,-./01234536789:;!perf-0.7.0-GBOrdQ2MhETH2OvuHZR6iQ Perf.Cycle Perf.MeasurePerfCycletick_warmuptick'tick tickNoinlinetickIOticksticksIOnstickWHNF tickWHNF' tickWHNFIO ticksWHNF ticksWHNFIOMeasuremeasurepresteppoststepAdditiveaddzero runMeasure runMeasureNcostcputimerealtimecountcycles$fAdditiveNominalDiffTime$fAdditiveWord64$fAdditiveInteger $fAdditiveIntPerfTperfperfNrunPerfT evalPerfT execPerfT$fMonadIOPerfT$fFunctorPerfT$fApplicativePerfT $fMonadPerfTaveragebaseSystem.CPUTime getCPUTime time-1.10-BMxqFVrI4CvBhqQD8eT7HnData.Time.Clock.POSIXgetCurrentTime(Data.Time.Clock.Internal.NominalDiffTimeNominalDiffTime$rdtsc-1.3.0.1-10yGRb5eJnjCZl4VfKJvYpSystem.CPUTime.Rdtscrdtsc