Haskell Paralelo (e entrada e saída de dados)

Transcrição

1 Haskell Paralelo (e entrada e saída de dados) Prof. Fabrício Olivetti de França Universidade Federal do ABC

2 Entrada e Saída de dados

3 Imprimindo na tela Nós já conhecemos o comando print, que imprime qualquer valor na tela. Um comando menos genérico é o putstrln.

4 GHCI Imprimindo na tela Prelude> :t putstrln putstrln :: String -> IO () Ele recebe uma String e retorna um IO ()?

5 Imprimindo na tela IO é o envelope da classe de entrada e saída de dados (Point, Just, ). () representa uma unit, ou uma tupla sem elementos. Vamos convencionar que IO é uma ação e IO () é uma ação que é executada e não retorna nada.

6 Imprimindo na tela Da mesma forma temos a função getline. main = do putstrln "Please enter your name:" name <- getline putstrln ("Hello, " ++ name ++ ", how are you?") Ela espera por uma ação do usuário e armazena em name.

7 GHCI Imprimindo na tela Prelude> :t getline getline :: IO String Diferente do que vimos até então, ela não recebe parâmetros de entrada, apenas retorna uma String envolvida em IO.

8 Ações Essas funções que recebem ou retornam IO são chamadas de ações pois queremos que sejam executadas no instante em que a chamamos. O retorno de um IO não pode ser previsto em tempo de compilação, não sabemos o que vai acontecer.

9 Ações Considere a sequência: x <- getline y <- getline e: x = 13 y = 15

10 Ações Na segunda sequência, não importa a ordem de operação, mas na primeira a ordem importa. O operador <- executa a ação naquele instante, garantindo a coerência do programa, e remove o envelope da ação.

11 Blocos "do" Toda vez que precisamos executar sequências de operações (de modo imperativo), utilizamos um bloco do: do nome <- getline putstrln nome

12 Blocos "do" O bloco do não pode terminar com uma operação <-, pois deve terminar com uma instrução pura. do nome <- getline putstrln nome

13 Purificando Não se esqueça de que, se formos utilizar os valores provenientes do envelope IO, temos que purificá-los! do linha <- getline let x = read linha :: Integer -- converte em int, se possível print (funcaopura x)

14 Lendo arquivos Imagine o seguinte arquivo de dados, exemplodata.txt:

15 Lendo arquivos Queremos ler seu conteúdo e transformar em uma lista de listas: [ [1.2, 3.5, 2.3], [4.1, 2.1, 3.4], ]

16 Lendo arquivos readfile :: FilePath -> IO String Lê o arquivo em FilePath e retorna ele como string (envolvido em um IO). file <- readfile "arquivo" file se torna uma String com o conteúdo do arquivo.

17 Lendo arquivos Vamos criar uma função parsefile que fará a conversão, a assinatura dela deve ser: parsefile :: String -> [Double]

18 Lendo arquivos Queremos que cada linha do arquivo seja uma lista de Doubles: parsefile :: String -> [Double] parsefile file = map parseline (lines file)

19 GHC Lendo arquivos A função parseline converte cada palavra da linha em um Double: parsefile :: String -> [Double] parsefile file = map parseline (lines file) where parseline l = map todouble (words l) todouble w = read w :: Double

20 Avaliação preguiçosa

21 Quero evitar a fadiga Vamos verificar como a avaliação preguiçosa funciona no Haskell. Para isso utilizaremos a função sprint no ghci que mostra o estado atual da variável.

22 GHCI Quero evitar a fadiga Prelude> :set -XMonomorphismRestriction Prelude> x = Prelude> :sprint x x = _

23 GHCI Quero evitar a fadiga Prelude> x = Prelude> :sprint x x = _ Prelude> x 3 Prelude> :sprint x x = 3

24 Quero evitar a fadiga O valor de x é computado apenas quando requisitamos seu valor!

25 Quero evitar a fadiga Prelude> x = Prelude> y = x * 3 Prelude> :sprint x x = _ Prelude> :sprint y y = _

