Integrando Haskell à Plataforma .NET

1. Integrando Haskell à Plataforma .NET Dissertação de Mestrado Monique Louise de Barros Monteiro Orientador: André Luís de Medeiros Santos

2. Motivação Linguagens Funcionais • Altamente produtivas • Base formal Linguagens OO • Largamente utilizadas • Rico conjunto de APIs • Plataformas de desenvolvimento / execução

3. Agenda • Plataforma .NET • Integrando Linguagens Funcionais a .NET • O Compilador Haskell.NET • Análise de Desempenho • Conclusões e Trabalhos Futuros

4. Plataforma .NET

5. Web Services Web Forms Windows Forms ASP .NET ADO .NET – Dados e XML Biblioteca de Classes Básicas Common Language Runtime Visão Geral “Plataforma multilinguagem de desenvolvimento e execução que permite que diferentes linguagens e bibliotecas trabalhem juntas, de forma transparente, fácil de construir, gerenciar e integrar com outros sistemas de rede.”

6. CLR • Common Language Runtime • Ambiente de execução da Plataforma .NET • Algumas características: • Compilação just-in-time • Suporte nativo a delegates e Generics • Garbage collector geracional • Implementação da CLI

7. CLI • Common Language Infrastructure • Padrão submetido à ECMA International • Especificação para código executável e para o ambiente onde o código será executado • Componentes: • Metadados • Virtual Execution System • Common Type System • Common Language Specification

8. JVM x CLR JVM ● ○ ○ ○ CLR ○ ● ● ● Foco em linguagens OO Interoperabilidade entre linguagens Suporte a tail calls Suporte a ponteiros para função

9. Integrando Linguagens Funcionais a .NET

10. Integração – Alternativas • Bridge • Componente intermediador de chamadas entre dois ambientes de execução • Marshalling / Unmarshalling • Ex.: Hugs.NET • Compilação • Maiores possibilidades de interoperabilidade • Compartilhamento do ambiente de execução

11. Trabalhos Relacionados • Linguagens não estritas • Hugs .NET • Mondrian • Haskell → ILX • Haskell.NET • Linguagens estritas • F# • Nemerle • Scheme • SML .NET • Implementações para a JVM • Haskell, SML, Scheme

12. O Compilador Haskell.NET

13. Arquitetura • Extensão do Glasgow Haskell Compiler (GHC) • Uso do front end e das otimizações aplicadas pelo GHC • Tradução de STG (Shared Term Graph Language) para CIL (Common Intermediate Language, ou “IL”),assembly da CLR • Linguagem funcional simplificada • Ambiente de Execução (“runtime system”) • Geração de código verificável

14. GHC – Arquitetura

15. Estratégia de Compilação • Uniões Discriminadas • Closures • Ambiente de execução • Versão 1 • Versão 2 • Aplicação de Funções • Controle da Pilha de Chamadas

