Use latest fusion-plugin to strictly verify fusion and add reporting of Core size regressions

.github/workflows/regression-check.yml

@@ -141,7 +141,8 @@ jobs:
     - name: Run benchmarks for "master" branch
       run: |
         # --cabal-build-options "-j1"
-        ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw
+        ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --core-sizes
+        ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw --keep-going || true
         # XXX Print dependencies of streamly-core and streamly for comparison
         # in case there is a regression due to version changes.
         # ghc-pkg --package-db=./dist-newstyle/packagedb/ghc-9.10.3/ field streamly depends
@@ -159,6 +160,7 @@ jobs:
     - name: Run benchmarks and append
       run: |
         # --cabal-build-options "-j1"
+        ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --core-sizes --append
         ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw --append
 
     # -----------------------------------------------------------------
@@ -167,6 +169,7 @@ jobs:
 
     - name: List all benchmarks
       run: |
+        ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --core-sizes --no-measure
         ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --no-measure
 
     - name: Compare benchmarks

benchmark/Streamly/Benchmark/CrossModule/FileSystem.hs

@@ -26,9 +26,16 @@ module CrossModule.FileSystem (benchmarks) where
 
 import Data.Functor.Identity (runIdentity)
 import Data.Word (Word8)
+import Foreign.Ptr (Ptr)
+import GHC.Classes (IP)
 import GHC.Magic (inline)
 import GHC.Magic (noinline)
+import GHC.Stack (CallStack, SrcLoc)
+import Streamly.Internal.Data.Array (Array)
+import Streamly.Internal.Data.MutArray (MutArray)
+import Streamly.Internal.Data.MutByteArray (PinnedState)
 import System.IO (Handle)
+import Unsafe.Coerce (UnsafeEquality)
 
 import qualified Streamly.Data.Fold as Fold
 import qualified Streamly.FileSystem.Handle as FH
@@ -38,6 +45,7 @@ import qualified Streamly.Internal.Data.Parser as PR
 import qualified Streamly.Internal.Data.Stream as IP
 import qualified Streamly.Data.Stream as S
 
+import Fusion.Plugin.Types
 import Test.Tasty.Bench hiding (env)
 import Prelude hiding (last, length)
 import Streamly.Benchmark.Common
@@ -58,6 +66,13 @@ import Test.Inspection
 -------------------------------------------------------------------------------
 
 -- | Get the last byte from a file bytestream.
