1module Throughput.BinaryBuilderDeclarative (
2  serialize
3) where
4
5import Data.Monoid
6import Data.Word
7import qualified Data.ByteString.Lazy as L
8
9import Data.Binary.Builder
10
11import Control.Monad
12
13import Throughput.Utils
14
15serialize :: Int -> Int -> Endian -> Int -> Maybe L.ByteString
16serialize wordSize chunkSize end iters = fmap toLazyByteString $
17  case (wordSize, chunkSize, end) of
18    (1, 1,_)        -> return $ writeByteN1 iters
19
20    (2, 1,  Big)    -> return $ writeWord16N1Big iters
21    (2, 1,  Little) -> return $ writeWord16N1Little iters
22    (2, 1,  Host)   -> return $ writeWord16N1Host iters
23
24    (4, 1,  Big)    -> return $ writeWord32N1Big iters
25    (4, 1,  Little) -> return $ writeWord32N1Little iters
26    (4, 1,  Host)   -> return $ writeWord32N1Host iters
27
28    (8, 1,  Host)   -> return $ writeWord64N1Host iters
29    (8, 1,  Big)    -> return $ writeWord64N1Big iters
30    (8, 1,  Little) -> return $ writeWord64N1Little iters
31
32    _               -> mzero
33
34------------------------------------------------------------------------
35-- Word8
36------------------------------------------------------------------------
37
38word8List :: Int -> [Word8]
39word8List n = take n $ cycle $ [0..]
40
41------------------------------------------------------------------------
42
43writeByteN1  = mconcat . map singleton . word8List
44
45
46------------------------------------------------------------------------
47-- Word16
48------------------------------------------------------------------------
49
50word16List :: Int -> [Word16]
51word16List n = take n $ cycle $ [0..]
52
53------------------------------------------------------------------------
54-- Big endian, word16 writes
55
56writeWord16N1Big  = mconcat . map putWord16be . word16List
57
58
59------------------------------------------------------------------------
60-- Little endian, word16 writes
61
62writeWord16N1Little  = mconcat . map putWord16le . word16List
63
64
65------------------------------------------------------------------------
66-- Host endian, unaligned, word16 writes
67
68writeWord16N1Host  = mconcat . map putWord16host . word16List
69
70
71------------------------------------------------------------------------
72-- Word32
73------------------------------------------------------------------------
74
75word32List :: Int -> [Word32]
76word32List n = [0..fromIntegral (n-1)]
77
78------------------------------------------------------------------------
79-- Big endian, word16 writes
80
81writeWord32N1Big  = mconcat . map putWord32be . word32List
82
83
84------------------------------------------------------------------------
85-- Little endian, word32 writes
86
87writeWord32N1Little  = mconcat . map putWord32le . word32List
88
89
90------------------------------------------------------------------------
91-- Host endian, unaligned, word32 writes
92
93writeWord32N1Host  = mconcat . map putWord32host . word32List
94
95
96------------------------------------------------------------------------
97-- Word64
98------------------------------------------------------------------------
99
100word64List :: Int -> [Word64]
101word64List n = [0..fromIntegral (n-1)]
102
103------------------------------------------------------------------------
104-- Big endian, word16 writes
105
106writeWord64N1Big  = mconcat . map putWord64be . word64List
107
108
109------------------------------------------------------------------------
110-- Little endian, word64 writes
111
112writeWord64N1Little  = mconcat . map putWord64le . word64List
113
114------------------------------------------------------------------------
115-- Host endian, unaligned, word64 writes
116
117writeWord64N1Host  = mconcat . map putWord64host . word64List
118
119