26 Quero evitar a fadiga Prelude> x = Prelude> y = x * 3 Prelude> :sprint x x = _ Prelude> :sprint y y = _ Prelude> y 6 Prelude> :sprint x x = 2

27 Eu quero agora! A função seq recebe dois parâmetros, avalia o primeiro e retorna o segundo.

28 Eu quero agora! Prelude> x = Prelude> y = 2 * 3 Prelude> :sprint x x = _ Prelude> :sprint y y = _ Prelude> seq x y 6 Prelude> :sprint x x = 2

29 Quero evitar a fadiga Prelude> let l = map (+1) [1..10] :: [Int] Prelude> :sprint l l = _ Prelude> seq l () Prelude> :sprint l l = _ : _ Prelude> length l Prelude> :sprint l l = [_,_,_,_,_,_,_,_,_,_] Prelude> sum l Prelude> :sprint l l = [2,3,4,5,6,7,8,9,10,11]

30 Paralelismo: Anotação Simples

31 O óbvio Considere a implementaçõa ingênua de fibonacci: fib 0 = 0 fib 1 = 1 fib 2 = 1 fib n = (fib n - 1) + (fib n - 2) Um ponto óbvio para paralelizar: enquanto uma thread trabalha no (n-1) outra no (n-2).

32 GHC Anotando paralelismo import Control.Parallel fib :: Integer -> Integer fib 0 = 0 fib 1 = 1 fib n = n1 `par` (n1 + n2) where n1 = fib (n - 1) n2 = fib (n - 2) main = do print (fib 36)

33 Anotando paralelismo A função par indica para criar um spark para o primeiro argumento e executar o segundo argumento. par x (x+y) cria uma thread para calcular x e calcula x+y em paralelo.

34 Spark Um spark é uma possibilidade de se tornar uma thread. Se o programa julgar necessário transforma em thread.

35 Anotando paralelismo Compile com: ghc -o nome nome.hs -threaded -eventlog -rtsopts Execute com:./nome +RTS -N1 -s -ls -M2g

36 Anotando paralelismo -threaded: compile com suporte a multithreading -eventlog: permite criar um log do uso de threads -rtsopts: embute opções no seu programa +RTS: flag para indicar opções embutidas -Nx: quantas threads usar -s: estatísticas de execução -ls: gera log para o threadscope -M2g: limita o uso de memória em 2GB

37 Fibonacci Com 1 thread: Total time 2.591s ( 2.620s elapsed) Com 2 threads: Total time 2.749s ( 1.388s elapsed) O valor entre parênteses é o tempo real.

38 GHC Anotando paralelismo import Control.Parallel fib :: Integer -> Integer fib 0 = 0 fib 1 = 1 fib n = n1 `par` (n2 + n1) where n1 = fib (n - 1) n2 = fib (n - 2) main = do print (fib 36)

39 Fibonacci Com 1 thread: Total time 2.518s ( 2.541s elapsed) Com 2 threads: Total time 4.475s ( 2.841s elapsed) O que houve??

40 Fibonacci No ghc o operador + avalia o operando da direita primeiro. Enquanto uma thread avaliava n1 a principal avaliava também n1.

41 GHC Anotando paralelismo import Control.Parallel fib :: Integer -> Integer fib 0 = 0 fib 1 = 1 fib n = n1 `par` n2 `pseq` (n2 + n1) where n1 = fib (n - 1) n2 = fib (n - 2) main = do print (fib 36)

42 Fibonacci pseq funciona como seq, porém aguarda que as threads terminem antes de continuar.

43 Fibonacci Com 1 thread: Total time 2.845s ( 2.872s elapsed) Com 2 threads: Total time 2.995s ( 1.523s elapsed) Com o sincronismo, perdemos um tantinho de tempo, mas temos o paralelismo garantido.

44 Threadscope

45 Avaliando o paralelismo Para avaliarmos se nossa estratégia de paralelismo está funcionando, temos a ferramenta threadscope: $ cabal install threadscope

