~alcinnz/harfbuzz-pure

ref: 0ab0042c920132249d2e677fc1bfa918993b9416 harfbuzz-pure/bench/Main.hs -rw-r--r-- 2.9 KiB
0ab0042c — Adrian Cochrane Don't cache results of main function unless processed (neglected in previous commit). 7 months ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
{-# LANGUAGE TemplateHaskell #-}
module Main where
import Criterion.Main
import Data.Text.Glyphize
import Data.FileEmbed
import System.FilePath ((</>))
import qualified Data.Text.Foreign as Txt
import qualified Data.Text.Lazy as Txt

import Control.Parallel.Strategies (parMap, rdeepseq)
import Data.Word (Word8)

-- Benchmarking these as well...
import Foreign.Marshal.Array (peekArray)
import Foreign.ForeignPtr (ForeignPtr, mallocForeignPtrArray)
import System.IO.Unsafe (unsafePerformIO, unsafeDupablePerformIO, unsafeInterleaveIO)
import Data.Text.Glyphize.Array

shapeStr txt = shape font defaultBuffer { text = txt } []
  where font = createFont $ createFace $(
                    makeRelativeToProject ("assets" </> "Lora-Regular.ttf") >>=
                    embedFile) 0

dracula = $(makeRelativeToProject ("bench" </> "dracula.txt") >>= embedStringFile)

main = defaultMain [
    bgroup "Dracula" [
        bench "Week-Head" $ whnf shapeStr dracula,
        bench "Normal Form" $ nf shapeStr dracula,
        bench "Paragraphs" $ nf (map shapeStr) $ Txt.lines dracula,
        bench "Parallelised" $ nf (parMap rdeepseq shapeStr) $ Txt.lines dracula
    ],
    bgroup "building blocks" [
        bench "peekArray (NF)" $ nfIO $ Txt.useAsPtr (Txt.toStrict dracula) $
            \ptr l -> peekArray (fromEnum l) ptr,
        bench "peekArray" $ whnfIO $ Txt.useAsPtr (Txt.toStrict dracula) $
            \ptr l -> peekArray (fromEnum l) ptr,
        bench "alloc foreign ptr" $ whnfIO (mallocForeignPtrArray $
            fromEnum $ Txt.length dracula :: IO (ForeignPtr Word8)),
        bench "clone ptr" $ whnfIO $ Txt.useAsPtr (Txt.toStrict dracula) $
            \ptr l -> clonePtr ptr $ fromEnum l,
        bench "peek lazy" $ whnfIO (Txt.asForeignPtr (Txt.toStrict dracula) >>=
            \(ptr, l) -> return $ peekLazy ptr $ fromEnum l),
        bench "iterate lazy" $ whnfIO $ Txt.useAsPtr (Txt.toStrict dracula) $
            \ptr l -> iterateLazy ptr $ fromEnum l,
        bench "peek lazy (NF)" $ nfIO $ (Txt.asForeignPtr (Txt.toStrict dracula) >>=
            \(ptr, l) -> return $ peekLazy ptr $ fromEnum l),
        bench "iterate lazy (NF)" $ nfIO $ Txt.useAsPtr (Txt.toStrict dracula) $
            \ptr l -> iterateLazy ptr $ fromEnum l,
        -- These benchmarks give unconfident results, thought they'd be interesting...
        bench "unsafePerformIO" $ whnf unsafePerformIO $ return (),
        bench "unsafeDupablePerformIO" $ whnf unsafeDupablePerformIO $ return (),
        bench "unsafeInterleaveIO" $ whnfIO $ unsafeInterleaveIO $ return (),
        bench "accursedUnutterablePerformIO" $ whnf accursedUnutterablePerformIO $ return (),
        bench "peek kilo array" $ nfIO $ Txt.useAsPtr (Txt.toStrict $ Txt.take 1024 dracula) $
            \ptr l -> peekArray (fromEnum l) ptr,
        bench "lazy kilo array" $ nfIO (Txt.asForeignPtr (Txt.toStrict $ Txt.take 1024 dracula) >>=
                \(ptr, l) -> return $ peekLazy ptr $ fromEnum l)
    ]
  ]