estudo da interpretação abstrata como auxílio à exploração ... · automática do paralelismo...

38
UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL INSTITUTO DE INFORMÁTICA PROGRAMA DE PÓS-GRADUAÇÃO EM COMPUTAÇÃO Estudo da Interpretação Abstrata como Auxílio à Exploração Automática do Paralelismo em Paradigmas Declarativos por Silvana Campos de Azevedo TI 867 PPGC-UFRGS Trabalho Individual Prof. Dr. Cláudio Fernando Resin Geyer Orientador Porto Alegre, agosto de 1999

Upload: nguyentuyen

Post on 28-Jan-2019

215 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL INSTITUTO DE INFORMÁTICA

PROGRAMA DE PÓS-GRADUAÇÃO EM COMPUTAÇÃO

Estudo da Interpretação Abstrata como Auxílio à Exploração

Automática do Paralelismo em Paradigmas Declarativos

por

Silvana Campos de Azevedo TI 867 PPGC-UFRGS

Trabalho Individual

Prof. Dr. Cláudio Fernando Resin Geyer Orientador

Porto Alegre, agosto de 1999

Page 2: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

2

Sumár io

LISTA DE FIGURAS.......................................................................................................... 3

L ISTA DE TABELAS.......................................................................................................... 4

L ISTA DE ABREVIATURAS............................................................................................ 5

RESUMO .............................................................................................................................. 6

ABSTRACT .......................................................................................................................... 7

1 INTRODUÇÃO................................................................................................................. 8

1.1 TEMA ............................................................................................................................. 8 1.2 MOTIVAÇÃO .................................................................................................................. 8 1.3 OBJETIVOS..................................................................................................................... 8 1.4 ESTRUTURA DO TEXTO .................................................................................................. 9

2 INTERPRETAÇÃO ABSTRATA ................................................................................. 10

2.1 ABORDAGEM FORMAL ................................................................................................. 10 2.2 ABORDAGEM INFORMAL .............................................................................................. 12 2.3 CONCLUSÃO................................................................................................................. 14

3 PROGRAMAÇÃO EM LÓGICA ................................................................................. 15

3.1 CARACTERÍSTICAS....................................................................................................... 15 3.2 INTERPRETAÇÃO ABSTRATA ........................................................................................ 17 3.3 AMBIENTE DE DESENVOLVIMENTO.............................................................................. 19 3.4 CONCLUSÃO................................................................................................................. 23

4 PROGRAMAÇÃO FUNCIONAL ................................................................................. 24

4.1 CARACTERÍSTICAS....................................................................................................... 24 4.2 EVALUATION TRANSFORMERS..................................................................................... 25

4.2.1 Modelo de Avaliação Paralela............................................................................. 25 4.2.2 Interpretação Abstrata ......................................................................................... 27 4.2.3 Evaluation Transformers...................................................................................... 29

4.3 PARTICIONAMENTO GLOBAL ....................................................................................... 30 4.4 CONCLUSÃO................................................................................................................. 33

5 CONCLUSÃO ................................................................................................................. 34

BIBLIOGRAFIA ................................................................................................................ 36

Page 3: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

3

Lista de Figuras FIGURA 2.1 - DOMÍNIOS E FUNÇÕES DE ABSTRAÇÃO E CONCRETIZAÇÃO [LAB 92] ........... 11 FIGURA 2.2 - SEGURANÇA DE UMA INTERPRETAÇÃO ABSTRATA [LAB 92] ........................ 11 FIGURA 2.3- PROGRAMA DE MANIPULAÇÃO NUMÉRICA ..................................................... 13 FIGURA 3.1 - EQUAÇÃO DO ALGORITMO DE UM PROGRAMA EM LÓGICA............................. 15 FIGURA 3.2 - PROGRAMA DA ÁRVORE GENEALÓGICA ........................................................ 15 FIGURA 3.3 - SIMULAÇÃO DA EXECUÇÃO ........................................................................... 16 FIGURA 3.4 - PARALELISMO OU/E..................................................................................... 16 FIGURA 3.5 - PROCESSO DE INTERPRETAÇÃO ABSTRATA [LAB 92] ................................... 20 FIGURA 4.1 - ÁRVORE DE EXECUÇÃO DE REVERSE [BUR 87] ............................................. 30 FIGURA 4.2 - BLOCO QUE CHAMA UMA FUNÇÃO F (A). BLOCO BÁSICO OBTIDO PELA

DESCONEXÃO DA CHAMADA DE F (B). PARTE [U, V] DE F (C). PARTE [U] (D). PARTE � �

P (E) [COO 96]. ...................................................................................................................... 31

Page 4: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

4

Lista de Tabelas TABELA 2.1 - TABELA DA OPERAÇÃO DE MULTIPLICAÇÃO................................................. 13 TABELA 2.2 - TABELA DA OPERAÇÃO DE ADIÇÃO .............................................................. 13 TABELA 4.1 - DOMÍNIO ABSTRATO PARA TIPOS BÁSICOS.................................................... 27 TABELA 4.2 - DOMÍNIO ABSTRATO PARA TIPO LISTA .......................................................... 27 TABELA 4.3 - INTERPRETAÇÃO ABSTRATA DAS FUNÇÕES LENGTH, SUMLIS......................... 28 TABELA 4.4 - INTERPRETAÇÃO ABSTRATA DA FUNÇÃO APPEND......................................... 28 TABELA 4.5 - INTERPRETAÇÃO ABSTRATA DA FUNÇÃO REVERSE........................................ 28 TABELA 4.6 - EVALUATION TRANSFORMERS PARA REVERSE.................................................. 29 TABELA 4.7 - EVALUATION TRANSFORMERS PARA LENGTH E SUMLIST .................................. 30

Page 5: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

5

Lista de Abreviaturas CASLOG Complexity Analyzer Systems for LOGic programming GRANLOG Granularity Analyzer for LOGic programming ParTy Parallel Types Analyzer P-TAC Parallel Three-Address SP-TAC Simple P-TAC

Page 6: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

6

Resumo A limitada habili dade dos compiladores na detecção automática do paralelismo dos programas é uma significante barreira para o uso das arquiteturas paralelas. Técnicas de análise global, como a interpretação abstrata, podem prover sistemas que auxiliem os compiladores a detectarem fontes de paralelismo. A interpretação abstrata simula a execução de um programa segundo um domínio abstrato obtendo informações sobre o seu comportamento.

O trabalho enfoca a utili zação da interpretação abstrata no auxílio à paralelização automática de programas. Dentro deste universo destacam-se os paradigmas declarativos pelo fato desta técnica encontrar grande aplicabili dade na exploração do paralelismo implícito destes paradigmas. Palavras Chaves: Exploração Automática do Paralelismo, Interpretação Abstrata,

Paradigmas Declarativos

Page 7: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

7

TITLE : Study on Abstract Interpretation as a Help to Automatic Parallel Exploitation in Declarative Paradigms

Abstract The limited compiler abili ty to automatically detect parallelism is a meaningful barrier to parallel architecture use. Global analysis techniques help compilers in the parallelism source detection. Abstract interpretation simulates the program execution through an abstract domain. It obtains behavior informations.

This work focuses on the use of abstract interpretation to help automatic parallelization of programs. In this area, declarative paradigms stand out due to the great applicability of abstract interpretation technique in implicit parallelism exploitation. Keywords: Automatic Parallel Exploitation, Abstract Interpretation, Declarative

Paradigms.

Page 8: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

8

1 Introdução

1.1 Tema O escopo do trabalho é a utili zação da análise global na paralelização automática de programas. Dentro deste universo destacam-se os paradigmas declarativos, ou seja, o paradigma em lógica e o funcional. Isto deve-se ao fato de uma das técnicas de análise global, denominada interpretação abstrata, encontrar grande aplicabili dade na exploração do paralelismo implícito destes paradigmas.

1.2 Motivação Existem duas abordagens de exploração do paralelismo, o paralelismo explícito e o paralelismo implícito. O paralelismo explícito necessita que o programador detecte o paralelismo existente no programa e expresse-o através de comandos da linguagem. O paralelismo implícito é explorado automaticamente pelo compilador ou pelo ambiente de execução, não requerendo nenhuma participação do programador.

Este texto se restringe à exploração do paralelismo implícito, mais precisamente das técnicas de compilação que detectam o paralelismo existente no programa. Isto será explorado nos paradigmas declarativos.

