1b8439d · streamly · git.iko.soy

git.iko.soy/streamly

change writeNUnsafe to use strict unboxed data

Now all benchmarks that use A.writeN/A.writeNUnsafe with concatMap perform as well as the custom flattenArray implementation.

commit1b8439d641f0b51eda92a80be1ab1a2f7fa9df59 authorHarendra Kumar <harendra.kumar@gmail.com> dateSun 25 Aug 2019, 10:57 (7 years ago) parent0ef35be

4 files changed+23−37

compare with master

unifiedsplit

design/inlining.md+12 src/Streamly/Benchmark/FileIO/Stream.hs+1 src/Streamly/FileSystem/Handle/Internal.hs+2−12 src/Streamly/Memory/Array/Types.hs+8−25

design/inlining.md+12

@@ -109,3 +109,15 @@ on `i` to get it specialized:

109109```

110110

111111`-flate-specialise` also helps in this case.

112+

113+## Stream and Fold State Data Structures

114+

115+Since state is an internal data structure threaded around in the loop, it is a

116+good practice to use strict unboxed fields for state data structures where

117+possible. In most cases it is not necessary, but in some cases it may affect

118+fusion and make a difference of 10x performance or more. For example, using

119+non-strict fields can increase the code size for internal join points and

120+functions created during transformations, which can affect the inlining of

121+these code blocks which in turn can affect stream fusion.

122+

123+See https://gitlab.haskell.org/ghc/ghc/issues/17075 .

src/Streamly/Benchmark/FileIO/Stream.hs+1

@@ -165,6 +165,7 @@ hinspect $ hasNoTypeClasses 'copyCodecUtf8

165165{-# INLINE chunksOf #-}

166166chunksOf :: Int -> Handle -> IO Int

167167chunksOf n inh =

168+ -- writeNUnsafe gives 2.5x boost here over writeN.

168169 S.length $ S.chunksOf n (AT.writeNUnsafe n) (FH.read inh)

169170

170171hinspect $ hasNoTypeClasses 'chunksOf

src/Streamly/FileSystem/Handle/Internal.hs+2−12

@@ -91,16 +91,6 @@ writeSArraysInChunksOf :: (MonadIO m, Storable a)

9191 => Int -> Handle -> SerialT m (Array a) -> m ()

9292writeSArraysInChunksOf n h xs = writeSArrays h $ AS.compact n xs

9393

94−-- XXX Using custom array chunking with A.arraysOf, writeS gives 2x faster

95−-- readStream/catStream benchmark compared to S.arraysOf based writeS as well

96−-- as compared to the fold IO version of cat benchmark i.e. readStream/cat.

97−-- However, if we use the most optimal A.writeNUnsafe fold then the fold

98−-- version of cat is also as fast. But with the most optimal version of

99−-- A.writeNUnsafe, fusion breaks. Once GHC fusion problem gets fixed we should

100−-- be able to use that.

101−--

102−-- Until then we are keeping the custom A.arraysOf code.

103−--

10494-- | @writeSInChunksOf chunkSize handle stream@ writes @stream@ to @handle@ in

10595-- chunks of @chunkSize@. A write is performed to the IO device as soon as we

10696-- collect the required input size.

@@ -108,8 +98,8 @@ writeSArraysInChunksOf n h xs = writeSArrays h $ AS.compact n xs

10898-- @since 0.7.0

10999{-# INLINE writeSInChunksOf #-}

110100writeSInChunksOf :: MonadIO m => Int -> Handle -> SerialT m Word8 -> m ()

111−-- writeSInChunksOf n h m = writeSArrays h $ S.arraysOf n m

112−writeSInChunksOf n h m = writeSArrays h $ AS.arraysOf n m

101+writeSInChunksOf n h m = writeSArrays h $ S.arraysOf n m

102+-- writeSInChunksOf n h m = writeSArrays h $ AS.arraysOf n m

113103

114104-- > write = 'writeInChunksOf' A.defaultChunkSize

115105--

src/Streamly/Memory/Array/Types.hs+8−25

@@ -520,6 +520,10 @@ writeN n = Fold step initial extract

520520 return $ Array start (end `plusPtr` sizeOf (undefined :: a)) bound

521521 extract = return -- liftIO . shrinkToFit

522522

523+data ArrayUnsafe a = ArrayUnsafe

524+ {-# UNPACK #-} !(ForeignPtr a) -- first address

525+ {-# UNPACK #-} !(Ptr a) -- first unused address

526+

523527-- | Like 'writeN' but does not check the array bounds when writing. The fold

524528-- driver must not call the step function more than 'n' times otherwise it will

525529-- corrupt the memory and crash. This function exists mainly because any

@@ -534,34 +538,13 @@ writeNUnsafe n = Fold step initial extract

534538

535539 where

536540

537− {-

538− -- XXX this implementation is good on all benchmarks except

539− -- readStream/catStream which uses a stream based writeS instead of a fold

540− -- based write. In the writeS case it does not fuse and therefore performs

541− -- 10x worse.

542541 initial = do

543542 (Array start end _) <- liftIO $ newArray (max n 0)

544− return (start, end)

545− -- XXX any if condition in the step causes fusion to fail with groupsOf

546− -- If we need to do bounds check we can use 'n' instead of threading around

547− -- bound pointer.

548− step (start, end) x = do

549− liftIO $ poke end x

550− return $ (start, (end `plusPtr` sizeOf (undefined :: a)))

551− extract (start, end) = return $ Array start end end -- liftIO . shrinkToFit

552− -}

553− -- This implementation fuses in all known cases as of now. Even though both

554− -- readStream/cat and readStream/catStream benchmarks perform 2x worse when

555− -- arraysOf uses this impl compared to their best seen performance.

556− -- readStream/cat is best with the above implementation and

557− -- readStream/catStream is best when using the custom arraysOf

558− -- implementation.

559− initial = do

560− liftIO $ newArray (max n 0)

561− step (Array start end bound) x = do

543+ return $ ArrayUnsafe start end

544+ step (ArrayUnsafe start end) x = do

562545 liftIO $ poke end x

563− return $ Array start (end `plusPtr` sizeOf (undefined :: a)) bound

564− extract = return -- liftIO . shrinkToFit

546+ return $ (ArrayUnsafe start (end `plusPtr` sizeOf (undefined :: a)))

547+ extract (ArrayUnsafe start end) = return $ Array start end end -- liftIO . shrinkToFit

565548

566549{-# INLINE_NORMAL fromStreamDN #-}

567550fromStreamDN :: forall m a. (MonadIO m, Storable a)