Estoy tratando de aprender a usar el módulo Control.Parallel
, pero creo que no lo entendí bien.Programación multinúcleo en Haskell - Control.Parallel
Estoy tratando de ejecutar el siguiente código (fibs.hs).
import Control.Parallel
fib :: Int -> Int
fib 0 = 0
fib 1 = 1
fib n = p `par` (q `pseq` (p + q))
where
p = fib (n-1)
q = fib (n-2)
main = print $ fib 30
Compilé esto con:
ghc -O2 --make -threaded fibs.hs
Y entonces consigo los siguientes resultados ejecución de este programa (salida de un script en Python que se ejecuta cada programa 100 veces y devuelve el promedio y la desviación estándar de la tiempo de ejecución):
./fibs +RTS -N1 -> avg= 0.060203 s, deviation = 0.004112 s
./fibs +RTS -N2 -> avg= 0.052335 s, deviation = 0.006713 s
./fibs +RTS -N3 -> avg= 0.052935 s, deviation = 0.006183 s
./fibs +RTS -N4 -> avg= 0.053976 s, deviation = 0.007106 s
./fibs +RTS -N5 -> avg= 0.055227 s, deviation = 0.008598 s
./fibs +RTS -N6 -> avg= 0.055703 s, deviation = 0.006537 s
./fibs +RTS -N7 -> avg= 0.058327 s, deviation = 0.007526 s
Mis preguntas son:
Lo que está ocurriendo exactamente cuando evalúo:
a `par` (b `pseq` (a + b)) ?
entiendo que un
par
b se supone dar a entender que el compilador sobre el cálculo de una en paralelo con b y volver b. DE ACUERDO. ¿Pero qué hacepseq
?¿Por qué veo un aumento de rendimiento tan pequeño? Estoy ejecutando esto en una máquina cuádruple Intel Core 2. Esperaría que correr con -N5 o -N6 no hiciera una diferencia real en el rendimiento o que el programa comenzara a funcionar muy mal. Pero ¿por qué no veo una mejora de -N2 a -N3 y por qué la mejora inicial es tan pequeña?
No Haskell automáticamente el balance de chispas para obtener el mejor rendimiento? – Chuck
Equilibra automáticamente los hilos. El tiempo de ejecución tiene colas de expresiones no evaluadas (chispas) que se convertirán en subprocesos a medida que disminuyen las cargas de trabajo. Depende de usted no crear demasiadas chispas (y así perder el tiempo llenando las colas de chispas) –