A limitada habili dade dos compiladores para achar o paralelismo dos programas é uma significante barreira para o uso de arquiteturas paralelas [BLU 94]. Técnicas de análise global, como a interpretação abstrata, podem prover sistemas que auxil iem os compiladores a detectarem fontes de paralelismo. A interpretação abstrata simula a execução de um programa segundo um domínio abstrato obtendo informações sobre o seu comportamento.

Os paradigmas declarativos adequam-se à aplicação da técnica de análise global por possuírem fontes de paralelismo inerentes. Outra característica que facilita a exploração automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e funcionais não estão vinculadas à arquitetura.

Estes aspectos incentivaram a realização de um estudo sobre as propriedades que a interpretação abstrata pode obter em tempo de compilação para auxil iar na exploração automática do paralelismo. Além disso enfoca-se a técnica de interpretação abstrata e os principais conceitos básicos dos paradigmas declarativos.

1.3 Objetivos O objetivo geral deste trabalho consiste no estudo do auxílio que a interpretação abstrata pode dar na exploração do paralelismo implícito nos paradigmas de desenvolvimento. O enfoque é direcionado aos paradigmas declarativos pelo fato desta

Page 9: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

9

técnica de análise global ser amplamente utili zada com a finalidade de auxiliar a exploração automática do paralelismo.

Pretende-se alcançar como objetivos específicos. � estudar os princípios da interpretação abstrata; � estudar os paradigmas declarativos; � detectar problemas que impedem a exploração automática do paralelismo nestes paradigmas; � estudar a interpretação abstrata aplicada a esses paradigmas.

1.4 Estrutura do Texto O texto está dividido em cinco capítulos. O segundo capítulo apresenta os princípios da interpretação abstrata, ou seja, a teoria formal desta técnica. O capítulo três disserta sobre as características básicas do paradigma em lógica, como estrutura básica do paradigma, as fontes de paralelismo, a influência das informações de modos e dependências no processo de paralelização e a interpretação abstrata aplicada a este paradigma no auxilio da exploração automática do paralelismo. O capítulo quatro mostra os princípios do paradigma funcional, dois modelos de paralelização implícita e a utili zação da interpretação abstrata nestes modelos. O quinto capítulo relata as conclusões obtidas na realização deste trabalho.

Page 10: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

10

2 Interpretação Abstrata Este capítulo descreve na seção 2.1 os conceitos da técnica de análise global denominada interpretação abstrata, seus objetivos e suas características. Posteriormente aos conceitos teóricos, a seção 2.2 apresenta esta técnica com o exemplo da aplicação da ‘regra dos sinais’ em um programa de manipulação numérica. A seção 2.3 expõe as considerações finais deste capítulo.

2.1 Abordagem Formal

A análise global visa prever em tempo de compilação características da execução do programa. Isto pode ser feito através da técnica de análise global denominada interpretação abstrata. A interpretação abstrata tem o objetivo de obter em tempo de compilação informações sobre os termos a que as variáveis do programa estarão ligadas em tempo de execução, para um determinado ponto de entrada. Isto ocorre através da simulação de um programa segundo um domínio abstrato [COR 97], [DAM 97], [LAB 96]. Esta análise poderia ser realizada em princípio calculando-se o conjunto de todas as possíveis instanciações, denominado � , que podem acontecer em cada passo da execução. No entanto este conjunto pode ser infinito, o que acarretaria computações infinitas [LAB 92].

Para solucionar este problema, a interpretação abstrata utili za as noções de aproximação e representação finita. A aproximação baseia-se na construção de um conjunto � a tal que

� � � a

e prova-se que � �,

� � � a � p(

�),

então a propriedade (p(�)) também se satisfaz � �

, � � �

Diz-se que � a é uma aproximação segura de � . Da mesma forma qualquer função pode ser aproximada. Considera-se a aproximação da função semântica de um programa: Seja o significado de um programa P uma função Fc na qual os valores de entrada e saída pertencem ao domínio concreto

D: Fc: D � D

Muda-se o significado de forma que esta função obtenha um conjunto de saída a partir de um conjunto de entrada, então tem-se a função

Fc : (D) � (D)

onde

Fc (S) = { Fc(x) | x � S}

(S) denota o conjunto das partes de S, diz-se que a função

Page 11: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

11

G: � (D) � (D)

é uma aproximação segura de Fc� se �S, S � � (D), G(S) � Fc� (S)

Provando-se isto todas as propriedades que forem provadas para G estão automaticamente provadas para Fc� .

O segundo conceito básico é o de representação finita. O domínio � (D) pode ser representado através de um domínio Da cujo os elementos são representações finitas dos elementos de � (D) os quais podem ser infinitos. O domínio concreto ( � (D)) e o domínio abstrato (Da) estão relacionados por um par de funções denominadas abstração ( � ) e concretização ( � ). A figura 2.1 apresenta a definição destas funções.

FIGURA 2.1 - Domínios e funções de abstração e concretização [LAB 92]

� � : Da � (D) tal que � ( � ) = d se d é o maior elemento de � (D) que descreve � ; � � : � (D) Da, tal que � (d) = � se � é o menor elemento de Da que descreve d.

Então, a função semântica abstrata pode ser definida como Fa: Da Da sendo uma aproximação segura da função semântica concreta se

� � , � � Da, � (Fa( � )) � Fc� ( � ( � )). Através destas condições pode-se provar propriedades dos resultados obtidos para uma determinada classe de entradas, representadas por � , demostrando que todos os elementos de � (Fa( � )) tem estas propriedades [LAB 92], como ilustra a figura 2.2.

FIGURA 2.2 - Segurança de uma interpretação abstrata [LAB 92]

� (D) Da

��

� �

Fc���

Fa

Page 12: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

12

2.2 Abordagem Informal

A fim de apresentar melhor tal assunto demostra-se esta situação com o exemplo clássico da aplicação da ‘regra dos sinais’ em um programa de manipulação numérica. Considera-se a seguinte sintaxe abstrata de uma linguagem de expressões aritméticas [BUR 89]:

Exp::= cn |Exp + Exp |Exp * Exp

Existe uma constante cn para cada inteiro n. Uma maneira normal de interpretar tal linguagem é primeiro interpretar o conjunto de constantes { cn} como inteiros que podem ser denotados por � st, então a constante cn é interpretada como um inteiro n. Os símbolos + e * são interpretados como adição e multiplicação de inteiros. Isto induz a uma função de interpretação padrão denotada por Est,

Est: Exp� Zst Est [[cn]] = n Est [[Exp1 + Exp2]] = Est [[Exp1]] +r E

st [[Exp2]] Est [[Exp1 * Exp2]] = Est [[Exp1]] * r E

st [[Exp2]]

onde +r e * r são as funções reais de adição e multiplicação.

Se a propriedade de interesse é se o valor da expressão é positivo, negativo ou zero, pode-se usar a interpretação padrão da linguagem para determinar a resposta do cálculo e então ver se é positivo, negativo ou zero. Por exemplo, para a expressão:

c29 * c-33 * c64

o cálculo da resposta é

Est[[c29]] * r Est[[c-33]] * r E

st[[c64]]

o qual é

29 * r –33 * r 64 = -61248

um valor negativo. Uma maneira mais simples de fazer isto é, por exemplo, multiplicar um número positivo por um número negativo e verificar o sinal do número resultante. Normalmente isto pode ser feito calculando-se o sinal da expressão, como por exemplo:

(+) * (-) * (+) = (-)

onde (+) representa a propriedade de ser positivo, e similarmente (-) representa a propriedade de ser negativo, e então se diz que a resposta para o cálculo real será negativa.

A interpretação abstrata é denotada por Eab [BUR 89].

Eab[[cn]] = sign(Est[[cn]])

onde

Page 13: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

13

(+) se n>0 sign(n) = (0) se n=0 (-) se n<0

O aspecto importante não é o valor da constante mas sim seu sinal. Isto representa o escopo sob o qual deseja-se realizar a análise, ou seja, o domínio abstrato [AZE 98a]. Suponha que, dado o programa mostrado na figura 2.3, deseja-se saber o que pode ser afirmado em relação aos valores das variáveis (positivo, negativos ou zero). Assume-se, que x será sempre negativo, e y sempre positivo, quando o programa é chamado.

w:= x * y z:= w * w v:= w + y

FIGURA 2.3- Programa de manipulação numérica

Inicialmente define-se um domínio abstrato sob o qual a análise será feita. Este domínio conterá quatro valores: +, -, 0, T. Todos os valores positivos serão mapeados para +, todos os valores negativos serão denotados -, 0 denota o valor zero e T é utili zado para caracterizar a falta de informação sobre o sinal da variável.