+{-# ANN readLast (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN readLast (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Maybe,''Word8,''Ptr
+    ,''PinnedState]) #-}
+{-# ANN readLast (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE readLast #-}
 readLast :: Handle -> IO (Maybe Word8)
 readLast = S.fold Fold.latest . S.unfold FH.reader
 
@@ -69,6 +84,12 @@ inspect $ 'readLast `hasNoType` ''MutArray.ArrayUnsafe  -- FH.read/A.read
 #endif
 
 -- | Count the number of bytes in a file.
+{-# ANN readCountBytes (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN readCountBytes (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Ptr,''PinnedState]) #-}
+{-# ANN readCountBytes (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE readCountBytes #-}
 readCountBytes :: Handle -> IO Int
 readCountBytes = S.fold Fold.length . S.unfold FH.reader
 
@@ -80,6 +101,12 @@ inspect $ 'readCountBytes `hasNoType` ''MutArray.ArrayUnsafe  -- FH.read/A.read
 #endif
 
 -- | Sum the bytes in a file.
+{-# ANN readSumBytes (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN readSumBytes (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Word8,''Ptr,''PinnedState]) #-}
+{-# ANN readSumBytes (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE readSumBytes #-}
 readSumBytes :: Handle -> IO Word8
 readSumBytes = S.fold Fold.sum . S.unfold FH.reader
 
@@ -94,10 +121,21 @@ inspect $ 'readSumBytes `hasNoType` ''MutArray.ArrayUnsafe  -- FH.read/A.read
 -- reduce after grouping in chunks
 -------------------------------------------------------------------------------
 
+{-# ANN chunksOfSum (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN chunksOfSum (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Ptr,''PinnedState]) #-}
+{-# ANN chunksOfSum (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE chunksOfSum #-}
 chunksOfSum :: Int -> Handle -> IO Int
 chunksOfSum n inh =
     S.fold Fold.length $ IP.groupsOf n FL.sum (S.unfold FH.reader inh)
 
+-- NOTE: these three rely on the caller applying 'inline'/'noinline' (GHC.Magic)
+-- at each call site to get either a fully inlined or a real out-of-line call
+-- from the same definition, so they are intentionally left without a NOINLINE
+-- pragma/ANN -- adding NOINLINE here would remove the unfolding that 'inline'
+-- needs and defeat the small-n variant.
 foldMany1ChunksOfSum :: Int -> Handle -> IO Int
 foldMany1ChunksOfSum n inh =
     S.fold Fold.length
@@ -143,6 +181,13 @@ chunksOf n inh =
 -------------------------------------------------------------------------------
 
 -- | Get the last byte from a file bytestream.
+{-# ANN toChunksLast (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN toChunksLast (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Maybe,''Word8,''Ptr
+    ,''PinnedState]) #-}
+{-# ANN toChunksLast (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE toChunksLast #-}
 toChunksLast :: Handle -> IO (Maybe Word8)
 toChunksLast inh = do
     let s = FH.readChunks inh
@@ -157,6 +202,12 @@ inspect $ 'toChunksLast `hasNoType` ''Step
 #endif
 
 -- | Count the number of bytes in a file.
+{-# ANN toChunksSumLengths (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN toChunksSumLengths (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Ptr,''PinnedState]) #-}
+{-# ANN toChunksSumLengths (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE toChunksSumLengths #-}
 toChunksSumLengths :: Handle -> IO Int
 toChunksSumLengths inh =
     let s = FH.readChunks inh
@@ -168,6 +219,12 @@ inspect $ 'toChunksSumLengths `hasNoType` ''Step
 #endif
 
 -- | Sum the bytes in a file.
+{-# ANN toChunksCountBytes (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''Array]) #-}
+{-# ANN toChunksCountBytes (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''Ptr,''PinnedState]) #-}
+{-# ANN toChunksCountBytes (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE toChunksCountBytes #-}
 toChunksCountBytes :: Handle -> IO Word8
 toChunksCountBytes inh = do
     let foldlArr' f z = runIdentity . IP.foldl' f z . A.read
@@ -184,6 +241,13 @@ inspect $ 'toChunksCountBytes `hasNoType` ''Step
 -------------------------------------------------------------------------------
 
 -- | Count the number of lines in a file.
+{-# ANN toChunksSplitOnSuffix (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''MutArray,''Array]) #-}
+{-# ANN toChunksSplitOnSuffix (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''MutArray,''Ptr
+    ,''PinnedState]) #-}
+{-# ANN toChunksSplitOnSuffix (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE toChunksSplitOnSuffix #-}
 toChunksSplitOnSuffix :: Handle -> IO Int
 toChunksSplitOnSuffix =
     IP.fold Fold.length
@@ -196,6 +260,13 @@ inspect $ 'toChunksSplitOnSuffix `hasNoType` ''Step
 #endif
 
 -- | Count the number of words in a file.
+{-# ANN toChunksSplitOn (PermitPatternMatches
+    [''[],''Int,''UnsafeEquality,''IO,''MutArray,''Array]) #-}
+{-# ANN toChunksSplitOn (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''MutArray,''Ptr
+    ,''PinnedState]) #-}
+{-# ANN toChunksSplitOn (PermitTypeClasses [''IP]) #-}
+{-# NOINLINE toChunksSplitOn #-}
 toChunksSplitOn :: Handle -> IO Int
 toChunksSplitOn =
     IP.fold Fold.length
@@ -212,6 +283,12 @@ inspect $ 'toChunksSplitOn `hasNoType` ''Step
 -------------------------------------------------------------------------------
 
 -- | Lines and unlines
+{-# ANN copyChunksSplitInterposeSuffix (PermitPatternMatches
+    [''IO,''[],''Int,''UnsafeEquality,''Array,''MutArray]) #-}
+{-# ANN copyChunksSplitInterposeSuffix (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''(),''MutArray,''Ptr,''Bool
+    ,''PinnedState]) #-}
+{-# ANN copyChunksSplitInterposeSuffix (PermitTypeClasses [''IP]) #-}
 {-# NOINLINE copyChunksSplitInterposeSuffix #-}
 copyChunksSplitInterposeSuffix :: Handle -> Handle -> IO ()
 copyChunksSplitInterposeSuffix inh outh =
@@ -225,6 +302,12 @@ inspect $ 'copyChunksSplitInterposeSuffix `hasNoType` ''Step
 #endif
 
 -- | Words and unwords
+{-# ANN copyChunksSplitInterpose (PermitPatternMatches
+    [''IO,''[],''Int,''UnsafeEquality,''MutArray,''Array,''(,),''Maybe]) #-}
+{-# ANN copyChunksSplitInterpose (PermitConstructions
+    [''Int,''SrcLoc,''CallStack,''[],''Array,''(,),''MutArray,''Maybe,''()
+    ,''Ptr,''Bool,''PinnedState]) #-}
+{-# ANN copyChunksSplitInterpose (PermitTypeClasses [''IP]) #-}
 {-# NOINLINE copyChunksSplitInterpose #-}
 copyChunksSplitInterpose :: Handle -> Handle -> IO ()
 copyChunksSplitInterpose inh outh =