Ответ 1

Если ваша цель - запустить этот запуск так быстро, как ваш компилятор на С++, тогда вы хотел бы использовать структуру данных, с которой компилятор может иметь свой путь.

module Main where

import qualified Data.Vector as V

b :: Int -> Int
b x = x + 5
c x = b x + 1
d x = b x - 1

a x = c x + d x

main = do
    putStrLn "Starting..."
    putStrLn $ show $ V.foldl' (+) 0 $ V.map a $ V.enumFromTo 1 100000000
    putStrLn "Done."

GHC способен полностью исключить цикл и просто вставляет константу в результирующая сборка. На моем компьютере это теперь имеет время выполнения < 0,002 с, когда используя те же самые флаги оптимизации, которые вы изначально указали.

В качестве продолжения, основанного на комментариях @Yuras, ядро, созданное векторное решение и решение для плавного потока функционально идентичны.

Vector

main_$s$wfoldlM'_loop [Occ=LoopBreaker]
  :: Int# -> Int# -> Int#

main_$s$wfoldlM'_loop =
  \ (sc_s2hW :: Int#) (sc1_s2hX :: Int#) ->
    case <=# sc1_s2hX 100000000 of _ {
      False -> sc_s2hW;
      True ->
        main_$s$wfoldlM'_loop
          (+#
             sc_s2hW
             (+#
                (+# (+# sc1_s2hX 5) 1)
                (-# (+# sc1_s2hX 5) 1)))
          (+# sc1_s2hX 1)
    }

Поток-слитый

$wloop_foldl [Occ=LoopBreaker]
  :: Int# -> Int# -> Int#

$wloop_foldl =
  \ (ww_s1Rm :: Int#) (ww1_s1Rs :: Int#) ->
    case ># ww1_s1Rs 100000000 of _ {
      False ->
        $wloop_foldl
          (+#
             ww_s1Rm
             (+#
                (+# (+# ww1_s1Rs 5) 1)
                (-# (+# ww1_s1Rs 5) 1)))
          (+# ww1_s1Rs 1);
      True -> ww_s1Rm
    }

Единственное реальное различие - выбор операции сравнения для условия прекращения. Обе версии сводятся к жестким хвостовым рекурсивным циклам который может быть легко оптимизирован LLVM.

Ответ 2

ghc не списывает списки (избегая успеха любой ценой?)

Вот версия, которая использует пакет stream-fusion:

module Main where

import Prelude hiding (map, foldl)
import Data.List.Stream
import Data.Stream (enumFromToInt, unstream)
import Text.Printf
import Control.Exception
import System.CPUTime

b :: Int -> Int
b x = x + 5
c x = b x + 1
d x = b x - 1

a x = c x + d x

main = do
    putStrLn "Starting..."
    putStrLn $ show $ foldl (+) 0 $ map (\z -> a z) $ unstream $ enumFromToInt 1 100000000 
    putStrLn "Done."

У меня нет llvm для сравнения с вашими результатами, но он в 10 раз быстрее вашей версии (скомпилирован без llvm).

Я думаю, что векторное слияние должно выполняться еще быстрее.

Ответ 3

Как отмечали другие, вы не сравниваете эквивалентные алгоритмы. Как указал Юрас GHC не списывает списки. Ваша версия Haskell фактически выделит весь этот список, это будет сделано лениво по одной ячейке за раз, но это будет сделано. Ниже приведена версия, которая алгоритмически ближе к вашей версии C. В моей системе он запускается в то же время, что и версия C.

{-# LANGUAGE BangPatterns #-}
module Main where

import Text.Printf
import Control.Exception
import System.CPUTime
import Data.List

a,b,c :: Int -> Int
b x = x + 5
c x = b x + 1
d x = b x - 1

a !x = c x + d x

-- Don't allocate a list, iterate and increment as the C version does.
applyTo !acc !n
    | n > 100000000 = acc
    | otherwise = applyTo (acc + a n) (n + 1)

main = do
    putStrLn "Starting..."
    print $ applyTo 0 1
    putStrLn "Done."

Сравнивая его с time:

    ghc -O3 bench.hs -fllvm -fforce-recomp -o bench-hs && time ./bench-hs
[1 of 1] Compiling Main             ( bench.hs, bench.o )
Linking bench-hs ...
Starting...
10000001100000000
Done.
./bench-hs  0.00s user 0.00s system 0% cpu 0.003 total

По сравнению с C:

clang++ -O3 bench.cpp -o bench && time ./bench                                   
Starting...
10000001100000000
Done.
./bench  0.00s user 0.00s system 0% cpu 0.004 total