Também existem as regras de sinais, onde pode-se escrever a interpretação de + e * como +ab, apresentada na tabela 2.2, e *ab, mostrada na tabela 2.1:

TABELA 2.1 - Tabela da operação de multiplicação

*ab - 0 + T - + 0 - T 0 0 0 0 T + - 0 + T T T T T T

TABELA 2.2 - Tabela da operação de adição

+ab - 0 + T - - - T T 0 - 0 + T + T + + T T T T T T

Page 14: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

14

De posse do novo domínio, e com as operações já redefinidas para trabalhar neste domínio abstrato, o programa é então executado a partir dos valores iniciais x=- e y=+. Da primeira linha do programa tem-se w:=- *ab +, ou seja, w=-, da segunda linha, z:=- * ab -, ou seja, z=+ e na terceira linha, v:=- +ab +, fazendo v=T. Isto significa que sempre que o programa for chamado com x tendo um valor negativo, e y tendo um valor positivo, a variável w assumirá valores negativos, enquanto z assumirá valores positivos. Sobre a variável v não pode-se afirmar qual sinal terá [CAS 96].

O processo de simulação realizado pela interpretação abstrata, ocorre através de sucessivas iterações no código fonte. Isto é realizado até que se encontre um resultado estável, ou seja, quando ocorrerem duas iterações consecutivas com o mesmo valor. Este processo é denominado cálculo do ponto fixo.

2.3 Considerações Finais

Este capítulo enfocou a abordagem formal e a abordagem informal da técnica de interpretação abstrata. Um aspecto relevante deste estudo é que apesar das informações geradas pela interpretação abstrata serem aproximadas, estas aproximações são seguras. Por outro lado, a utilização de técnicas de análise em runtime alcançam maior precisão, porém causam um overhead adicional ao sistema.

Page 15: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

15

3 Programação em Lógica

Este capítulo descreve o paradigma da programação em lógica e o auxílio que a interpretação abstrata pode ter na exploração implícita do paralelismo neste paradigma. A seção 3.1 expõe as características do paradigma em lógica, suas fontes de paralelismo implícito e a relevância das informações de modos e dependências para a exploração automática do paralelismo. A seção 3.2 apresenta alguns domínios abstratos para a programação em lógica. A seção 3.3 descreve o processo de interpretação abstrata sobre o domínio sharing. Finalmente a seção 3.4 apresenta as considerações finais deste capítulo.

3.1 Caracter ísticas A entidade básica dos programas em lógica é o predicado lógico [BAR 98]. Um programa em lógica consiste no desenvolvimento de sentenças lógicas que representem o problema a ser resolvido. Como este problema será resolvido é tarefa do ambiente de execução. A figura 3.1 mostra de forma sucinta este conceito.

FIGURA 3.1 - Equação do algoritmo de um programa em lógica

A separação da lógica e do controle possibilita que o controle da execução seja transparente ao usuário. O controle fica a cargo do ambiente de execução e este tem um enorme grau de liberdade na escolha dos caminhos de dedução que serão percorridos para solucionar o problema [HER 86]. Esta característica é denominada não-determinismo.

A fim de ilustrar melhor o não-determinismo de um programa em lógica simulou-se a execução do programa apresentado na figura 3.2. A figura 3.3 mostra a simulação.

FIGURA 3.2 - Programa da árvore genealógica

Algoritmo = Lógica + Controle

pai(joão, marcos).pai(joão, josé).pai(josé, maria).pai(josé, antônio).

avô(X, Y):- pai(X, Z), pai(Z, Y).

:- avô(A, antônio).

Page 16: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

16

FIGURA 3.3 - Simulação da execução

Como pode-se perceber na figura 3.3 o sistema de backtracking serve para retornar quando um ramo da árvore de execução falha. O não-determinismo pode ocorrer na escolha dos ramos da execução. O sistema de backtraking muitas vezes é visto como um barreira para o aumento do desempenho computacional. Esta característica é uma das grandes motivações para a exploração do paralelismo em programas em lógica.

O relacionamento entre paralelismo e programação em lógica está baseado na liberdade que o ambiente de execução possui na escolha dos caminhos da execução. Esta liberdade permite o desenvolvimento de ambientes de execução que explorem em paralelo os diversos caminhos oriundos do não-determinismo. As duas principais fontes de não-determinismo originam as duas principais fontes de paralelismo na programação em lógica. O paralelismo OU, refere-se à execução paralela das cláusulas de um predicado, e o paralelismo E, refere-se a execução paralela das metas de uma cláusula. A figura 3.4 mostra o paralelismo OU e o paralelismo E.

FIGURA 3.4 - Paralelismo OU/E

Para obter um melhor desempenho no processo de paralelização em um programa

Prolog [STE 94], é necessário a análise do comportamento dos argumentos em relação ao modo de chamada dos procedimentos e em relação aos tipos de elementos a que se instanciam. Isto deve-se ao fato da programação em lógica não possuir distinção entre

tripulação(X, Y):- passageiro(X), piloto(Y).tripulação(X, Y):- mecânico(X), piloto(Y).

Paralelismo E

Paralelismo OU

avô(A, antônio)

pai(A, Z), pai(Z, antônio)

pai(joão, marcos), pai(marcos, antônio) pai(joão, josé), pai(josé, antônio)

backtraking

Page 17: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

17

argumento de entrada e argumento de saída. Esta característica dificulta a determinação dos fluxos de controle e consequentemente a determinação das dependências entre as variáveis de um programa. Na programação em lógica as variáveis não são tipadas. Isto dificulta a determinação dos custos de comunicação entre as partes de um programa.

A informação de dependência dos dados é proveitosa em várias otimizações de programas em lógica. Por exemplo Chang [CHA 85], [CHA 85a] e Warren [WAR 77] citam a melhora do processo de bactracking e a paralelização de programas.

A obtenção das dependências entre as variáveis de um programa podem auxiliar no particionamento correto do mesmo. Obtendo-se as dependências existentes entre as metas do corpo de uma cláusula pode-se determinar quais metas tem potencialidade de serem executadas em paralelo (exploração do paralelismo E).

A informação de tipos provê a determinação dos custos de comunicação. Os custos de comunicação possuem grande relevância quando a exploração do paralelismo ocorre em ambientes de memória distribuída. A determinação dos custos auxili a no escalonamento das partes de um programa.

Uma maneira de determinar os modos, os tipos e as dependências dos argumentos de um programa em lógica é através da interpretação abstrata.

3.2 Interpretação Abstrata Existem vários domínios abstratos que representam o conjunto dos modos e dos tipos que um argumento pode assumir.

Por exemplo o domínio abstrato de modos do modelo GRANLOG, um analisador automático de granulosidade na programação em lógica [BAR 96], é o seguinte: � i: indica que o argumento está instanciado (fechado); � o: indica que o argumento não sofreu instanciação (variável li vre); � io: indica que o argumento entrou parcialmente instanciado e sofreu

instanciações durante a execução do procedimento; � ?: indica que não pode-se dizer nada a respeito da informação de modo do argumento.

Outro exemplo é o CASLOG [LIN 93], um analisador de complexidade de programas em lógica. Este modelo utili za apenas dois modos, o modo fechado e o modo aberto.

Segundo Debray [DEB 89] o domínio abstrato de modos ( � ) para os argumentos de um programa Prolog é o seguinte: � c: conjunto de termos fechados; � d: conjunto de todos os termos; � e: conjunto de termos vazios; � f: conjunto de variáveis não instanciadas; � nv: conjunto de termos não variáveis.

Page 18: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

18

O interpretador abstrato proposto por Debray [DEB 89] visa obter informações de modos e compartilhamento (dependências) entre as variáveis de um programa.

O fato do domínio do modelo GRANLOG e do domínio do modelo proposto por Debray apresentarem um tipo que caracteriza variáveis parcialmente livres possibili ta uma maior precisão na determinação das dependências entre as variáveis do programa. O modelo CASLOG não possui tal distinção entre argumento não instanciado e parcialmente instanciado. Isto pode dificultar a determinação das dependências entre os argumentos.

Outros domínios provêm informações de compartilhamento. Este é o caso dos domínios Asub, sharing e sharing+freeness. O domínio Asub [BUE 94], [LAB 95] possui a peculiaridade de informar a linearidade dos termos. Esta informação pode melhorar significativamente a precisão da informação do compartilhamento, por permitir a correta propagação do não compartilhamento definido entre as variáveis de um termo linear. Um termo linear é aquele cujos argumentos são estritamente independentes, ou seja, não compartilham variáveis.

