fine-grained: 1000 repetitions for fast ops

Author: sjakobi

benchmarks/FineGrained.hs

@@ -66,11 +66,11 @@ bFromList =
     setupBytes s gen = genNBytes s bytesLength gen
     b s = bench (show s) . whnf (HM.fromList . map (,()))
 
--- 100 lookups each, so we get more precise timings
+-- 1000 lookups each, so we get more precise timings
 bLookup :: Benchmark
 bLookup =
   bgroup
-    "lookup"
+    "lookup (1000x)"
     [ bgroup "presentKey" bLookupPresentKey,
       bgroup "absentKey" bLookupAbsentKey
     ]
@@ -85,7 +85,7 @@ bLookupPresentKey =
     b s =
       bench (show s)
         . whnf (\(m, ks) -> foldl' (\() k -> HM.lookup k m `seq` ()) () ks)
-    toKs = take 100 . Data.List.cycle . HM.keys
+    toKs = take 1000 . Data.List.cycle . HM.keys
     setupBytes size gen = do
       m <- genBytesMap size gen
       return (m, toKs m)
@@ -104,20 +104,20 @@ bLookupAbsentKey =
         . whnf (\(m, ks) -> foldl' (\() k -> HM.lookup k m `seq` ()) () ks)
     setupBytes size gen = do
       m <- genBytesMap size gen
-      ks0 <- genNBytes 200 bytesLength gen
-      let ks1 = take 100 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
+      ks0 <- genNBytes 2000 bytesLength gen
+      let ks1 = take 1000 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
       return (m, ks1)
     setupInts size gen = do
       m <- genIntMap size gen
-      ks0 <- genInts 200 gen
-      let ks1 = take 100 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
+      ks0 <- genInts 2000 gen
+      let ks1 = take 1000 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
       return (m, ks1)
 
--- 100 insertions each, so we get more precise timings
+-- 1000 insertions each, so we get more precise timings
 bInsert :: Benchmark
 bInsert =
   bgroup
-    "insert"
+    "insert (1000x)"
     [ bgroup
         "presentKey"
         [ bgroup "sameValue" bInsertPresentKeySameValue,
@@ -136,7 +136,7 @@ bInsertPresentKeySameValue =
     b s =
       bench (show s)
         . whnf (\(m, kvs) -> foldl' (\() (k, v) -> HM.insert k v m `seq` ()) () kvs)
-    toKVs = take 100 . Data.List.cycle . HM.toList
+    toKVs = take 1000 . Data.List.cycle . HM.toList
     setupBytes size gen = do
       m <- genBytesMap size gen
       return (m, toKVs m)
@@ -154,7 +154,7 @@ bInsertPresentKeyDifferentValue =
     b s =
       bench (show s)
         . whnf (\(m, kvs) -> foldl' (\() (k, v) -> HM.insert k v m `seq` ()) () kvs)
-    toKVs = take 100 . Data.List.cycle . map (second (+ 1)) . HM.toList
+    toKVs = take 1000 . Data.List.cycle . map (second (+ 1)) . HM.toList
     setupBytes size gen = do
       m <- genBytesMap size gen
       return (m, toKVs m)
@@ -173,20 +173,20 @@ bInsertAbsentKey =
         . whnf (\(m, kvs) -> foldl' (\() (k, v) -> HM.insert k v m `seq` ()) () kvs)
     setupBytes size gen = do
       m <- genBytesMap size gen
-      ks <- genNBytes 200 bytesLength gen
-      let kvs = take 100 $ Data.List.cycle $ map (,1) $ filter (not . flip HM.member m) ks
+      ks <- genNBytes 2000 bytesLength gen
+      let kvs = take 1000 $ Data.List.cycle $ map (,1) $ filter (not . flip HM.member m) ks
       return (m, kvs)
     setupInts size gen = do
       m <- genIntMap size gen
-      ks <- genInts 200 gen
-      let kvs = take 100 $ Data.List.cycle $ map (,1) $ filter (not . flip HM.member m) ks
+      ks <- genInts 2000 gen
+      let kvs = take 1000 $ Data.List.cycle $ map (,1) $ filter (not . flip HM.member m) ks
       return (m, kvs)
 
--- 100 deletions each, so we get more precise timings
+-- 1000 deletions each, so we get more precise timings
 bDelete :: Benchmark
 bDelete =
   bgroup
-    "delete"
+    "delete (1000x)"
     [ bgroup "presentKey" bDeletePresentKey,
       bgroup "absentKey" bDeleteAbsentKey
     ]
@@ -201,7 +201,7 @@ bDeletePresentKey =
     b s =
       bench (show s)
         . whnf (\(m, ks) -> foldl' (\() k -> HM.delete k m `seq` ()) () ks)
-    toKs = take 100 . Data.List.cycle . HM.keys
+    toKs = take 1000 . Data.List.cycle . HM.keys
     setupBytes size gen = do
       m <- genBytesMap size gen
       return (m, toKs m)
@@ -220,13 +220,13 @@ bDeleteAbsentKey =
         . whnf (\(m, ks) -> foldl' (\() k -> HM.delete k m `seq` ()) () ks)
     setupBytes size gen = do
       m <- genBytesMap size gen
-      ks0 <- genNBytes 200 bytesLength gen
-      let ks1 = take 100 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
+      ks0 <- genNBytes 2000 bytesLength gen
+      let ks1 = take 1000 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
       return (m, ks1)
     setupInts size gen = do
       m <- genIntMap size gen
-      ks0 <- genInts 200 gen
-      let ks1 = take 100 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
+      ks0 <- genInts 2000 gen
+      let ks1 = take 1000 $ Data.List.cycle $ filter (not . flip HM.member m) ks0
       return (m, ks1)
 
 -- TODO: For the "overlap" and "equal" cases, it would be interesting to