integrando haskell à plataforma .net
DESCRIPTION
Integrando Haskell à Plataforma .NET. Dissertação de Mestrado Monique Louise de Barros Monteiro Orientador: André Luís de Medeiros Santos. Motivação. Linguagens Funcionais Altamente produtivas Base formal Linguagens OO Largamente utilizadas Rico conjunto de APIs - PowerPoint PPT PresentationTRANSCRIPT
Integrando Haskell à Integrando Haskell à Plataforma .NETPlataforma .NET
Dissertação de MestradoDissertação de MestradoMonique Louise de Barros MonteiroMonique Louise de Barros Monteiro
Orientador: Orientador: André Luís de Medeiros SantosAndré Luís de Medeiros Santos
Integrando Haskell à Plataforma .NET
MotivaçãoMotivação
Linguagens FuncionaisLinguagens Funcionais• Altamente produtivasAltamente produtivas• Base formalBase formal
Linguagens OOLinguagens OO• Largamente utilizadasLargamente utilizadas• Rico conjunto de APIsRico conjunto de APIs• Plataformas de desenvolvimento / execuçãoPlataformas de desenvolvimento / execução
Integrando Haskell à Plataforma .NET
AgendaAgenda
Plataforma .NETPlataforma .NET Integrando Linguagens Funcionais a .NETIntegrando Linguagens Funcionais a .NET O Compilador Haskell.NETO Compilador Haskell.NET Análise de DesempenhoAnálise de Desempenho Conclusões e Trabalhos FuturosConclusões e Trabalhos Futuros
Plataforma .NETPlataforma .NET
Integrando Haskell à Plataforma .NET
Visão GeralVisão Geral
ASP .NET
Common Language Runtime
Web Services Web Forms
Biblioteca de Classes Básicas
ADO .NET – Dados e XML
Windows Forms
““Plataforma multilinguagem de Plataforma multilinguagem de desenvolvimento e execução que permite desenvolvimento e execução que permite que diferentes linguagens e bibliotecas que diferentes linguagens e bibliotecas
trabalhem juntas, de forma transparente, trabalhem juntas, de forma transparente, fácil de construir, gerenciar e integrar com fácil de construir, gerenciar e integrar com
outros sistemas de rede.”outros sistemas de rede.”
Integrando Haskell à Plataforma .NET
CLRCLR
• Common Language RuntimeCommon Language Runtime
• Ambiente de execução da Plataforma .NETAmbiente de execução da Plataforma .NET
• Algumas características:Algumas características:– Compilação Compilação just-in-timejust-in-time– Suporte nativo a delegates e GenericsSuporte nativo a delegates e Generics– Garbage collector Garbage collector geracionalgeracional
• Implementação da CLIImplementação da CLI
Integrando Haskell à Plataforma .NET
CLICLI
• Common Language InfrastructureCommon Language Infrastructure
• Padrão submetido à ECMA InternationalPadrão submetido à ECMA International
• Especificação para código executável e para Especificação para código executável e para o ambiente onde o código será executadoo ambiente onde o código será executado
• Componentes:Componentes:– MetadadosMetadados– Virtual Execution SystemVirtual Execution System– Common Type SystemCommon Type System– Common Language SpecificationCommon Language Specification
Integrando Haskell à Plataforma .NET
JVM x CLRJVM x CLR
Foco em linguagens OOFoco em linguagens OO
Interoperabilidade entre Interoperabilidade entre linguagenslinguagens
Suporte a Suporte a tail callstail calls
Suporte a ponteiros para funçãoSuporte a ponteiros para função
JVMJVM
●●○○○○○○
CLRCLR
○○●●●●●●
Integrando Integrando Linguagens Linguagens
Funcionais a .NETFuncionais a .NET
Integrando Haskell à Plataforma .NET
Integração – AlternativasIntegração – Alternativas
• BridgeBridge– Componente intermediador de chamadas entre Componente intermediador de chamadas entre
dois ambientes de execuçãodois ambientes de execução– Marshalling / UnmarshallingMarshalling / Unmarshalling– Ex.: Hugs.NETEx.: Hugs.NET
• CompilaçãoCompilação– Maiores possibilidades de interoperabilidadeMaiores possibilidades de interoperabilidade– Compartilhamento do ambiente de execuçãoCompartilhamento do ambiente de execução
Integrando Haskell à Plataforma .NET
Trabalhos RelacionadosTrabalhos Relacionados• Linguagens não estritasLinguagens não estritas
– Hugs .NETHugs .NET– MondrianMondrian– Haskell Haskell → → ILXILX– Haskell.NETHaskell.NET
• Linguagens estritasLinguagens estritas– F#F#– NemerleNemerle– SchemeScheme– SML .NETSML .NET
• Implementações para a JVMImplementações para a JVM– Haskell, SML, SchemeHaskell, SML, Scheme
O Compilador O Compilador Haskell.NETHaskell.NET
Integrando Haskell à Plataforma .NET
ArquiteturaArquitetura
• Extensão do Glasgow Haskell Compiler (GHC)Extensão do Glasgow Haskell Compiler (GHC)– Uso do Uso do front end front end e das otimizações aplicadas pelo e das otimizações aplicadas pelo
GHCGHC
• Tradução de STG (Shared Term Graph Tradução de STG (Shared Term Graph Language) para CIL (Common Intermediate Language) para CIL (Common Intermediate Language, ou “IL”),Language, ou “IL”), assemblyassembly da CLR da CLR– Linguagem funcional simplificadaLinguagem funcional simplificada
• Ambiente de Execução (“Ambiente de Execução (“runtime systemruntime system”)”)
• Geração de código verificávelGeração de código verificável
Integrando Haskell à Plataforma .NET
GHC – Arquitetura GHC – Arquitetura
Integrando Haskell à Plataforma .NET
Estratégia de CompilaçãoEstratégia de Compilação
• Uniões DiscriminadasUniões Discriminadas
• ClosuresClosures
• Ambiente de execuçãoAmbiente de execução– Versão 1Versão 1– Versão 2Versão 2
• Aplicação de FunçõesAplicação de Funções
• Controle da Pilha de ChamadasControle da Pilha de Chamadas
Integrando Haskell à Plataforma .NET
• Construtores – Alternativas de Representação:Construtores – Alternativas de Representação:– Uma classe por construtor (Ex.: F#, Mondrian)Uma classe por construtor (Ex.: F#, Mondrian)– Compartilhamento de classes Compartilhamento de classes
• Casamento de padrão – Alternativas de Representação:Casamento de padrão – Alternativas de Representação:– Uso de instrução Uso de instrução switchswitch– Uso de instruções para identificação da classe (Ex.: F#, Uso de instruções para identificação da classe (Ex.: F#,
Mondrian)Mondrian)
• Alternativa adotada: compartilhamento de classes + Alternativa adotada: compartilhamento de classes + switchswitch
Uniões DiscriminadasUniões Discriminadas
data List t = Nil | Cons t (List t)
•List é uma união discriminada.
•Nil e Cons são construtores.
Integrando Haskell à Plataforma .NET
• Casamento de padrão:Casamento de padrão:
Uniões DiscriminadasUniões Discriminadas
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; ...}
new Pack(1);
new Pack_2<Closure, Closure>(2, x, xs);
• Aplicação de construtores:Aplicação de construtores:
Integrando Haskell à Plataforma .NET
ClosuresClosures • Objetos alocados dinamicamente que Objetos alocados dinamicamente que
encapsulam um código a ser executado e um encapsulam um código a ser executado e um ambiente que pode ser acessado pelo código.ambiente que pode ser acessado pelo código.
• Em linguagens Em linguagens lazy, lazy, argumentos e variáveis argumentos e variáveis livres são closures.livres são closures.
f :: Int -> u -> (Int -> Int)
f x y = let g w = x + w in g
•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.
Integrando Haskell à Plataforma .NET
ClosuresClosures• Alternativas de Representação:Alternativas de Representação:
– Uma classe por closureUma classe por closure• Grande número de classesGrande número de classes• Ex.: F#, Mondrian, implementações para JVMEx.: F#, Mondrian, implementações para JVM
– Classes genéricas para vários tipos de closureClasses genéricas para vários tipos de closure• Uso de ponteiro para método – náo verificável Uso de ponteiro para método – náo verificável • Uso de delegatesUso de delegates
• Alternativa adotada: classes genéricas com Alternativa adotada: classes genéricas com uso de delegatesuso de delegates
Integrando Haskell à Plataforma .NET
DelegateDelegate
• Objeto que encapsula:Objeto que encapsula:– um ponteiro para um método a ser invocadoum ponteiro para um método a ser invocado– uma referência para o objeto alvo no qual o uma referência para o objeto alvo no qual o
método deverá ser chamado (método deverá ser chamado (nullnull para método para método estáticos)estáticos)
• Instância de uma classe que herda de Instância de uma classe que herda de MulticastDelegateMulticastDelegate MulticastDelegate
MeuDelegate
Invoke()BeingInvoke()EndInvoke()
Implementação da CLI
Integrando Haskell à Plataforma .NET
Ambiente de Execução 1Ambiente de Execução 1
MulticastDelegate
Updatable
value : IClosure
Invoke()
Updatable_1_FV<T1>
value : IClosurefv1 : T1
Invoke()
Updatable_2_FV<T1,T2>
value : IClosurefv1 : T1fv2 : T2
Invoke()
IClosure
Enter()
NonUpdatable_2_FV<T1,T2>
arity : intfv1 : T1fv2 : T2pap : IPAP
Invoke()
NonUpdatable
arity : int
Invoke()
IClosure
Enter()
NonUpdatable_1_FV<T1>
arity : intfv1 : T1pap : IPAP
Invoke()
MulticastDelegate
Updatable
value : IClosure
Invoke()
Updatable_1_FV<T1>
value : IClosurefv1 : T1
Invoke()
Updatable_2_FV<T1,T2>
value : IClosurefv1 : T1fv2 : T2
Invoke()
IClosure
Enter()
NonUpdatable_2_FV<T1,T2>
arity : intfv1 : T1fv2 : T2pap : IPAP
Invoke()
NonUpdatable
arity : int
Invoke()
IClosure
Enter()
NonUpdatable_1_FV<T1>
arity : intfv1 : T1pap : IPAP
Invoke()
IClosure
Enter()
Pack
tag : int
Pack_1<T1>
arg1 : T1
Pack_2<T1,T2>
arg1 : T1arg2 : T2
IClosure
Enter()
Pack
tag : int
Pack_1<T1>
arg1 : T1
Pack_2<T1,T2>
arg1 : T1arg2 : T2
IPAP
PAP_1<T1>
arg1 : T1
PAP_2<T1,T2>
arg1 : T1arg2 : T2
IPAP
PAP_1<T1>
arg1 : T1
PAP_2<T1,T2>
arg1 : T1arg2 : T2
Integrando Haskell à Plataforma .NET
Ambiente de Execução 2Ambiente de Execução 2
Closure
Enter()
Updatable
value : Closurefunction : UpdCloFunction_1_FV<T1>
Updatable_1_FV<T1>
fv1 : T1value : Closurefunction : UpdCloFunction_1_FV<T1>
Updatable_2_FV<T1,T2>
fv1 : T1fv2 : T2value : Closurefunction : UpdCloFunction_2_FV<T1,T2>
NonUpdatable_2_FV<T1,T2>
arity : Integerpap : IPAPfv1 : T1fv2 : T2function : NonUpdCloFunction_2_FV<T1,T2>
NonUpdatable_1_FV<T1>
arity : Integerpap : IPAPfv1 : T1function : NonUpdCloFunction_1_FV<T1>
NonUpdatable
arity : Integerpap : IPAPfunction : NonUpdCloFunction
Closure
Enter()
Updatable
value : Closurefunction : UpdCloFunction_1_FV<T1>
Updatable_1_FV<T1>
fv1 : T1value : Closurefunction : UpdCloFunction_1_FV<T1>
Updatable_2_FV<T1,T2>
fv1 : T1fv2 : T2value : Closurefunction : UpdCloFunction_2_FV<T1,T2>
NonUpdatable_2_FV<T1,T2>
arity : Integerpap : IPAPfv1 : T1fv2 : T2function : NonUpdCloFunction_2_FV<T1,T2>
NonUpdatable_1_FV<T1>
arity : Integerpap : IPAPfv1 : T1function : NonUpdCloFunction_1_FV<T1>
NonUpdatable
arity : Integerpap : IPAPfunction : NonUpdCloFunction
Integrando Haskell à Plataforma .NET
Aplicação de FunçõesAplicação de Funções
• Aplicação de funções desconhecidas Aplicação de funções desconhecidas estaticamente ou aplicações parciaisestaticamente ou aplicações parciais
• Modelo push/enter (Ex.: Mondrian)Modelo push/enter (Ex.: Mondrian)– Código da função chamada a aplica ao número correto Código da função chamada a aplica ao número correto
de argumentosde argumentos– Fast entry pointFast entry point– Slow entry pointSlow entry point
• Modelo eval/apply (Ex.: F#, Bigloo for Scheme)Modelo eval/apply (Ex.: F#, Bigloo for Scheme)– Função chamadora aplica a função chamada ao Função chamadora aplica a função chamada ao
número correto de argumentosnúmero correto de argumentos
• Alternativa adotada: modelo push/enterAlternativa adotada: modelo push/enter– Maior facilidade de implementaçãoMaior facilidade de implementação
Integrando Haskell à Plataforma .NET
Pilha de ChamadasPilha de Chamadas
• Pilha de chamadas tende a um crescimento Pilha de chamadas tende a um crescimento muito rápidomuito rápido
• Possíveis soluções:Possíveis soluções:– Tail-calls (prefixo suportado pela IL - Tail-calls (prefixo suportado pela IL - .tail.tail))– TrampolimTrampolim
– Instrução Instrução jmp (njmp (não verificável)ão verificável)
while (f != null) f = f.Invoke();
Integrando Haskell à Plataforma .NET
• Função Função mapmap
ExemploExemplo
Integrando Haskell à Plataforma .NET
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:6 Pack 2<Closure,Closure>k = 7 (Pack 2<Closure,Closure>) scrutinee;7 Closure arg 1 = k.arg1; Closure arg 2 = k.arg2;9 Updatable_2_FV<Closure,Closure>fx_closure =10 new Updatable_2_FV<Closure,IClosure>(11 new UpdCloFunction<Closure,IClosure>(fx));11 fx closure.fv1 = arg 1; fx closure.fv2 = f;12 Updatable_2_FV<Closure,Closure>fxs closure =13 new Updatable_2_FV<Closure,Closure>(14 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 }
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:6 Pack 2<Closure,Closure>k = 7 (Pack 2<Closure,Closure>) scrutinee;7 Closure arg 1 = k.arg1; Closure arg 2 = k.arg2;9 Updatable_2_FV<Closure,Closure>fx_closure =10 new Updatable_2_FV<Closure,IClosure>(11 new UpdCloFunction<Closure,IClosure>(fx));11 fx closure.fv1 = arg 1; fx closure.fv2 = f;12 Updatable_2_FV<Closure,Closure>fxs closure =13 new Updatable_2_FV<Closure,Closure>(14 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 }
ExemploExemplo
Alocação e inicialização de
closures
Chamada ao slow entry
point
Chamada ao fast entry
point
Análise de Análise de Desempenho e Desempenho e
OtimizaçõesOtimizações
Integrando Haskell à Plataforma .NET
MetodologiaMetodologia
• Subconjunto do grupo Imaginário do Subconjunto do grupo Imaginário do benchmark benchmark NofibNofib
• Execuções consecutivas (6) dos programasExecuções consecutivas (6) dos programas– Tempo de execução em segundos (comando Tempo de execução em segundos (comando timetime))– Média aritméticaMédia aritmética
• Valores de comparação sumarizados por Valores de comparação sumarizados por média geométricamédia geométrica
Integrando Haskell à Plataforma .NET
EntradasEntradas
• Dificuldade para Dificuldade para escolha de entradasescolha de entradas– Nofib sugere saídasNofib sugere saídas– Dados desatualizadosDados desatualizados
• Escolha baseada em Escolha baseada em tempos de execução tempos de execução razoáveis (testes razoáveis (testes críticos)críticos)
ProgramaPrograma EntradaEntrada
Digits_e1Digits_e1 20002000
Digits_e2Digits_e2 30003000
Exp3Exp3 99
PrimesPrimes 45004500
QueensQueens 1313
TakTak (12,1,25)(12,1,25)
Wheel-sieve1Wheel-sieve1 400000400000
Wheel-sieve2Wheel-sieve2 8000080000
Integrando Haskell à Plataforma .NET
Uso de DelegatesUso de DelegatesProgramaPrograma Closures como Closures como
delegatesdelegatesClosures Closures separadas de separadas de delegatesdelegates
MelhorMelhoraa
Digits_e1Digits_e1 32,0632,06 29,3029,30 8,6%8,6%
Digits_e2Digits_e2 33,6333,63 32,4232,42 3,6%3,6%
Exp3Exp3 29,1329,13 39,4439,44 -35,4%-35,4%
PrimesPrimes 20,3020,30 21,1021,10 -3,9%-3,9%
QueensQueens 18,3818,38 16,7216,72 9,0%9,0%
TakTak 14,5414,54 14,5914,59 0,0%0,0%
Wheel-sieve1Wheel-sieve1 19,8019,80 11,6211,62 41,3%41,3%
Wheel-sieve2Wheel-sieve2 291,78291,78 18,7618,76 93,6%93,6%
MédiaMédia 32,6%32,6%
Integrando Haskell à Plataforma .NET
Principais OtimizaçõesPrincipais Otimizações
• Remoção do Remoção do updateupdate frameframe
• Compartilhamento de booleanosCompartilhamento de booleanos
• Relacionadas a tail-callsRelacionadas a tail-calls
Integrando Haskell à Plataforma .NET
Remoção do Remoção do Update Frame Update Frame • Remoção da pilha de atualizaçõesRemoção da pilha de atualizações• Uso do próprio Uso do próprio stack framestack frame da CLR da CLR• 1ª. versão do ambiente de execução1ª. versão do ambiente de execução
ProgramaPrograma AnteAntess
DepoDepoisis
MelhoMelhorara
Digits_e1 (1000)Digits_e1 (1000) 12,412,433
11,9911,99 3,6%3,6%
Digits_e2 (1500)Digits_e2 (1500) 11,611,688
10,3110,31 11,8%11,8%
Exp3Exp3 3,973,97 2,772,77 30,2%30,2%
Primes (3000)Primes (3000) 13,313,333
12,7312,73 4,5%4,5%
Queens (12)Queens (12) 9,309,30 8,988,98 3,5%3,5%
MédiaMédia 11,4%11,4%
Integrando Haskell à Plataforma .NET
Booleanos – CompartilhamentoBooleanos – Compartilhamento
ProgramaPrograma AnteAntess
DepoDepoisis
MelhoMelhorara
Digits_e1 (1500)Digits_e1 (1500) 18,718,788
16,3116,31 13,1%13,1%
Digits_e2 (2000)Digits_e2 (2000) 15,915,933
12,8112,81 19,6%19,6%
Exp3Exp3 40,040,022
40,0640,06 0.0%0.0%
Primes (3500)Primes (3500) 18,618,633
12,8412,84 31,1%31,1%
QueensQueens 38,838,800
23,1223,12 40,4%40,4%
TakTak 41,641,600
22,3222,32 46,3%46,3%
Wheel-sieve1 (200000)Wheel-sieve1 (200000) 11,911,955
8,428,42 29,6%29,6%
Wheel-sieve2 (40000)Wheel-sieve2 (40000) 9,949,94 7,117,11 28,5%28,5%
MédiaMédia 27,3%27,3%
Integrando Haskell à Plataforma .NET
Tail-callsTail-calls• Remoção de tail-calls apenas do ambiente de Remoção de tail-calls apenas do ambiente de
execuçãoexecuçãoProgramaPrograma AntesAntes DepoDepo
isisMelhoMelhorara
Digits_e1 (1500)Digits_e1 (1500) 16,3016,30 15,9915,99 1,9%1,9%
Digits_e2 (2000)Digits_e2 (2000) 12,8412,84 12,5112,51 2,5%2,5%
Exp3Exp3 40,1140,11 39,0339,03 2,7%2,7%
Primes (3500)Primes (3500) 12,8312,83 12,4112,41 3,3%3,3%
QueensQueens 23,1423,14 22,8622,86 1,2%1,2%
TakTak 22,3422,34 22,2922,29 0,2%0,2%
Wheel-sieve1 (200000)Wheel-sieve1 (200000) 8,438,43 5,695,69 32,6%32,6%
Wheel-sieve2 (40000)Wheel-sieve2 (40000) 7,117,11 7,017,01 1,5%1,5%
MédiaMédia 6,4%6,4%
Integrando Haskell à Plataforma .NET
Tail-callsTail-calls• Impacto da presença de tail-calls no código Impacto da presença de tail-calls no código
compiladocompiladoProgramaPrograma Com tail-Com tail-
callscallsSem tail-Sem tail-callscalls
MelhoMelhorara
Digits_e1Digits_e1 29,4429,44 33,5833,58 12,3%12,3%
Digits_e2 (2000)Digits_e2 (2000) 12,6212,62 13,3913,39 5,7%5,7%
Exp3Exp3 39,4139,41 41,5941,59 5,2%5,2%
PrimesPrimes 21,1421,14 22,5222,52 6,1%6,1%
QueensQueens 22,9222,92 36,8836,88 51,1%51,1%
TakTak 22,3722,37 17,3717,37 --28,8%28,8%
Wheel-sieve1 (200000)Wheel-sieve1 (200000) 5,695,69 Estouro da Estouro da pilhapilha
--
Wheel-sieve2 (40000)Wheel-sieve2 (40000) 7,087,08 8,828,82 19,8%19,8%
MédiaMédia 13,2%13,2%
Integrando Haskell à Plataforma .NET
Tail-callsTail-calls• Substituição por instruções de desvioSubstituição por instruções de desvio
ProgramaPrograma AnteAntess
DepoDepoisis
MelhoMelhorara
Digits_e1Digits_e1 29,429,466
29,3029,30 0,5%0,5%
Digits_e2Digits_e2 32,432,477
32,4232,42 0,2%0,2%
Exp3Exp3 39,439,499
39,4439,44 0,1%0,1%
PrimesPrimes 21,121,155
21,1021,10 0,2%0,2%
QueensQueens 22,922,922
16,7216,72 22,0%22,0%
TakTak 22,322,399
14,5914,59 34,9%34,9%
Wheel-sieve1Wheel-sieve1 15,015,011
11,6211,62 22,6%22,6%
Wheel-sieve2Wheel-sieve2 18,718,777
18,7618,76 19,8%19,8%
MédiaMédia 11,9%11,9%
Integrando Haskell à Plataforma .NET
Haskell.NET X GHC NativoHaskell.NET X GHC Nativo
ProgramaPrograma GHC GHC NativoNativo
Haskell.NHaskell.NETET
Razão.NET/Razão.NET/NativoNativo
Digits_e1Digits_e1 6,296,29 29,3029,30 4,74,7
Digits_e2Digits_e2 6,696,69 32,4232,42 4,84,8
Exp3Exp3 2,812,81 39,4439,44 14,014,0
PrimesPrimes 0,950,95 21,1021,10 22,122,1
QueensQueens 10,2110,21 16,7216,72 1,61,6
TakTak 13,2213,22 14,5914,59 1,11,1
Wheel-sieve1Wheel-sieve1 6,786,78 11,6211,62 1,71,7
Wheel-sieve2Wheel-sieve2 5,915,91 18,7618,76 3,23,2
MédiaMédia 4,04,0
Conclusões e Conclusões e Trabalhos Trabalhos
FuturosFuturos
Integrando Haskell à Plataforma .NET
ContribuiçõesContribuições
• Desenvolvimento de uma implementação de Desenvolvimento de uma implementação de Haskell para .NETHaskell para .NET
• Avaliação de desempenho sob vários Avaliação de desempenho sob vários aspectosaspectos
• Ambiente de estudo e prototipação de Ambiente de estudo e prototipação de técnicas alternativastécnicas alternativas
• Base para a interoperabilidade com outras Base para a interoperabilidade com outras linguagenslinguagens
Integrando Haskell à Plataforma .NET
ConclusõesConclusões
• Parte do prelúdio implementadaParte do prelúdio implementada– Subconjunto básico implementado em C#Subconjunto básico implementado em C#
• Desenvolvimento e avaliação de dois ambientes de Desenvolvimento e avaliação de dois ambientes de execuçãoexecução– Segunda versão: maior portabilidade e Segunda versão: maior portabilidade e
manutenibilidademanutenibilidade
• Desempenho da mesma ordem de magnitude que o Desempenho da mesma ordem de magnitude que o GHC nativo para a maioria dos programasGHC nativo para a maioria dos programas
• Gerenciamento de memória ainda é um fator críticoGerenciamento de memória ainda é um fator crítico
• Análises de desempenho fornecem uma visão Análises de desempenho fornecem uma visão realista da CLRrealista da CLR
Integrando Haskell à Plataforma .NET
Trabalhos FuturosTrabalhos Futuros
• Suporte a mais BibliotecasSuporte a mais Bibliotecas
• Análises de DesempenhoAnálises de Desempenho– Outras representações para closuresOutras representações para closures– Avaliação do modelo eval/applyAvaliação do modelo eval/apply– Extensões à máquina virtual (via Rotor)Extensões à máquina virtual (via Rotor)
• Integração com PhoenixIntegração com Phoenix
• Suporte a interoperabilidadeSuporte a interoperabilidade– Implementação da FFI (Implementação da FFI (Foreign Function Foreign Function
InterfaceInterface))– Extensões OO à inguagemExtensões OO à inguagem– Geração de wrappersGeração de wrappers
Integrando Haskell à Integrando Haskell à Plataforma .NETPlataforma .NET
Dissertação de MestradoDissertação de MestradoMonique Louise de Barros MonteiroMonique Louise de Barros Monteiro
Orientador: Orientador: André Luís de Medeiros SantosAndré Luís de Medeiros Santos