Massive performance issue between interpreted and compiled code. (Interpreted is faster!)
I was unable to reduce this to a minimal example, but it's not hard to recreate. I've observed this all the way back to GHC 8.8, and perhaps earlier. Both Mac and Linux. (However, I think this is a regression, i.e., older GHCs--from back about 3 years ago--didn't have this issue. Though I don't have any specific info on versions where it was not an issue.)
The numbers reported below are with GHC 9.8.1.
To replicate, you'll need to have SBV installed. (https://hackage.haskell.org/package/sbv)
For this program:
import Data.SBV
import Data.SBV.Tools.CodeGen
import Documentation.SBV.Examples.Crypto.SHA
main :: IO ()
main = compileToC (Just "testOutput_delete") "sha512" $ do
cgOverwriteFiles True
let algorithm = sha512P
hInBytes <- cgInputArr 64 "hIn"
blockBytes <- cgInputArr 128 "block"
let hIn = chunkBy 8 fromBytes hInBytes
block = chunkBy 8 fromBytes blockBytes
result = hashBlock algorithm hIn (Block block)
cgOutputArr "hash" $ concatMap toBytes result
I'm seeing:
$ time ghc -e main a
ghc -e main a 62.22s user 9.47s system 85% cpu 1:24.18 total
That's kind of slow, but not too bad. But when I compile:
$ ghc a.hs
Loaded package environment from /Users/leventerkok/.ghc/x86_64-darwin-9.8.1/environments/default
[1 of 2] Compiling Main ( a.hs, a.o )
[2 of 2] Linking a
time ./ald: warning: ignoring duplicate libraries: '-lm'
$ time ./a
./a 820.27s user 15.34s system 99% cpu 14:04.02 total
That is significantly slower; in fact 10 times slower than the interpreted code. Compiling with optimizations (-O2) doesn't change the run-time.
I'd appreciate any insights into what might be going wrong.