16. List é uma união discriminada. • Nil e Cons são construtores. Uniões Discriminadas data List t = Nil | Cons t (List t) • Construtores – Alternativas de Representação: • Uma classe por construtor (Ex.: F#, Mondrian) • Compartilhamento de classes • Casamento de padrão – Alternativas de Representação: • Uso de instrução switch • Uso de instruções para identificação da classe (Ex.: F#, Mondrian) • Alternativa adotada: compartilhamento de classes + switch

17. Uniões Discriminadas • Casamento de padrão: switch (scrutinee.tag) { case 1: ... case 2: Pack 2<Closure,Closure> k = (Pack 2<Closure,Closure>) scrutinee; Closure arg_1 = k.arg1; Closure arg_2 = k.arg2; ... } • Aplicação de construtores: new Pack(1); new Pack_2<Closure, Closure>(2, x, xs);

18. g é uma closure que encapsula um código que espera receber um argumento e acessa um argumento recebido por f. • x é uma variável livre em g. • f é uma closure sem variáveis livres. Closures • Objetos alocados dinamicamente que encapsulam um código a ser executado e um ambiente que pode ser acessado pelo código. • Em linguagens lazy, argumentos e variáveis livres são closures. f :: Int -> u -> (Int -> Int) f x y = let g w = x + w in g

19. Closures • Alternativas de Representação: • Uma classe por closure • Grande número de classes • Ex.: F#, Mondrian, implementações para JVM • Classes genéricas para vários tipos de closure • Uso de ponteiro para método – náo verificável • Uso de delegates • Alternativa adotada: classes genéricas com uso de delegates

20. Implementação da CLI Delegate • Objeto que encapsula: • um ponteiro para um método a ser invocado • uma referência para o objeto alvo no qual o método deverá ser chamado (null para método estáticos) • Instância de uma classe que herda de MulticastDelegate

21. Ambiente de Execução 1

22. Ambiente de Execução 2

23. Aplicação de Funções • Aplicação de funções desconhecidas estaticamente ou aplicações parciais • Modelo push/enter (Ex.: Mondrian) • Código da função chamada a aplica ao número correto de argumentos • Fast entry point • Slow entry point • Modelo eval/apply (Ex.: F#, Bigloo for Scheme) • Função chamadora aplica a função chamada ao número correto de argumentos • Alternativa adotada: modelo push/enter • Maior facilidade de implementação

24. Pilha de Chamadas • Pilha de chamadas tende a um crescimento muito rápido • Possíveis soluções: • Tail-calls (prefixo suportado pela IL - .tail) • Trampolim • Instrução jmp (não verificável) while (f != null) f = f.Invoke();

25. Exemplo • Função map

26. Alocação e inicialização de closures Chamada ao slow entry point Chamada ao fast entry point Exemplo • 1 public static IClosure map(IClosure f, IClosure l) { • 2 Pack scrutinee = (Pack) l.Enter(); • 3 switch (scrutinee.tag) { • 4 case 1: return new Pack(1); • 5 case 2: • Pack 2<Closure,Closure>k = • (Pack 2<Closure,Closure>) scrutinee; • 7 Closure arg 1 = k.arg1; Closure arg 2 = k.arg2; • 9 Updatable_2_FV<Closure,Closure>fx_closure = • new Updatable_2_FV<Closure,IClosure>( • new UpdCloFunction<Closure,IClosure>(fx)); • 11 fx closure.fv1 = arg 1; fx closure.fv2 = f; • 12 Updatable_2_FV<Closure,Closure>fxs closure = • new Updatable_2_FV<Closure,Closure>( • new UpdCloFunction<Closure,IClosure>((fxs)); • 14 fxs closure.fv1 = f; fxs closure.fv2 = arg 2; • 15 return new Pack 2<IClosure,IClosure>(2,fx closure,fxs closure); • 16 } • 17 } • 19 public static Closure fx(Updatable_2_FV<Closure,Closure> closure){ • 20 RuntimeSystem.Push(closure.fv1); • 21 return <tail> closure.fv2.Enter(); • 22 } • 23 public static Closure fxs(Updatable_2_FV<Closure,Closure> closure){ • 24 return <tail>map(closure.fv1, closure.fv2); • 25 }

27. Análise de Desempenho e Otimizações

28. Metodologia • Subconjunto do grupo Imaginário do benchmark Nofib • Execuções consecutivas (6) dos programas • Tempo de execução em segundos (comando time) • Média aritmética • Valores de comparação sumarizados por média geométrica

29. Entradas • Dificuldade para escolha de entradas • Nofib sugere saídas • Dados desatualizados • Escolha baseada em tempos de execução razoáveis (testes críticos)

30. Uso de Delegates

31. Principais Otimizações • Remoção do updateframe • Compartilhamento de booleanos • Relacionadas a tail-calls

32. Remoção do Update Frame • Remoção da pilha de atualizações • Uso do próprio stack frame da CLR • 1ª. versão do ambiente de execução

33. Booleanos – Compartilhamento

34. Tail-calls • Remoção de tail-calls apenas do ambiente de execução

35. Tail-calls • Impacto da presença de tail-calls no código compilado

36. Tail-calls • Substituição por instruções de desvio

37. Haskell.NET X GHC Nativo

38. Conclusões e Trabalhos Futuros

39. Contribuições • Desenvolvimento de uma implementação de Haskell para .NET • Avaliação de desempenho sob vários aspectos • Ambiente de estudo e prototipação de técnicas alternativas • Base para a interoperabilidade com outras linguagens

40. Conclusões • Parte do prelúdio implementada • Subconjunto básico implementado em C# • Desenvolvimento e avaliação de dois ambientes de execução • Segunda versão: maior portabilidade e manutenibilidade • Desempenho da mesma ordem de magnitude que o GHC nativo para a maioria dos programas • Gerenciamento de memória ainda é um fator crítico • Análises de desempenho fornecem uma visão realista da CLR

41. Trabalhos Futuros • Suporte a mais Bibliotecas • Análises de Desempenho • Outras representações para closures • Avaliação do modelo eval/apply • Extensões à máquina virtual (via Rotor) • Integração com Phoenix • Suporte a interoperabilidade • Implementação da FFI (Foreign Function Interface) • Extensões OO à inguagem • Geração de wrappers

42. Integrando Haskell à Plataforma .NET Dissertação de Mestrado Monique Louise de Barros Monteiro Orientador: André Luís de Medeiros Santos