O domínio sharing [BUE 94], [LAB 95] gera informações de compartilhamento. Dois argumentos podem compartilhar variáveis, mas no momento já estarem totalmente instanciados. Isto caracteriza argumentos que compartilham variáveis e que podem ser executados em paralelo.

O domínio sharing+freeness [BUE 94], [LAB 95] é composto de dois domínios abstratos. O domínio sharing e o domínio freeness. A informação sharing detecta compartilhamento entre as variáveis e a informação freeness detecta variáveis que permanecem livres durante a execução. A união destes dois domínios possibil ita uma maior precisão nos dois tipos de informação obtidos. Isto deve-se ao fato dos dois domínios serem complementares e portanto, a obtenção de um tipo de informação aumenta a precisão da aquisição do outro.

O domínio abstrato sob o qual o GRANLOG analisa os tipos das variáveis de um programa Prolog é o seguinte: � ?: indica que o argumento não pode ser definido. � int: indica que o argumento é um inteiro. � float: indica que o argumento é um número de ponto-flutuante. � atom(size): indica que o argumento é um átomo cujo parâmetro size contém o

número de caracteres do identificador do átomo. � var : o argumento é uma variável livre. � li st(size, types): indica que o argumento é uma lista cujo size é o número de elementos que compõe a lista e types é uma lista contendo o tipo de cada um dos argumentos. � struct(functor , elements, types): o argumento é uma estrutura cujo functor contém o número de caracteres do seu identificador. Elements determina o número de elementos da estrutura. Types é uma lista contendo o tipo de cada um dos argumentos. � io(entrada, saída): indica que o argumento possui duas notações de tipos. O parâmetro entrada descreve a instanciação antes da chamada. O parâmetro saída indica o estado de instanciação após a chamada.

Page 19: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

19

O ParTy (Parallel Types Analyser) é um interpretador abstrato de tipos para os argumentos de programas Prolog [CAS 97], [CAS 97a]. O domínio abstrato do ParTy é o seguinte: $bottom$: ausência de informação a respeito da variável. Menor elemento do

conjunto de tipos. int: representa elementos do tipo inteiro. float: representa elementos do tipo ponto-flutuante. atom(size): representa átomos de tamanho size. struct(size, ar ity, [li st_of_types]): representa estruturas de aridade arity, cujos argumentos têm os tipos descritos na lista [ li st_of_types] , e cujo functor tem tamanho size. li st(size, type): representa listas de tamanho size e tipo type. $top$: representa variáveis que podem ser ligadas a qualquer tipo de objeto em tempo de execução. [minor_type, major_type]: representa um intervalo de tipos.

Os domínios de tipos do modelo GRANLOG e do modelo ParTy se eqüivalem do ponto de vista de utili zação na paralelização de programas. Um dos pontos interessantes do domínio ParTy é o fato de possuir um modo que representa um intervalo de tipos. Isto denota uma relação de ordem no conjunto de tipos simples. Esta relação de ordem leva em conta o tamanho necessário de memória para armazenar este tipo [AZE 98], [CAS 97]. Este aspecto é importante na determinação dos custos de comunicação.

3.3 Ambiente de Desenvolvimento O interpretador abstrato descrito nesta seção pode trabalhar com os domínios abstratos Asub, sharing e sharing+freeness. Porém afim de explanação será utilizado o domínio abstrato sharing.

A entrada para o interpretador abstrato apresentado em [LAB 92] é um programa e um conjunto de modelos de consulta, que em sua forma mais simples se limitam aos nomes dos predicados que serão utili zados como entrada. Se deseja-se uma análise mais precisa, pode-se incluir uma descrição do conjunto de substituições abstratas permitidas para cada predicado de entrada. É conveniente dar nomes diferentes as substituições abstratas dependendo do ponto da cláusula a que correspondem. Considere a cláusula h:- p1, ..., pn. Sejam ! i e ! i+1 as substituições abstratas à esquerda e à direita da sub-meta pi, 1 " i " n (veja figura 3.6(b)).

Page 20: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

20

FIGURA 3.5 - Processo de interpretação abstrata [LAB 92]

Definição: considere # i e # i+1 como, respectivamente, as substituições abstratas de chamada e de retorno para a sub-meta pi. Para esta mesma cláusula, # 1 é a substituição abstrata de entrada (também representada por $ entry) e # n+1 é a substituição abstrata de saída (também representada por $ exit).

De forma similar a execução top down concreta, o processo de interpretação abstrata pode ser representado como uma árvore abstrata E-OU, onde os nodos E e os nodos OU se alternam. A cabeça de uma cláusula h é um nodo E cujos filhos são os literais do corpo p1, ..., pn, como mostra a figura 3.6(b). Da mesma forma se um destes literais podem ser unificados com diferentes cláusulas cujas cabeças são h1, ..., hm, p é um nodo OU cujos filhos são os nodos E h1, ..., hm, como mostra a figura 3.6(a).

Durante a construção da árvore, o cálculo das substituições abstratas em cada ponto se realiza da seguinte forma: % obtendo-se a substituição abstrata resultante a partir da substituição abstrata de

chamada: Seja uma substituição # ch para uma sub-meta p e sendo h1, ..., hm as cabeças das cláusulas que unificam com p, primeiro calcula-se as substituições de entrada $ 1entry, ..., $ mentry para estas cláusulas. Depois calcula-se as substituições de saída $ 1exit, ..., $ mexit. Mais tarde calcula-se as substituições resultantes # 1success, ..., # msuccess correspondente à cláusula. Finalmente, a substituição resultante # success é obtida a partir das substituições # 1success, ..., # msuccess. % obtêm-se as substituições de saída a partir das substituições de entrada: Seja uma cláusula h:- p1, ..., pn cujo corpo não é vazio e uma substituição de entrada # 1, # 1 é a nova substituição de chamada para p1, cuja substituição resultante é # 2. Finalmente se obtém a substituição de saída para esta cláusula # n+1.

Para uma estratégia de análise seria necessário: % definir um domínio abstrato e sua relação de ordem; % descrever como se calcula uma substituição de entrada para uma cláusula C a partir de uma sub-meta p que unifica com a cabeça de C e uma substituição de chamada;

&call P

&success

'1entry h1

'1exit ...............

'mentry h1m

'mexit

(a)

h

&1 p1

&2 ..........

&n pn

&n+1

(b)

Page 21: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

21

( descrever como se calcula à substituição resultante para uma submeta p a partir da substituição de chamada e de saída para uma cláusula C cuja cabeça unifica com p.

Os últimos dois passos dizem respeito à unificação abstrata. Os três passos seriam suficientes se o programa a ser avaliado não possuísse recursividade. No entanto, a recursividade é um poderoso mecanismo das linguagens de programação. Tendo em vista isto, se introduz o cálculo do ponto fixo para garantir que a computação da análise termine.

Uma substituição para as variáveis de uma cláusula é uma função que atribui a cada variável do programa nesta cláusula Pvar termos que podem ser formados a partir do universo de variáveis Var, constantes, functores e consultas consideradas. O domínio de uma substituição ) se representa dom( ) ). A instanciação de um termo t na substituição ) se denota por t ) sendo var(t ) ) o conjunto de variáveis em t ) .

Seja ) uma substituição para a cláusula C. Uma variável x em C é básica se a substituição ) é var(x ) ) = 0. Duas variáveis x e y em C são estritamente independentes na substituição ) se var(x ) ) * var(y) ) = 0. Diz-se que uma variável v ocorre na variável x na substituição ) se v + var(x ) ). Evidentemente x é básica na substituição ) se não existir nenhuma variável que ocorra em x em ) , e x e y serão estritamente independentes se em ) não existe nenhuma variável v que ocorra em ambas variáveis em ) .

Intuitivamente necessita-se saber quando um conjunto de variáveis em uma cláusula é independente para qualquer substituição concreta que possa ocorrer nesta cláusula e quando uma variável é básica para qualquer substituição concreta que ocorra na cláusula. O domínio abstrato sharing aproxima esta informação da seguinte forma: uma substituição abstrata , para uma cláusula C é um conjunto de conjuntos de variáveis de programa em C que aproxima todas aquelas substituições concretas ) sobre C que cumprem as seguintes condições:

