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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
-- Benchmark the cost of creating various types of map.
{-# LANGUAGE CPP, FlexibleContexts, ScopedTypeVariables #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
import Criterion.Main
import Data.ByteString (ByteString, pack)
import Data.Hashable (Hashable)
import System.Random.MWC
import qualified Data.HashMap.Lazy as H
import qualified Data.IntMap as I
import qualified Data.Map as M
import qualified Data.Vector as V
import qualified Data.Vector.Algorithms.Intro as I
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Unboxed as U
#if !MIN_VERSION_bytestring(0,10,0)
import Control.DeepSeq (NFData (..))
#endif
type V = U.Vector Int
type B = V.Vector ByteString
numbers :: IO (V, V, V)
numbers = do
gen <- createSystemRandom
random <- uniformVector gen 40000
let sorted = G.modify I.sort random
revsorted = G.reverse sorted
return (random, sorted, revsorted)
strings :: IO (B, B, B)
strings = do
gen <- createSystemRandom
random <- V.replicateM 10000 $
(pack . U.toList) `fmap` (uniformVector gen =<< uniformR (1,16) gen)
let sorted = G.modify I.sort random
revsorted = G.reverse sorted
return (random, sorted, revsorted)
main :: IO ()
main = defaultMain [
env numbers $ \ ~(random,sorted,revsorted) ->
bgroup "Int" [
bgroup "IntMap" [
bench "sorted" $ whnf intmap sorted
, bench "random" $ whnf intmap random
, bench "revsorted" $ whnf intmap revsorted
]
, bgroup "Map" [
bench "sorted" $ whnf mmap sorted
, bench "random" $ whnf mmap random
, bench "revsorted" $ whnf mmap revsorted
]
, bgroup "HashMap" [
bench "sorted" $ whnf hashmap sorted
, bench "random" $ whnf hashmap random
, bench "revsorted" $ whnf hashmap revsorted
]
]
, env strings $ \ ~(random,sorted,revsorted) ->
bgroup "ByteString" [
bgroup "Map" [
bench "sorted" $ whnf mmap sorted
, bench "random" $ whnf mmap random
, bench "revsorted" $ whnf mmap revsorted
]
, bgroup "HashMap" [
bench "sorted" $ whnf hashmap sorted
, bench "random" $ whnf hashmap random
, bench "revsorted" $ whnf hashmap revsorted
]
]
]
hashmap :: (G.Vector v k, Hashable k, Eq k) => v k -> H.HashMap k Int
hashmap xs = G.foldl' (\m k -> H.insert k value m) H.empty xs
intmap :: G.Vector v Int => v Int -> I.IntMap Int
intmap xs = G.foldl' (\m k -> I.insert k value m) I.empty xs
mmap :: (G.Vector v k, Ord k) => v k -> M.Map k Int
mmap xs = G.foldl' (\m k -> M.insert k value m) M.empty xs
value :: Int
value = 31337
#if !MIN_VERSION_bytestring(0,10,0)
instance NFData ByteString where
rnf bs = bs `seq` ()
#endif
|
