{-# OPTIONS -fglasgow-exts #-}
-- ^ unboxed strings
--
-- Benchmark tool.
-- Compare a function against equivalent code from other libraries for
-- space and time.
--
import BenchUtils
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as C
import qualified Data.ByteString.Lazy as L
import Data.List
import Data.Char
import Data.Word
import Data.Int
import System.IO
import Control.Monad
import Text.Printf
--
-- temporarily broken
--
main :: IO ()
main = do
-- initialise
force (fps,fps') >> force (lps,lps')
printf "# Size of test data: %dk\n" ((floor $ (fromIntegral (B.length fps)) / 1024) :: Int)
printf "#Byte\t Lazy\n"
run 5 ((fps,fps'),(lps,lps')) tests
------------------------------------------------------------------------
tests =
[ ("++",
[F ({-# SCC "append" #-} app (uncurry B.append))
,F ({-# SCC "lazy append" #-} app (uncurry L.append))
])
, ("concat",
[F ({-# SCC "concat" #-} app B.concat)
,F ({-# SCC "lazy concat" #-} app L.concat)
])
, ("length",
[F ({-# SCC "length" #-} app B.length)
,F ({-# SCC "lazy length" #-} app L.length)
])
-- , ("pack", [F (\_ -> {-# SCC "pack" #-} B.pack [1..1000000])
-- ])
, ("unpack", [F ({-# SCC "unpack" #-} app B.unpack)
])
{-
, ("compare",
[F ({-# SCC "compare" #-} app2 compare) :: needs type annotation
,F ({-# SCC "lazy compare" #-} app2 compare) ])
-}
, ("index",
[F ({-# SCC "index" #-} app$ flip B.index 260000)
,F ({-# SCC "lazy index" #-} app$ flip L.index 260000)
])
, ("map",
[F ({-# SCC "map" #-} app$ B.map (+1))
,F ({-# SCC "lazy map" #-} app$ L.map (+1))
])
, ("filter",
[F ({-# SCC "filter" #-} app$ B.filter (/=101))
,F ({-# SCC "lazy filter" #-} app$ L.filter (/=101))
])
-- , ("map'",
-- [F ({-# SCC "map" #-} app$ B.map (*2))
-- ,F ({-# SCC "map" #-} app$ B.map' (*1))
-- ])
-- , ("filter'",
-- [F ({-# SCC "filter" #-} app$ B.filter (/=121))
-- ,F ({-# SCC "filter'" #-} app$ B.filter' (/=121))
-- ])
-- , ("filterNotByte",
-- [F ({-# SCC "filterNotByte" #-}app$ B.filterNotByte 101)
-- ,F ({-# SCC "lazy filterNotByte" #-}app$ L.filterNotByte 101)
-- ])
-- , ("filterByte",
-- [F ({-# SCC "filterByte" #-} app$ B.filterByte 103)
--- ,F ({-# SCC "lazy filterByte" #-} app$ L.filterByte 103)
-- ])
-- , ("findIndexOrEnd",
-- [F ({-# SCC "findIndexOrEnd" #-} app$ B.findIndexOrEnd (==126))
-- ])
, ("findIndex",
[F ({-# SCC "findIndex" #-} app$ B.findIndex (==126))
,F ({-# SCC "lazy findIndex" #-} app$ L.findIndex (==126))
])
, ("find",
[F ({-# SCC "find" #-} app$ B.find (==126))
,F ({-# SCC "lazy find" #-} app$ L.find (==126))
])
, ("foldl",
[F ({-# SCC "fold" #-} app$ B.foldl (\a w -> a+1::Int) 0)
,F ({-# SCC "lazy fold" #-} app$ L.foldl (\a w -> a+1::Int) 0)
])
, ("foldl'",
[F ({-# SCC "fold" #-} app$ B.foldl' (\a w -> a+1::Int) 0)
,F ({-# SCC "lazy fold" #-} app$ L.foldl' (\a w -> a+1::Int) 0)
])
, ("take",
[F ({-# SCC "take" #-} app $ B.take 100000)
,F ({-# SCC "lazy take" #-} app $ L.take 100000)
])
, ("drop",
[F ({-# SCC "drop" #-} app $ B.drop 100000)
,F ({-# SCC "lazy drop" #-} app $ L.drop 100000)
])
, ("takeWhile",
[F ({-# SCC "takeWhile" #-} app $ B.takeWhile (/=122))
,F ({-# SCC "lazy takeWhile" #-} app $ L.takeWhile (==122))
])
, ("dropWhile",
[F ({-# SCC "dropWhile" #-} app $ B.dropWhile (/=122))
,F ({-# SCC "lazy dropWhile" #-} app $ L.dropWhile (/=122))
])
, ("span",
[F ({-# SCC "span" #-} app $ B.span (/=122))
,F ({-# SCC "lazy span" #-} app $ L.span (/=122))
])
, ("break",
[F ({-# SCC "break" #-} app $ B.break (==122))
,F ({-# SCC "lazy break" #-} app $ L.break (==122))
])
, ("split",
[F ({-# SCC "split" #-} app $ B.split 0x0a)
,F ({-# SCC "lazy split" #-} app $ L.split 0x0a)
])
-- , ("breakByte",
-- [F ({-# SCC "breakChar" #-} app $ B.breakByte 122)
-- ,F ({-# SCC "lazy breakChar" #-} app $ L.breakByte 122)
-- ])
-- , ("spanByte",
-- [F ({-# SCC "spanChar" #-} app $ B.spanByte 122)
-- ,F ({-# SCC "lazy spanChar" #-} app $ L.spanByte 122)
-- ])
, ("reverse",
[F ({-# SCC "reverse" #-} app B.reverse)
,F ({-# SCC "lazy reverse" #-} app L.reverse)
])
, ("cons",
[F ({-# SCC "cons" #-} app $ B.cons 120)
,F ({-# SCC "lazy cons" #-} app $ L.cons 120)
])
, ("snoc",
[F ({-# SCC "snoc" #-} app $ flip B.snoc 120)
,F ({-# SCC "lazy snoc" #-} app $ flip L.snoc 120)
])
, ("empty",
[F ({-# SCC "empty" #-} const B.empty)
,F ({-# SCC "lazy empty" #-} const L.empty)
])
, ("head",
[F ({-# SCC "head" #-} app B.head)
,F ({-# SCC "lazy head" #-} app L.head)
])
, ("tail",
[F ({-# SCC "tail" #-} app B.tail)
,F ({-# SCC "lazy tail" #-} app L.tail)
])
, ("last",
[F ({-# SCC "last" #-} app B.last)
,F ({-# SCC "lazy last" #-} app L.last)
])
, ("init",
[F ({-# SCC "init" #-} app B.init)
,F ({-# SCC "lazy init" #-} app L.init)
])
, ("count",
[F ({-# SCC "count" #-} app $ B.count 10)
,F ({-# SCC "lazy count" #-} app $ L.count 10)
])
, ("isPrefixOf",
[F ({-# SCC "isPrefixOf" #-} app $ B.isPrefixOf
(C.pack "The Project Gutenberg eBook"))
,F ({-# SCC "lazy isPrefixOf" #-} app $ L.isPrefixOf
(L.pack [84,104,101,32,80,114,111,106,101
,99,116,32,71,117,116,101,110,98
,101,114,103,32,101,66,111,111,107]))
])
, ("join",
[F ({-# SCC "join" #-} app $ B.join (B.pack [1,2,3]))
,F ({-# SCC "lazy join" #-} app $ L.join (L.pack [1,2,3]))
])
-- , ("joinWithByte",
-- [F ({-# SCC "joinWithByte" #-} app $ uncurry (B.joinWithByte 32))
-- ,F ({-# SCC "lazy joinWithByte" #-} app $ uncurry (L.joinWithByte 32))
-- ])
, ("any",
[F ({-# SCC "any" #-} app $ B.any (==120))
,F ({-# SCC "lazy any" #-} app $ L.any (==120))
])
, ("all",
[F ({-# SCC "all" #-} app $ B.all (==120))
,F ({-# SCC "lazy all" #-} app $ L.all (==120))
])
, ("maximum",
[F ({-# SCC "maximum" #-} app B.maximum)
,F ({-# SCC "lazy maximum" #-} app L.maximum)
])
, ("minimum",
[F ({-# SCC "minimum" #-} app B.minimum)
,F ({-# SCC "lazy minimum" #-} app L.minimum)
])
, ("elem",
[F ({-# SCC "elem" #-} app $ B.elem 122)
,F ({-# SCC "lazy elem" #-} app $ L.elem 122)
])
, ("notElem",
[F ({-# SCC "notElem" #-} app $ B.notElem 122)
,F ({-# SCC "lazy notElem" #-} app $ L.notElem 122)
])
, ("elemIndex",
[F ({-# SCC "elemIndex" #-} app $ B.elemIndex 122)
,F ({-# SCC "lazy elemIndex" #-} app $ L.elemIndex 122)
])
, ("findIndices",
[F ({-# SCC "findIndicies" #-} app $ B.findIndices (==122))
,F ({-# SCC "lazy findIndices" #-} app $ L.findIndices (==122))
])
, ("elemIndices",
[F ({-# SCC "elemIndicies" #-} app $ B.elemIndices 122)
,F ({-# SCC "lazy elemIndices" #-} app $ L.elemIndices 122)
])
, ("splitAt",
[F ({-# SCC "splitAt" #-} app $ B.splitAt 10000)
,F ({-# SCC "lazy splitAt" #-} app $ L.splitAt 10000)
])
, ("splitWith",
[F ({-# SCC "splitWith" #-} app $ B.splitWith (==122))
,F ({-# SCC "lazy splitWith" #-} app $ L.splitWith (==122))
])
, ("replicate",
[F ({-# SCC "replicate" #-} const $ B.replicate 10000000 120)
,F ({-# SCC "lazy replicate" #-} const $ L.replicate 10000000 120)
])
, ("group",
[F ({-# SCC "group" #-} app B.group)
,F ({-# SCC "lazy group" #-} app L.group)
])
, ("groupBy",
[F ({-# SCC "groupBy" #-} app $ B.groupBy (==))
,F ({-# SCC "lazy groupBy" #-} app $ L.groupBy (==))
])
, ("inits",
[F ({-# SCC "inits" #-} app B.inits)
])
, ("tails",
[F ({-# SCC "tails" #-} app B.tails)
])
-- , ("transpose",[F ({-# SCC "transpose" #-}B.transpose [fps,fps'])])
------------------------------------------------------------------------
--
-- Char8 or ByteString only
, ("intersperse",
[F ({-# SCC "intersperse" #-} app $ B.intersperse 120 )
])
, ("sort",
[F ({-# SCC "sort" #-} app B.sort)
])
-- , ("lineIndices",
-- [F ({-# SCC "lineIndicies" #-} app C.lineIndices)
-- ])
, ("elemIndexEnd",
[F ({-# SCC "elemIndexEnd" #-} app $ B.elemIndexEnd 122)
])
-- , ("breakSpace",
-- [F ({-# SCC "breakSpace" #-} app C.breakSpace)
-- ])
-- , ("dropSpace",
-- [F ({-# SCC "dropSpace" #-} app C.dropSpace)
-- ])
-- , ("dropSpaceEnd",
-- [F ({-# SCC "dropSpaceEnd" #-} app C.dropSpaceEnd)
-- ])
-- , ("zip",[F ({-# SCC "zip" #-} B.zip fps fps)])
, ("zipWith'",
[F ({-# SCC "zipWith'" #-} app (uncurry (B.zipWith (+))))
])
, ("isSubstringOf",
[F ({-# SCC "isSubstringOf" #-} app $ B.isSubstringOf (C.pack "email news"))
])
, ("isSuffixOf",
[F ({-# SCC "isSuffixOf" #-} app $ B.isSuffixOf (C.pack "new eBooks"))
])
, ("spanEnd",
[F ({-# SCC "spanEnd" #-} app $ B.spanEnd (/=122))
])
, ("lines",
[F ({-# SCC "lines" #-} app C.lines)
])
, ("unlines",
[F ({-# SCC "unlines" #-} app C.unlines)
])
, ("words",
[F ({-# SCC "words" #-} app C.words)
])
, ("unwords",
[F ({-# SCC "unwords" #-} app C.unwords)
])
]
------------------------------------------------------------------------
fst1 f ((x,_),_) = f x
snd1 f (_,(x,_)) = f x
fst2list f ((x,y),_) = f [x,y]
snd2list f (_,(x,y)) = f [x,y]
fst2 f (x,_) = f x
snd2 f (_,y) = f y
type Input = ((B.ByteString,B.ByteString),(L.ByteString,L.ByteString))
class (Eq a, Ord a) => Ap a where app :: (a -> b) -> Input -> b
instance Ap B.ByteString where app = fst1
instance Ap L.ByteString where app = snd1
instance Ap [B.ByteString] where app = fst2list
instance Ap [L.ByteString] where app = snd2list
instance Ap (B.ByteString, B.ByteString) where app = fst2
instance Ap (L.ByteString, L.ByteString) where app = snd2
app2 :: Ap (a, b) => (a -> b -> c) -> Input -> c
app2 = app . uncurry
|