46 Fibonacci $ threadscope FibParSeq.eventlog

47 Fibonacci $ threadscope FibParSeq.eventlog # de threads Atividade thread 1 Atividade thread 2

48 Fibonacci $ threadscope FibParSeq.eventlog

49 Vida de um spark

50 duds e fizzles dud: já foi avaliado antes de virar uma thread fizzle: já foi avaliado por outra thread

51 Vida de um spark Sinais de problemas: - Poucos sparks, pode ser paralelizado ainda mais - Muitos sparks, paralelizando demais - Muitos duds e fizzles, estratégia não otimizada.

52 Threadscope Em breve veremos como usar o threadscope para melhorar nosso paralelismo.

53 Estratégias

54 Estratégias de Paralelismo Forma genérica de anotar os pontos a serem paralelizados. Permite aplicar paralelismo em tipos compostos.

55 Estratégias de Paralelismo map (+ 2) lista como paralelizar usando `par`?

56 Estratégias de Paralelismo print (fib 35, fib 36) como paralelizar usando `par`?

57 Estratégias de Paralelismo (fib 35) `par` fib 36 `pseq` (fib 35, fib 36) feio!

58 Funções paralelas type Strategy a = a -> Eval a parpair :: Strategy (a,b) parpair (a,b) = do a' <- rpar a b' <- rpar b return (a',b')

59 Funções paralelas Tipo Strategy de um tipo qualquer a é uma função que recebe a e retorna a envelopado no tipo Eval. O tipo Eval é um tipo que define o que e como deve ser avaliado.

60 Funções paralelas rpar é uma função que retorna uma ação envelopada em Eval (lembram de IO?). Nesse caso precisamos utilizar a função return que envolve a tupla envelopada em Eval.

61 Funções paralelas runeval (parpair (fib 35, fib 36)) runeval executa a ação e retorna o valor fora do envelope Eval.

62 Funções paralelas using :: a -> Strategy a -> a x `using` s = runeval (s x)

63 Funções paralelas (fib 35, fib 36) `using` parpair Bonito! :)

64 parlist, rseq, rdeepseq parlist - paraleliza o processamento de uma lista, requer uma outra estratégia a ser aplicada em cada elemento. rseq - força a avaliação de uma expressão dentro daquele spark. rdeepseq - força avaliação da expressão até o fim.

65 Exemplo

66 GHC Média mean :: [[Double]] -> [Double] mean l = map mean' l `using` parlist rseq where mean' l' = (sum l') / (fromintegral $ length l') Cada elemento de l cria um spark que será avaliado via rseq.

67 threadscope Total time 1.381s ( 1.255s elapsed) Por que um core fez o dobro do trabalho?

68 threadscope Começamos a criar sparks muito rapidamente! Não deu tempo de aproveitá-los!

69 threadscope Com o pool cheio, não deu tempo de enviar para o outro core! Então ficaram no core mestre.

70 GHC Média mean :: [[Double]] -> [Double] mean l = map mean' l where mean' l' = (sum l') / (fromintegral $ length l') Vamos tirar a estratégia...

71 GHC Média meanpar :: [[Double]] -> [Double] meanpar l = concat lists where lists = map mean chunks `using` parlist rseq chunks = chunksof 1000 l Agora dividimos a lista em pedaços de 1000 elementos e paralelizamos nesses pedaços.

72 threadscope Total time 1.289s ( 1.215s elapsed) Não tem mais overflow! Mas...

73 threadscope A aplicação da função mean foi preguiçosa, os sparks faziam apenas a promessa e retornavam!

74 GHC Média meanpar :: [[Double]] -> [Double] meanpar l = concat lists where lists = map mean chunks `using` parlist rdeepseq chunks = chunksof 1000 l Vamos usar a estratégia rdeepseq.

75 threadscope Total time 1.303s ( 0.749s elapsed) :)

76 threadscope E sem overflow!!