( se uma variável X não aparece em nenhum conjunto de , , então esta variável está totalmente instanciada sobre toda substituição concreta; ( se duas variáveis X e Y não aparecem juntas em nenhum conjunto de , , então os termos a que X e Y estão ligados em tempo de execução nunca compartilharam nenhuma variável; ( se X e Y aparecem juntas em algum conjunto de , , existe a possibili dade destas variáveis compartilharem ao menos uma variável em tempo de execução.

Considere por exemplo que X, Y e Z são variáveis de programa em uma cláusula e que a substituição abstrata é {{ X} , { X, Y} } . Esta substituição abstrata corresponderia ao conjunto de substituições concretas em que X, Y e Z estão ligadas aos termos tx, ty e tz sendo que pode existir uma substituição concreta na qual os termos tx e ty compartilham ao menos uma variável (informação aproximada pelo conjunto { X, Y} ), o termo tx pode ter uma variável que não compartilha com nenhum outro termo, ou seja, não possui dependência (informação aproximada pelo conjunto { X} ) e o termo tz é um termo básico, portanto não contém variáveis (informação aproximada pelo fato de Z não aparecer em nenhum conjunto).

Page 22: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

22

Uma substituição abstrata Asubst do domínio sharing é um elemento

D - = . ( . (Pvar))

onde . (S) representa o conjunto das partes de S. Seja Subst o conjunto das possíveis substituições de Pvar a termos construídos por variáveis em Uvar, constantes, functores e consulta considerada e seja Occ a função

Occ( / , U) = { X | X 0 dom( / ) 1 U 0 var(X / )}

A abstração de uma substituição é definida como:

Definição: Abstração de uma substituição

A: subst 2 Asubst

A( / ) = { occ( / , U)|U 0 Uvar}

Exemplo: seja / = { W|a, X|f(A1, A2), Y|g(A2), Z|A3} . Occ( / , A1) = { X} , Occ( / , A2) = { X, Y} , Occ( / , A3) = { Z} e Occ( / , U) = / para qualquer outro U 0 Uvar. Portanto, A( / ) = { / , { X} , { X, Y} , { Z} } .

A função de abstração A se generaliza para conjuntos de substituições da seguinte forma:

Definição: Abstração de um conjunto de substituições

3 : . (subst) 2 Asubst

3 ( 4 ) = A( / )

Essencialmente 3 abstrai a união de toda a informação de dependências em todas as substituições de 4 . A correspondente função de concretização é:

Definição: Concretização

5 : Asubst 2 . (subst)

5 (SS) = { / |/ 0 subst 1 A( / ) 6 SS}

Existe no domínio abstrato uma ordem parcial definida sobre as substituições abstratas, induzida pela ordem parcial existente entre as substituições concretas.

71

72 se e somente se 5 (

71) 6 5 (

72).

U 8 9 :

Page 23: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

23

3.4 Considerações Finais Este capítulo dissertou sobre os aspectos do paradigma de programação em lógica. Uma das conclusões obtidas é que o não determinismo intrínseco à programação em lógica pressupõe uma facili dade na exploração automática do paralelismo. Este aspecto incentiva o desenvolvimento de interpretadores abstratos que obtenham estaticamente informações que auxil iem o ambiente de execução a explorar o paralelismo inerente ao programa. Outro aspecto relevante é que a abstração criada pela forma implícita de paralelismo facilita a programação, pois não há necessidade do envolvimento com detalhes do processamento paralelo como: particionamento do programa e sincronização. Além disso a análise global não afeta o poder de abstração da linguagem (linguagem de alto nível), ou seja, a linguagem continua desvinculada dos detalhes da arquitetura. Isto possibilita continuar com o grande grau de expressividade que as linguagens de programação em lógica proporcionam.

Page 24: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

24

4 Programação Funcional Este capítulo aborda os conceitos da programação funcional e da paralelização implícita de programas neste paradigma. A seção 4.1 disserta sobre as características gerais do paradigma funcional. A seção 4.2 descreve o modelo de avaliação paralela desenvolvido por Burn. A seção 4.3 descreve o mecanismo de paralelização implícita da linguagem SP-TAC. Finalmente a seção 4.4 apresenta as considerações finais deste capítulo.

4.1 Caracter ísticas

Na programação funcional os programas são formados exclusivamente por funções matemáticas, ou seja, a estrutura básica de um programa funcional é a função matemática. A programação em uma linguagem funcional consiste na construção de definições de expressões e no uso do computador para avaliá-las. O objetivo de programação é construir uma função para resolver um problema. Após a definição o computador passa a se comportar como uma calculadora que avalia as expressões através de simpli ficações até chegar a uma forma normal.

A execução de programas funcionais é obtida a partir do processo de ligação e de aplicação. A ligação é util izada para associar valores com nomes. A aplicação de funções é utili zada para computar novos valores.

O valor de uma expressão depende do valor das expressões que a constituem, e estas expressões podem ser substituídas por outras do mesmo valor, por exemplo:

(3 + 4) ; 7 A expressão (3+4) pode ser substituída pela expressão 7, a qual representa o mesmo valor.

Uma expressão pode ter nomes que representam valores, e é comum na matemática que várias ocorrências do mesmo nome representem o mesmo valor desconhecido. Este tipo de nome é chamado de variável [DUB 98].

O computador avalia uma expressão reduzindo-a a sua forma mais simples equivalente. No caso da expressão (3+4), sua forma mais simples equivalente é 7, pois esta não pode ser mais reduzida.

As expressões podem ser avaliadas pelo processo de substituição e simplificação, usando regras primitivas e regras feitas pelo programador em forma de definições. A forma mais simples equivalente a uma expressão, não importa qual seja, não é um valor, mas sim a representação de um valor.

Uma função está na sua forma normal se esta não pode ser mais reduzida. Existem valores que não possuem forma normal e outros apresentam uma forma não finita [DUB 98] um exemplo é o número < .

Page 25: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

25

Algumas funções não podem ser reduzidas pois produzem valores que não existem matematicamente. Um exemplo é a expressão 1/0 que deve causar uma mensagem de erro.

Os programas funcionais não possuem comandos de atribuição a posições de memória, desvinculando o programa (representação textual) da arquitetura, ou seja, as variáveis não representam espaço de memória. Outra característica importante é que a computação de um programa funcional não produz efeitos colaterais. Esta característica torna a ordem de execução irrelevante, livrando o programador de especificar o fluxo de controle.

Segundo Hammond, existem três classes de linguagens funcionais [HAN 94]: = Linguagens estritas: os argumentos de funções são avaliados antes da avaliação da função; = Linguagens não estritas: os argumentos são avaliados somente se forem necessários; = Linguagens híbridas: argumentos simples, como inteiros, são resolvidos antes da avaliação da função. No entanto, argumentos complexos, como listas, seguem a proposta das linguagens não estritas.

Hammond afirma que o paralelismo em linguagens funcionais pode ser explorado de forma explícita ou implícita. A exploração do paralelismo implícito em linguagens estritas é bastante simples, pois todos os argumentos devem ser avaliados antes da chamada da função, isto prevê a utili zação de argumentos indefinidos antes de passá-los para a função. Considerando-se que os argumentos podem ser expressões, surge a oportunidade para a exploração do paralelismo sempre que uma função for avaliada. Porém, nas linguagens não estritas o paralelismo implícito é obtido na solução paralela dos argumentos considerados necessários para a avaliação de uma função. Nesta classe de linguagem não há uma previsão da natureza dos argumentos antes de passá-los para as funções, isto dificulta a correta paralelização dos programas.

4.2 Evaluation Transformers

Esta seção descreve o processo de evaluation transformers, o qual é uma extensão da lazy evaluation. A subseção 4.2.1 apresenta o modelo de avaliação paralela desenvolvido por Burn. A seção 4.2.2 descreve o interpretador abstrato deste modelo. A seção 4.2.3 mostra o processo de evaluation transformers. 4.2.1 Modelo de Avaliação Paralela A lazy evaluation (passagem de parâmetro por demanda) assegura que os argumentos das funções só serão avaliados se forem necessários. Esta característica permite que se trabalhe com estruturas infinitas. A expressão,

w = (( > x.xx) (> x.xx)) não possui forma normal. Isto prova que independente da ordem das reduções, a validação desta expressão não chegará ao fim. Já a expressão

Page 26: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

26

x = ( ? y.z) ((? x.xx) (? x.xx))

tem a forma normal z.

Este exemplo mostra que se fosse aplicada a ordem normal de redução, w seria reduzido antes da saída, o que amarra x a w, tornando o processo de validação infinito [DAV 92]. A lazy evaluation permite que somente o necessário seja avaliado, possibili tando a redução de x a forma normal z.

A exploração do paralelismo a nível de avaliação tem como principal problema a consistência dos resultados, ou seja, a possibilidade de dois redex aplicados à mesma expressão encontrarem formas normais diferentes. Além disso a ordem de redução é importante para se certificar que um programa termina.

A lazy evaluation baseia-se na ordem normal para realizar a validação das expressões necessárias à computação do resultado [DAV 92]. Esta característica dificulta a redução de expressões em paralelo.

A ordem normal de avaliações restringe que somente um redex acontece em cada intervalo de tempo. A lazy evaluation baseia-se nesta ordem de validação para avaliar uma expressão que é necessária para a composição do resultado final. Isto é perfeitamente satisfatório para máquinas seqüenciais, no entanto é dificilmente utilizado para máquinas paralelas. A lazy evaluation avalia sempre a redução mais a esquerda e mais por fora, ou seja, avalia os argumentos somente quando necessário, evitando assim computações infinitas [DUB 98].

Outra característica é que a lazy evaluation nunca inicializa uma computação infinita a não ser que a semântica da expressão original seja avaliada como indefinida, ou seja, bottom. O problema então se reduz em assegurar que não será inicializada uma computação infinita, implicando que a semântica de toda a expressão seja bottom. Isto chama-se semantic criterion.

O semantic criterion fornece um meio naturalmente seguro de especificar o comportamento da estratégia de avaliação paralela, a qual não avalia uma expressão até que seu valor seja necessário. Nota-se que não existe desperdício de trabalho e que o semantic criterion relata fortemente o comportamento operacional de uma estratégia de avaliação e a semântica denotacional de um programa. A interpretação abstrata é utili zada para obter informações necessárias para checar o semantic criterion.

Em algumas aplicações de funções, os argumentos necessitam mais reduções que simplesmente até a forma normal. Por exemplo,

length [ ] = 0 length (x:xs) = 1 + length xs

a função length calcula o tamanho da lista, ou seja, a quantidade de elementos da lista. Para avaliar uma aplicação da função length é necessário passar por todos os elementos da lista, sem precisar saber o valor dos elementos. Já a função:

Page 27: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

27

sumlist [ ] = 0 sumlist (x:xs) = x + sumlist xs

sumlist necessita para a avaliação de uma aplicação o conhecimento de todos os elementos da lista e de seus valores.

Pode-se avaliar uma expressão utili zando-se um avaliador particular. Chama-se @ 1 o avaliador que avalia uma expressão até a forma normal. O avaliador @ 2 avalia a estrutura de uma lista. O avaliador @ 3 avalia a estrutura e o valor dos elementos de uma lista. O avaliador @ 0 não avalia expressões [BUR 89].

A utili zação de um avaliador em particular para uma determinada expressão auxili a no processo de avaliação pois permite que o avaliador só avalie o que é relevante para o processo de avaliação da expressão. 4.2.2 Interpretação Abstrata O domínio abstrato para tipos básicos, definido por Mycroft referenciado em [BUR 87] é apresentado na tabela 4.1.

TABELA 4.1 - Domínio abstrato para tipos básicos

0 representa o valor indefinido. 1 representa o valor definido.

Fonte: Burn, 87. O domínio abstrato para listas, definido por Wadler referenciado em [BUR 87] é mostrado na tabela 4.2.

TABELA 4.2 - Domínio abstrato para tipo lista

0 representa listas indefinidas. 1 representa listas infinitas e listas que tem um corpo indefinido

depois de um número finito de elementos, incluindo a lista indefinida.

2 além de conter todas as listas do tipo 1, contém todas listas finitas com pelo menos um elemento indefinido.

3 representa listas definidas. Fonte: Burn, 87.

A interpretação abstrata das funções length e sumlist são mostradas na tabela 4.3.

Page 28: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

28

TABELA 4.3 - Interpretação abstrata das funções length, sumlis

xs length sumlist 0 0 0 1 0 0 2 1 0 3 1 1

Fonte: Burn, 87. A interpretação abstrata da função append,

append [ ] ys = ys append (x:xs) ys = x: (append xs ys)

é apresentada na tabela 4.4. Uma peculiaridade desta função em relação aos outros exemplos é possuir dois argumentos como entrada.

TABELA 4.4 - Interpretação abstrata da função append

ys\xs 0 1 2 3 0 0 1 1 1 1 0 1 1 1 2 0 1 2 2 3 0 1 2 3

Fonte: Burn, 87. Outro exemplo é a interpretação abstrata da função reverse,

reverse [ ] = [ ] reverse (x:xs) = append (reverse xs) (x:[ ] )

mostrada na tabela 4.5.

TABELA 4.5 - Interpretação abstrata da função reverse

xs reverse 0 0 1 0 2 2 3 3

Fonte: Burn, 87.

Os domínios abstratos são util izados porque capturam a maneira como os avaliadores devem agir. Por exemplo, o avaliador A 1 deve terminar a avaliação se e somente se o início da avaliação denota um valor indefinido, que é o valor representado por bottom

Page 29: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

29

(0) de certo domínio abstrato. O avaliador B 2 falha se a lista for infinita, que é se uma expressão denota qualquer valor representado por 1. Finalmente B 3 falha se a expressão denota uma lista a qual é infinita ou tem qualquer valor indefinido, que é qualquer expressão que possua um elemento representado por 2. 4.2.3 Evaluation Transformers

A interpretação abstrata captura como o avaliador deve se comportar ao avaliar um argumento da aplicação de uma função. A evaluation transformers, através dos resultados da interpretação abstrata, determina o avaliador adequado a aplicação desta função. Para cada possível avaliador o processo de transformação vincula um avaliador.

Para demostrar como a evaluation transformers determina o avaliador adequado, considera-se o exemplo da função reverse. A função reverse, a qual tem os resultados da interpretação abstrata mostrados na tabela 4.5, obtém como resultado de sua computação uma lista.

Como o avaliador B 0 não oferece nenhuma segurança para a avaliação, este avaliador é transformado para si mesmo, ou seja, B 0 para B 0. O avaliador B 1 falha quando mapeado para o valor 0 do domínio abstrato. Na tabela 4.5 pode-se perceber que o maior valor do domínio abstrato que é mapeado para 0 é 1, o qual corresponde ao ponto de falha do avaliador B 2, portanto o avaliador B 1 é transformado para o avaliador B 2. O ponto do domínio abstrato que corresponde a falha para o avaliador B 2 é 1, este valor não ocorre na interpretação abstrata de reverse, que faz com que seja transformado para B 2. Finalmente, o ponto 2 corresponde ao avaliador B 3, e a interpretação abstrata mostra que o máximo valor do domínio abstrato que satisfaz isto seguramente é B 3 [BUR 89]. Isto é mostrado na tabela 4.6.

TABELA 4.6 - Evaluation transformers para reverse

xs reverse B 0 B 0 B 1 B 2 B 2 B 2 B 3 B 3 Fonte: Burn, 87.

Outro exemplo é a evaluation transformers das funções length e sumlist,

apresentadas na tabela 4.7. Como apresenta a tabela 4.3, as duas funções tem como resultados, ou definido, ou indefinido (domínio abstrato para tipos básicos). O avaliador B 0,

como não avalia a expressão é mapeado para B 0, nas duas funções.

Para length B 1 é mapeado para B 2, pois B 1 falha em 0 e a maior ocorrência de 0 é em 1, o qual corresponde ao valor de falha para B 2.

A função sumlist mapea B 1 para B 3, pois a maior ocorrência de 0 é em 2.

Page 30: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

30

TABELA 4.7 - Evaluation transformers para length e sumlist

xs length sumlist C0

C0

C0 C

3 C

2 C

3 Fonte: Burn, 87.

Os resultados da interpretação abstrata são passados para a árvore de execução do programa. Isto possibilit a uma visão prévia das avaliações que serão necessárias para a computação do resultado. Por exemplo, através da tabela 4.4, pode-se perceber que a função append só precisa da avaliação do primeiro argumento. Porém na função reverse o avaliador da função append necessita avaliar os dois argumentos, pois reverse tem como resultado uma lista. A figura 4.1 apresenta a representação da árvore de execução da função reverse [BUR 87].

FIGURA 4.1 - Árvore de execução de reverse [BUR 87]

Como pode-se perceber através destas informações os dois argumentos de append necessitam de avaliação podendo serem avaliados em paralelo.

4.3 Par ticionamento Global As funções em linguagens não estritas podem trabalhar com argumentos indefinidos e retornarem resultados parciais. Isto é denominado estratégia de avaliação lenient [COO 96].

A SP-TAC (Simple P-TAC) é uma linguagem funcional de baixo nível baseada na linguagem intermediária P-TAC (Parallel Three-Address), que é usada durante a compilação da linguagem Id [COO 96].

A SP-TAC usa a representação de grafo de um bloco. Esta representação é denominada grafo de fluxo de dados. A sintaxe da linguagem é essencialmente uma representação textual do grafo de fluxo de dados.

Definição 1: Grafo de fluxo de dados

e1

e2

append

length D2

D2

D2

Page 31: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

31

Dado um bloco b, o grafo de fluxo de dados G(b) correspondente a b é um grafo direcionado. Os nodos N(b) do grafo consistem de nodos de entrada – correspondente as variáveis livres do bloco, e os nodos de saída – correspondem aos valores retornados pelo bloco, e os nodos operadores – correspondem aos vários operadores especificados no bloco. As setas E(b) do grafo correspondem ao fluxo de valores no bloco.

A semântica denotacional da SP-TAC é baseada na semântica de Bloss referenciado em [COO 96] e usa os seguintes domínios e funções:

Int (inteiros) E c: Con F Val Bool (booleanos) E k: Pf F Fun Val (valores) E s: SE F Bve F D Fun (funções de primeira ordem) E b: Bo F Bve F Fenv F Dt D (denotable values) E : Exp F Bve F Fenv F Dt Dt (tupla de valores) E p: Prog F Fenv Bve (variáveis de ambiente) Fenv (funções de ambiente)

A estratégia de particionamento global reduz um bloco geral em um conjunto de blocos básicos pelo uso da informação de dependência das funções do bloco geral, a qual é obtida através da interpretação abstrata. Um bloco básico é um bloco onde todos os operadores são operadores primitivos, ou seja, não contém operadores condicionais e chamadas para funções definidas pelo usuário.

Considere o bloco mostrado na figura 4.2. O bloco tem duas entradas, duas saídas e chama a função f. Suponha que a função f não é conhecida, mas é viável particionar o bloco de qualquer maneira. Pode-se converter o bloco em blocos básicos assumindo-se o pior caso, ou seja, desconhecendo o comportamento da função f. Como mostra a figura 4.2(b), desconectou-se o nodo que chamou f. Então, criou-se novas saídas (z, w) e uma nova entrada (c) e usa-se estes nodos no lugar de uma chamada para a função f. Particionando estes blocos básicos une-se os nodos { 3, 4} sobre uma simples partição.

FIGURA 4.2 - Bloco que chama uma função f (a). Bloco básico obtido pela desconexão da chamada de f (b). Parte [u, v] de f (c). Parte [u] (d). Parte G p (e) [COO 96].

Page 32: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

32

O comportamento do bloco particionado é idêntico ao comportamento do bloco geral, apesar das dependências entre as entradas e saídas do bloco.

Supondo-se que a função f é:

def f u v = u + v;

É obvio que f age exatamente como o operador primitivo +, então o bloco pode ser convertido para o bloco básico apresentado na figura 4.2(c). Pode-se então particionar os dois blocos básicos em { 1, 2} e em { 3, 4} . A função f age como um operador primitivo com dois argumentos, o resultado depende de ambos os argumentos, e o resultado está sempre disponível se ambos os argumentos foram fornecidos.

Como se faz uma computação das partes para cada função em uma entrada de um programa? As partes de uma função são derivadas pelo uso de uma semântica não padrão.

Definição 2:

Uma parte é ou um conjunto de variáveis ou um H p. No domínio das partes H p é o menor elemento, ou seja, bottom. Uma parte para uma função I com n argumentos e retornando m resultados é um conjunto de m-tuplas das partes. Uma parte individual [ J 1,...,J k] denota que se a função I toma a parte, o valor correspondente para uma parte dependente em todos J 1,...,J k e é sempre definido se J 1,...,J k são definidos.

Aqui estão os domínios e funções usados na semântica não padrão.

Path (domínio das partes) As: SEK AbveK PS PS (conjunto de partes) Ak: PI K PI un PTS (conjunto de tuplas das partes) Ab: BoK AbveK Aenv K PTS PI un (funções abstratas) A: ExpK AbveK Aenv K PTS Aenv (funções de ambiente) Ap: Pr K Aenv Abve (variáveis de ambiente)

Usa-se p1L p2 para denotar o conjunto da operação de união quando ambos p1 e p2 são conjuntos. Se p1 ou p2 é H p, então p1L p2 é também H p. A semântica das partes (abstrata) é similar a semântica padrão (concreta). A principal diferença está na especificação das equações para operações primitivas e condicionais. Para operadores primitivos, uma união das partes dos argumentos é retornado, refletindo seu comportamento estrito. Para operadores condicionais, ambas as partes são retornadas, tornando incerto em tempo de compilação sobre qual ramo da condição pode ser tomado.

Esta característica possibilita considerar as equações semânticas como um algoritmo e computar as partes para cada função usando estas equações. O algoritmo usa o ponto fixo das iterações para computar partes de funções recursivas. Intuitivamente, isto assume que as partes de uma função são H p para começar e computa as partes da função usando as equações da semântica das partes. Este processo é repetido com a nova parte computada para a função até as partes de todas as funções cheguem a um ponto fixo [COO 96].

Existem duas questões que necessitam ser enfocadas:

Page 33: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

33

M Correção (aproximação): existe uma grande relação entre a semântica padrão (concreta) e a semântica das partes (abstrata). Basicamente, a segurança da semântica das partes garante que uma função sempre torne uma das partes computadas pela semântica das partes; M Computabilidade (representação finita): o algoritmo para a computação das partes mostra término em todas possíveis entradas do programa. Informalmente, isto é garantido pelo fato de uma função ter um número finito de partes.

4.4 Considerações Finais

Este capítulo abordou os aspectos do paradigma funcional. Concluiu-se que o modelo de avaliação paralela proposto por Burn é baseado em uma extensão da lazy evaluation, a qual é conservativa do ponto de vista de qual avaliação é necessária. Isto torna o processo de avaliação paralela conservativo, ou seja, só explora o paralelismo se tem segurança que os resultados serão consistentes, perdendo algumas vezes de explorar todo potencial paralelo do programa. Esta característica também é presente no modelo de particionamento global pois a estratégia de avaliação lenient segue o princípio de avaliar somente quando necessário. No modelo de evaluation transformers a interpretação abstrata tem o papel de prover informações sobre como os avaliadores devem avaliar os argumentos. Isto possibili ta uma previsão de quais avaliações serão necessárias em tempo de execução. A utilização da interpretação abstrata na linguagem SP-TAC auxili a na obtenção de dependências entre as funções de um programa. A partir da informação de dependências o programa pode ser particionado em blocos, onde cada bloco tem potencial para ser executado independentemente dos outros, ou seja, os blocos podem ser executados em paralelo.

Page 34: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

34

5 Conclusão O estudo realizado neste trabalho proporcionou um maior entendimento sobre o mecanismo de interpretação abstrata, em especial, da aplicação desta técnica nos paradigmas declarativos a fim de auxil iar na exploração automática do paralelismo.

A técnica de interpretação abstrata obtém informações em tempo de compilação, através da simulação de um programa. Na paralelização automática, isto possibilita criar um nível de abstração para o programador, deixando este livre dos detalhes da paralelização de programas. Além disso provê informações desprovidas de possíveis erros de implementação. Pelo fato desta técnica gerar informações em tempo de compilação, estas informações são aproximadas. A utili zação de técnicas de análise em runtime são mais precisas, porém causam um overhead adicional ao sistema. Esta questão é muito discutida, no entanto a utili zação da interpretação abstrata garante que as informações serão aproximações seguras, reduzindo a possibili dade de erros. Além disso o fato de ser uma técnica de análise estática libera o sistema do overhead causado pela realização da análise em tempo de execução.

A análise global permite que o poder de abstração da linguagem fique inalterado (linguagem de alto nível), ou seja, a linguagem continua desvinculada dos detalhes da arquitetura.

O fato das linguagens de programação em lógica e funcionais não vincularem seus argumentos com posições de memória facilita a exploração implícita do paralelismo. As linguagens de programação convencionais e orientadas a objetos possuem este vínculo entre variáveis e posição de memória, dificultando a exploração automática do paralelismo.

Na programação em lógica o não-determinismo intrínseco pressupõe uma facili dade na exploração automática do paralelismo. Este aspecto incentiva o desenvolvimento de interpretadores abstratos que obtenham estaticamente informações que auxili em o ambiente de execução a explorar o paralelismo inerente ao programa.

A obtenção das informações de modos é uma questão básica para a exploração do paralelismo implícito na programação em lógica. Pois através desta informação pode-se prever o fluxo de controle de um programa. A informação de dependências proporciona um particionamento eficiente do programa e consequentemente uma execução paralela eficiente.

A informação de tipos proporciona a determinação dos custos de comunicação entre as partes de um programa. Os custos assumem grande importância quando a exploração do paralelismo ocorre em um ambiente de memória distribuída. A importância dos custo deve-se ao fato desta informação auxiliar no processo de escalonamento das partes do programa.

Na programação funcional a utili zação da técnica de interpretação abstrata permite a obtenção de várias características de uma certa aplicação de uma função. Essas características são utili zadas na determinação do comportamento dos avaliadores, ou na determinação das dependências entre as funções de um programa.

O modelo de avaliação paralela proposto por Burn é baseado em uma extensão da lazy evaluation, a qual é conservativa do ponto de vista de qual avaliação é necessária. Isto

Page 35: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

35

torna o processo de avaliação paralela conservativo, ou seja, a exploração do paralelismo somente é realizada quando há segurança que os resultados serão consistentes. Esta característica pode viabili zar uma perda na exploração do potencial paralelo do programa. No particionamento global esta perda também pode ocorrer, pois a estratégia de avaliação lenient também segue o princípio de avaliar somente quando necessário.

A interpretação abstrata na linguagem SP-TAC auxili a na obtenção das dependências entre as funções de um programa. A partir desta informação o programa pode ser particionado em blocos, onde cada bloco tem potencial para ser executado independentemente, ou seja, os blocos podem ser executados em paralelo.

Trabalhos futuros poderão explorar a aplicação de análise global em multiparadigmas, enfocando aspectos relevantes que poderiam ser detectados em tempo de compilação.

Page 36: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

36

Bibliografia [AZE 98] AZEVEDO, S. C., et al. Integração Party – Granlog: Interpretação Abstrata

Aplicada a Paralelização de Programas em Lógica. In: CONGRESO ARGENTINO DE CIENCIAS DE LA COMPUTACIÓN, 4, 1998, Neuquén-AR. Trabajos Seleccionados... Neuquén: Universidad Nacional del Comchue, 1998. V.1 p. 551-560

[AZE 98a] AZEVEDO, S. C. MODA: Um Analisador Estático de Modos e Dependências para Programação em Lógica. Pelotas: Universidade Católica de Pelotas, 1998. 56 p. Projeto de Graduação.

[BAR 96] BARBOSA, J. L. V. GRANLOG: Um Modelo para Análise Automática de Granulosidade na Programação em Lógica. Porto Alegre: GPGCC-UFRGS, 1996. Dissertação de mestrado.

[BAR 98] BARBOSA, J. L. V.; GEYER, C. F. R. Paradigmas de Desenvolvimento de Sistemas Computacionais. Porto Alegre: GPGCC-UFRGS, 1998.

[BLU 94] BLUME, W. et. al., Automatic Detection of Parallelism - A Grand Challenge for High-Performance computing. IEEE Parallel and Distr ibuted technology: Systems and Applications, New York, v.2, n.3, p. 37-47, fall 1994.

[BUE 94] BUENO, F. J. Automatic Optimisation and Parallelisation of Logic Programs through Program Transformation. Madrid: Universidad Poli técnica de Madrid, 1994. PhD Thesis.

[BUR 87] BURN, G. L. Evaluation Transformers – A Model for the Parallel Evaluation of Functional Languages (Extended Abstract). In: FUNCTIONAL PROGRAMMING AND COMPUTER ARCHITECTURE, 1987, Portland, Oregan. Proceedings... Berlin: Springer-Verlog, 1987, p.446-470. (Lecture Notes in Computer Science, v.274).

[BUR 89] BURN, G. L. Deriving a Parallel Evaluation Model for Lazy Functional Languages Using Abstract Interpretation In: BAKKER, J. W. Languages for Parallel Architectures: design, semantic, implementation models. [S. l.: s. n.], 1989. p.111-165.

[CAS 96] CASTRO, L. F. P. Interpretação Abstrata e sua Aplicação na Programação em Lógica. Porto Alegre: CPGCC-UFRGS, 1996.

[CAS 97] CASTRO, L. F. P. Um Modelo de Analisador Estático Baseado na Interpretação Abstrata Direcionado à Paralelização de Programas em Lógica. Porto Alegre: CPGCC-UFRGS, 1997. Dissertação de Mestrado.

[CAS 97a] CASTRO, L.F.; GEYER, F. R. ParTy – A Parallel – Types Analyzer . 1997. (disponível via www em http://www.inf.ufrgs.br/procpar/opera/papers/wpitclpl.ps.gz)

Page 37: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

37

[CHA 85] CHANG, J.; DESPAIN, A. Semi-Intelli gent Backtraking of Prolog Based on Static Data dependency Analysis. In: INTERNATIONAL SYMPOSIUM ON LOGIC PROGRAMMING, 1985, [S.l.] Proceedings... [S.l.] IEEE Computer Society, 1985.

[CHA 85a] CHANG, J.; DESPAIN, A.; DEGROOT, D. AND-Parallelism of Logic Programs based on a Static Data Dependency Analysis. Compcon’85, 1985.

[COO 96] COORG, S. R. Partitioning Non-str ict Functional Languages for Multi-threaded Code Generation. Cambridge: [s.n.], 1996.

[COR 97] CORTESI et al. Complementation in Abstract Interpretation. ACM Transactions on Programming Languages and Systems, New York, v.19, n.1, p.7-47, 1997.

[DAM 97] DAMS, D.; GERTH, R. Abstract Interpretation of Reactives Systems. ACM Transactions on Programming Languages and Systems, New York, v. 19, n. 2, p.253-291, 1997.

[DAV 92] DAVIE, A. J. T. An Introduction to Functional Programming Systems Using Haskell . Cambridge: Cambridge University, 1992, 290 p.

[DEB 89] DEBRAY, S. K. Static Inference of Modes and Data Dependencies in Logic Programs. ACM Transaction on Programming Languages and Systems, New York, v.11, n. 3, p.418-450, 1989.

[DUB 98] DU BOIS, A. R. Um Estudo sobre Programação Funcional e a L inguagem Haskell , com Desenvolvimento de Exemplos Ilustrativos. Pelotas: Universidade Católica de Pelotas, 1998. 140 p. Projeto de Graduação.

[HAN 94] HANUS, M. The Integration of Functions into Logic Programming from Theory to Pratice. Journal of Logic Progamming, New York, v.19/20, p.583-628, May/July 1994.

[HER 86] HERMENEGILDO, M. An Abstact Machine Based Execution Model for Computer Architecture Designe and Eff icient Implementation on Logic Programs in Parallel. Austin: University of texas, 1986. PhD Thesis

[LAB 92] LA BANDA, M. G. Implementación de un Intérprete Abstracto de Programas Prolog sobre el Dominio Shar ing + Freeness. Madrid: Universidad Politecnica de Madrid, 1992. Trabajo Fin de Carreira.

[LAB 95] LA BANDA, M. J. G. Independence, Global Analysis, and Parallelism in Dynamically Scheduled Constraint Logic Programming. Madrid: Universidad Politécnica de Madrid, 1995. PhD Thesis

[LAB 96] LA BANDA, M. et al. Global Analysis of Constraint Logic Programming. ACM Transactions on Programming Languages and Systems, New York, v.18, n.5, p.564-614, 1996.

Page 38: Estudo da Interpretação Abstrata como Auxílio à Exploração ... · automática do paralelismo é o alto nível destes paradigmas. As linguagens em lógica e As linguagens em

38

[LIN 93] LIN, N. Automatic Complexity Analysis of Logic Programs. [S.l.]: University of Arizona, 1993. PhD Thesis

[STE 94] STERLING, L.; SHAPIRO, E. The Ar t of Prolog: Advanced Programing Tecniques. 2. Ed. Cambridge: MIT Press, 1994.

[WAR 77] WARREN, D. Implementing Prolog – Compiling Predicate Logic programs. Edinburgh: University of Emdiburgh, 1977. Research Report.