Avaliação Parcial em Máquinas de Estado Abstratas

Avalia¸c˜ao Parcial em

M´aquinas de Estado Abstratas

Disserta¸c˜ ao apresentada ao Curso de P´ os- Gradua¸c˜ ao em Ciˆ encia da Computa¸c˜ ao da Universidade Federal de Minas Gerais, como requisito parcial para a obten¸c˜ ao do grau de Doutor em Ciˆ encia da Computa¸c˜ ao.

Belo Horizonte

28 de mar¸co de 2001

Gostaria de agradecer ao Professor Roberto da Silva Bigonha, entre outras coisas, por sua orienta¸c˜ ao e por oferecer um excelente ambiente de trabalho.

Agrade¸co ` a CAPES, ao Departamento de Inform´ atica da Universidade Federal de Vi¸cosa e ao Departamento de Ciˆ encia da Computa¸c˜ ao da Universidade Federal de Minas Gerais, cujo apoio foi fundamental para a condu¸c˜ ao da pesquisa.

Agrade¸co ` a Professora Mariza Andrade da Silva Bigonha, cujas sugest˜ oes enriqueceram o trabalho de pesquisa. Agrade¸co tamb´ em aos demais membros da banca examinadora, Professores Carlos Camar˜ ao de Figueiredo, Hermano Perrelli de Moura, Jos´ e Lucas Mour˜ ao Rangel Netto e Roberto Ierusalimschy. Ao Professor Neil Jones, agrade¸co a aten¸c˜ ao dedi- cada no per´ıodo que visitei a Universidade de Copenhagen.

Aos colegas do Laborat´ orio de Linguagens de Programa¸c˜ ao, agrade¸co o apoio, amizade e a agrad´ avel convivˆ encia: Fabio Tirelo, Elaine Gouveia Pimentel, Marcelo de Almeida Maia, Marcelo Luiz Silva, Marco T´ ulio Oliveira Valente, Patricia Costa, Marco Rodrigo Costa, Marcos Gon¸calves Rios, Fl´ avia Peligrinelli Ribeiro, Fernando Magno Quint˜ ao Pe- reira. Agrade¸co tamb´ em a amizade de Genicio Zanetti e Carlos Jos´ e Gomes da Rocha.

Agrade¸co especialmente a Anderson Luiz Ca¸cador, que foi quem mais suportou meu mau humor, depress˜ ao e brincadeiras durante os quatro anos do curso.

Finalmente, agrade¸co o apoio dado por meus pais, Albino Jos´ e Di Iorio e Maria Jos´ e

Oliveira Di Iorio, que sempre me incentivaram a estudar e a me tornar uma pessoa melhor.

Avalia¸c˜ ao Parcial ´ e uma t´ ecnica de especializa¸c˜ ao de programas. Se um programa tem duas ou mais entradas, o resultado da avalia¸c˜ ao parcial do mesmo em rela¸c˜ ao ` a primeira entrada

´ e um novo programa, designado residual ou especializado. Quando o programa residual ´ e executado sobre o restante das entradas, produz a mesma sa´ıda que o programa original, se executado sobre a entrada completa. O objetivo principal da avalia¸c˜ ao parcial ´ e o ganho em eficiˆ encia. Se parte da entrada ´ e conhecida, toda informa¸c˜ ao que depende apenas dela pode ser previamente computada, podendo gerar de forma totalmente autom´ atica um programa especializado mais eficiente que o original.

Uma aplica¸c˜ ao importante de avalia¸c˜ ao parcial ´ e a gera¸c˜ ao autom´ atica de compiladores dirigida por semˆ antica. A partir de um interpretador de uma linguagem de programa¸c˜ ao, ´ e poss´ıvel produzir automaticamente um compilador. As t´ ecnicas de avalia¸c˜ ao parcial podem ser usadas ainda na constru¸c˜ ao de um gerador de compiladores.

As M´ aquinas de Estado Abstratas (ASM, do inglˆ es Abstract State Machines ) s˜ ao um formalismo criado por Yuri Gurevich, anteriormente conhecido por Evolving Algebras. ´ E utilizado na descri¸c˜ ao da semˆ antica de linguagens de programa¸c˜ ao, arquiteturas de sis- temas, protocolos distribu´ıdos etc. Usando esse modelo, uma forma de se especificar a semˆ antica de uma linguagem de programa¸c˜ ao ´ e escrever um interpretador para essa lin- guagem. O interpretador recebe um programa da linguagem e seus dados de entrada, e simula a execu¸c˜ ao do programa sobre esses dados.

Neste trabalho, aplicamos as t´ ecnicas de avalia¸c˜ ao parcial ao formalismo das M´ aquinas de Estado Abstratas. Como a maioria dos modelos para descri¸c˜ ao de semˆ antica, ASM sofre com implementa¸c˜ oes ineficientes. O nosso objetivo ´ e produzir automaticamente espe- cifica¸c˜ oes ASM especializadas e obter um ganho em eficiˆ encia que torne o uso desse modelo mais atraente. Como uma das principais aplica¸c˜ oes de ASM ´ e a descri¸c˜ ao da semˆ antica de linguagens de programa¸c˜ ao, a maioria dos experimentos conduzidos est´ a relacionada ` a gera¸c˜ ao de compiladores dirigida por semˆ antica.

O trabalho pode ser dividido em duas fases principais. Na primeira fase, desenvolve- mos t´ ecnicas para a constru¸c˜ ao de um avaliador parcial para a linguagem das M´ aquinas de Estado Abstratas. Produzimos uma especifica¸c˜ ao desse avaliador parcial usando o pr´ oprio modelo ASM e demonstramos importantes propriedades sobre seu funcionamento, mostrando a facilidade que esse formalismo oferece para constru¸c˜ ao de especifica¸c˜ oes e demonstra¸c˜ oes. Encontramos dificuldades, que consideramos inerentes ao modelo ASM, para a produ¸c˜ ao de um gerador de compiladores por meio da auto-aplica¸c˜ ao do avaliador parcial.

Na segunda fase do trabalho, utilizamos uma t´ ecnica conhecida como extens˜ oes de

gera¸c˜ ao. Essa abordagem consiste em construir ` a m˜ ao um gerador de compiladores usando

t´ ecnicas de avalia¸c˜ ao parcial, evitando os problemas associados ` a auto-aplica¸c˜ ao de um

avaliador parcial tradicional. Conduzimos experimentos com gera¸c˜ ao autom´ atica de com-

piladores, usando descri¸c˜ oes da semˆ antica de linguagens escritas em ASM.

Partial Evaluation is a technique for program specialization. Let P be a program with two or more input data. Partially evaluating P with respect to the first input data generates a residual or specialized program. Running the residual program over the remaining input data will yield the same result as running P over all input data. The main goal of partial evaluation is to generate efficient programs from general ones by completely automatic methods.

Semantics based compiler generation is an important application of partial evaluation.

A compiler can be automatically produced from an interpreter definition. The techniques can also be used to build a compiler generator.

Abstract State Machines are a formalism created by Yuri Gurevich, previously known as Evolving Algebras. It has been successfully used to describe the semantics of programming languages, architectures, distributed protocols etc. In ASM, the semantics of a program- ming language is usually given by an interpreter for the language. The interpreter simulates the execution of a program over its input data.

Our work involves partial evaluation and Abstract State Machines. A typical problem of most formalisms to describe semantics of programs, including ASM, is an inefficient implementation. Our goal is to automatically generate specialized ASM specifications, that are more efficient than the original ones. We hope that this will make ASM available even for applications which require more efficient implementations. The specification of the semantics of programming languages is an important application of ASM. So most experiments developed in our work are related to semantics based compiler generation.

Our work can be divided in two separate phases. In the first phase, techniques for buil- ding a partial evaluator for ASM have been developed. We have written a specification of this partial evaluator using the ASM language itself. We have proven important properties related to the partial evaluator, showing that ASM is suitable to describe algorithms in a clear way and to prove properties of these algorithms. We have had difficulties to au- tomatically produce a compiler generator by self-application of the partial evaluator. We consider that these difficulties are inherent to the ASM model.

In the second phase of the work, we have used the generating extension approach. This

approach consists in hand writing a compiler generator using partial evaluation techniques,

avoiding the problems related to self-application of a traditional partial evaluator. We have

carried out experiments involving automatic compiler generation, using descriptions of the

semantics of programming languages written in ASM.

Sum´ ario

Lista de Figuras v

Lista de Tabelas vii

1 Introdu¸ c˜ ao 1

1.1 M´ aq uinas de Estado Abstratas . . . . 1

1.2 Avalia¸c˜ ao Parcial de Programas . . . . 1

1.3 Geradores de Compiladores . . . . 3

1.4 Objetivos e Resultados Alcan¸cados . . . . 3

1.4.1 Avaliador Parcial para ASM . . . . 4

1.4.2 Extens˜ oes de Gera¸c˜ ao para ASM . . . . 5

1.5 Organiza¸c˜ ao do Documento . . . . 6

2 M´ aquinas de Estado Abstratas 8 2.1 Introdu¸c˜ ao ao Modelo ASM . . . . 9

2.2 Exemplos . . . . 12

2.3 O Modelo Formal de ASM . . . . 15

2.3.1 Defini¸c˜ ao da M´ aq uina . . . . 15

2.3.2 Regras N˜ ao-B´ asicas . . . . 19

2.4 Conclus˜ oes . . . . 20

3 Avalia¸ c˜ ao Parcial 22 3.1 Introdu¸c˜ ao . . . . 22

3.2 Aplica¸c˜ oes de Avalia¸c˜ ao Parcial . . . . 24

3.2.1 Engenharia de Software . . . . 25

3.2.2 Parˆ ametros com Freq¨ uˆ encias de Varia¸c˜ ao Diferentes . . . . 25

3.2.3 Problemas de Natureza Interpretativa . . . . 26

3.2.4 Compila¸c˜ ao e Gera¸c˜ ao de Compiladores . . . . 26

3.3 T´ ecnicas de Avalia¸c˜ ao Parcial . . . . 27

3.3.1 Linguagem de Fluxograma FCL . . . . 27

3.3.2 Especializa¸c˜ ao Polivariante . . . . 29

3.3.3 M´ etodos Online . . . . 30

3.3.4 M´ etodos Offline . . . . 38

3.3.5 Compara¸c˜ ao Entre M´ etodos Online e Offline . . . . 44

3.3.6 T´ opicos mais Avan¸cados de M´ etodos Offline . . . . 45

3.4 Exemplos . . . . 47

3.4.1 Casamento de Padr˜ oes . . . . 47

3.4.2 Casamento de Padr˜ oes - Segunda Vers˜ ao . . . . 50

3.4.3 Interpretador para M´ aq uina de Turing . . . . 54

3.5 Gera¸c˜ ao de Geradores de Programas . . . . 59

3.5.1 Compila¸c˜ ao e Gera¸c˜ ao de Compiladores . . . . 60

3.5.2 Extens˜ oes de Gera¸c˜ ao . . . . 61

3.6 Leitura Adicional . . . . 64

3.7 Conclus˜ oes . . . . 65

4 Avalia¸ c˜ ao Parcial para ASM 67 4.1 Linguagem Processada . . . . 67

4.2 Pr´ e-Processamento . . . . 68

4.3 An´ alise de Tempo de Defini¸c˜ ao . . . . 68

4.4 Especializa¸c˜ ao . . . . 69

4.4.1 Exemplo . . . . 70

4.4.2 Otimiza¸c˜ oes . . . . 72

4.5 Teste do Meta-Interpretador . . . . 72

4.6 Gera¸c˜ ao de Compiladores . . . . 73

4.7 Conclus˜ ao . . . . 74

5 Implementa¸ c˜ ao de um Avaliador Parcial em ASM 76 5.1 Representa¸c˜ ao de Especifica¸c˜ oes . . . . 76

5.1.1 Especifica¸c˜ oes ASM de Entrada . . . . 77

5.1.2 Especifica¸c˜ oes Anotadas . . . . 77

5.1.3 Especifica¸c˜ oes Residuais . . . . 78

5.2 Pr´ e-Processamento . . . . 79

5.3 An´ alise de Tempo de Defini¸c˜ ao . . . . 79

5.3.1 Computando uma Divis˜ ao BTA . . . . 79

5.3.2 Gerando uma Especifica¸c˜ ao Anotada . . . . 81

5.4 Especializa¸c˜ ao . . . . 82

5.4.1 Representa¸c˜ ao de Estados . . . . 82

5.4.2 Algoritmo para Especializa¸c˜ ao . . . . 85

5.4.3 Processando Blocos . . . . 86

5.4.4 Processando Regras de Atualiza¸c˜ ao . . . . 87

5.4.5 Processando Regras Condicionais . . . . 87

5.4.6 Gera¸c˜ ao de Novos Estados Positivos . . . . 88

5.4.7 A Regra de Transi¸c˜ ao Residual . . . . 90

5.5 Auto-Aplica¸c˜ ao e Gera¸c˜ ao de Compiladores . . . . 90

5.6 Conclus˜ ao . . . . 92

6 Propriedades Importantes do Avaliador Parcial 94 6.1 Pr´ e-Processamento . . . . 94

6.1.1 Termina¸c˜ ao do Pr´ e-Processamento . . . . 95

6.1.2 Manuten¸c˜ ao da Semˆ antica Original . . . . 96

6.2 An´ alise de Tempo de Defini¸c˜ ao . . . . 98

6.2.1 Termina¸c˜ ao da BTA . . . . 98

6.2.2 Produ¸c˜ ao de uma Divis˜ ao Congruente . . . 101

6.3 Especializa¸c˜ ao . . . 107

6.3.1 Crit´ erio de Corre¸c˜ ao para a Especializa¸c˜ ao . . . 107

6.3.2 Construindo a Especifica¸c˜ ao Residual . . . 109

6.3.3 Corre¸c˜ ao do Algoritmo de Especializa¸c˜ ao . . . 110

6.3.4 Termina¸c˜ ao do Algoritmo de Especializa¸c˜ ao . . . 116

6.4 Conclus˜ oes . . . 117

7 Extens˜ oes de Gera¸ c˜ ao para ASM 118 7.1 Extens˜ oes de Gera¸c˜ ao . . . 118

7.1.1 Defini¸c˜ ao Eq uacional . . . 119

7.1.2 Avalia¸c˜ ao Parcial Versus Extens˜ oes de Gera¸c˜ ao . . . 120

7.1.3 Dificuldades com Auto-Aplica¸c˜ ao de mix . . . 121

7.2 A Linguagem Xasm . . . 122

7.2.1 Caracter´ısticas Importantes . . . 122

7.2.2 Xasm e Cogen . . . 122

7.2.3 Um Interpretador escrito em Xasm . . . 123

7.3 Cogen para ASM . . . 123

7.3.1 Representa¸c˜ ao de Especifica¸c˜ oes . . . 125

7.3.2 Pr´ e-Processamento e BTA . . . 126

7.3.3 Representa¸c˜ ao Abstrata da Extens˜ ao de Gera¸c˜ ao . . . 127

7.3.4 Uso de uma Linguagem ASM Concreta . . . 129

7.4 Experimentos com Cogen e Xasm . . . 131

7.4.1 Compilador para M´ aq uina de Turing . . . 132

7.4.2 Compilador para um Subconjunto da Linguagem C . . . 133

7.5 Conclus˜ ao . . . 136

8Conclus˜ oes 139 8.1 O Trabalho de Pesq uisa Desenvolvido . . . 139

8.2 Avalia¸c˜ ao Parcial e ASM . . . 141

8.3 Extens˜ oes de Gera¸c˜ ao para ASM . . . 142

8.4 Resumo das Contribui¸c˜ oes da Pesq uisa . . . 143

8.5 Trabalhos Futuros . . . 144

Referˆ encias Bibliogr´ aficas 146

Lista de Figuras

2.1 Interpreta¸c˜ ao do nome de fun¸c˜ ao f. . . . 11

3.1 Fun¸c˜ ao Power(n,x) = x ⁿ . . . . 23

3.2 Codifica¸c˜ ao em FCL da fun¸c˜ ao Power. . . . . 28

3.3 A execu¸c˜ ao da fun¸c˜ ao Power com n = 2 e x = 5. . . . 28

3.4 Esquema de uso das t´ ecnicas online. . . . 30

3.5 MIX - Algoritmo para Especializa¸c˜ ao de Programas. . . . 35

3.6 M´ etodo Online para Especializa¸c˜ ao de Comandos FCL. . . . 37

3.7 Esquema de uso das t´ ecnicas offline. . . . . 38

3.8 Programa Anotado. . . . 40

3.9 M´ etodo Offline para Especializa¸c˜ ao de Comandos FCL. . . . 43

4.1 Exemplo de especializa¸c˜ ao do interpretador de MT. . . . 71

4.2 Exemplo com compress˜ ao de transi¸c˜ oes. . . . 71

5.1 Exemplo de uso da tabela gencode. . . . 78

5.2 Pr´ e-processamento. . . . 79

5.3 Regras para computar uma divis˜ ao BTA. . . . 80

5.4 Macro ProcessBTA(x), se x ´ e um bloco ou regra condicional. . . . 80

5.5 Macro ProcessBTA(x), se x ´ e uma regra de atualiza¸c˜ ao. . . . . 80

5.6 Macro ProcessBTA(x), se x ´ e um termo. . . . 81

5.7 Fun¸c˜ ao gentr. . . . 82

5.8 Fun¸c˜ ao gentt. . . . 83

5.9 Fun¸c˜ ao Reduce. . . . 84

5.10 SPECRULES: Regras para Especializa¸c˜ ao. . . . 85

5.11 Regra ProcessRule(x), para blocos de regras anotadas. . . . . 86

5.12 ProcessUpdate(r,cn,rest ,updates). . . . 87

5.13 Regra ProcessRule(x), para regras condicionais anotadas. . . . 88

5.14 Algoritmo de especializa¸c˜ ao revisitado, incluindo gera¸c˜ ao de novos estados positivos. . . . . 89

6.1 Fun¸c˜ ao progToN. . . . 98

6.2 Fun¸c˜ ao f1. . . 109

6.3 Fun¸c˜ ao f2. . . 110

7.1 Esquema de Uso de um Gerador de Extens˜ oes de Gera¸c˜ ao. . . 119

7.2 Interpretador para MT escrito em Xasm. . . 124

7.3 Fun¸c˜ ao downdyn. . . 127

7.4 Representa¸c˜ ao Abstrata em uma Extens˜ ao de Gera¸c˜ ao. . . 128

7.5 Fun¸c˜ ao sds. . . 129

7.6 Declara¸c˜ oes de Fun¸c˜ oes no Compilador de MT para Xasm. . . 132

7.7 Trecho de C´ odigo do Compilador de MT para Xasm. . . 133

7.8 Programa P ₁ . . . 136

7.9 Programa P ₂ . . . 137

Lista de Tabelas

7.1 Testes com o Interpretador de C. . . 135

7.2 Testes com o Compilador de C para Xasm. . . 135

Cap´ıtulo 1 Introdu¸ c˜ ao

O trabalho desenvolvido envolve os conceitos de M´ aquinas de Estado Abstratas e Avalia-

¸c˜ ao Parcial de Programas. Este cap´ıtulo apresenta uma defini¸c˜ ao sucinta desses conceitos, juntamente com uma r´ apida introdu¸c˜ ao ` a gera¸c˜ ao autom´ atica de compiladores, que ´ e uma das principais aplica¸c˜ oes de avalia¸c˜ ao parcial de programas. Os objetivos e resultados alcan¸cados pela pesquisa s˜ ao tamb´ em discutidos neste cap´ıtulo. Abordagens detalhadas de M´ aquinas de Estado Abstratas e Avalia¸c˜ ao Parcial de Programas podem ser encontradas nos cap´ıtulos 2 e 3, respectivamente.

1.1 M´ aquinas de Estado Abstratas

As M´ aquinas de Estado Abstratas (ASM, do inglˆ es Abstract State Machines) s˜ ao um formalismo criado por Yuri Gurevich [40], originalmente conhecido por Evolving Algebras.

E utilizado na descri¸c˜ ´ ao de arquiteturas de sistemas [15, 16, 19], linguagens de programa¸c˜ ao [20, 21, 22, 42, 84], sistemas distribu´ıdos [7, 8, 17, 44] e de tempo real [35, 45], entre outros [18].

Usando esse formalismo, uma forma de se especificar a semˆ antica de uma linguagem de programa¸c˜ ao L ´ e escrever um interpretador para programas escritos em L. O interpretador recebe um programa S, escrito em L, e seus dados de entrada x, simulando a execu¸c˜ ao de S sobre x.

As M´ aquinas de Estado Abstratas constituem um formalismo poderoso o bastante para especificar de maneira simples algoritmos envolvendo processamento paralelo e distribu´ıdo.

Entretanto, nosso principal objetivo envolve sua utiliza¸c˜ ao na especifica¸c˜ ao da semˆ antica de linguagens de programa¸c˜ ao seq¨ uenciais. Assim, todo o trabalho se concentra em um subconjunto do modelo designado ASM Seq¨ uencial [40].

1.2 Avalia¸ c˜ ao Parcial de Programas

Dado um programa P com entradas in ₁ e in ₂ , a avalia¸c˜ ao parcial de P em rela¸c˜ ao

a in ₁ ´ e um novo programa P _in

que recebe apenas uma entrada in ₂ e produz os mesmos

resultados que P , se lhe fossem fornecidos in ₁ e in ₂ [55]. Avalia¸c˜ ao parcial ´ e um tipo de especializa¸c˜ ao de programas. O programa P _in

´ e designado programa especializado ou residual. As entradas in ₁ e in ₂ s˜ ao designadas, respectivamente, est´ atica e dinˆ amica.

Um avaliador parcial para uma linguagem L ´ e um programa que executa avalia¸c˜ ao parcial sobre programas escritos em L, produzindo como resultado programas especia- lizados que s˜ ao escritos, geralmente, na mesma linguagem L. O avaliador parcial realiza uma mistura de execu¸c˜ ao com gera¸c˜ ao de c´ odigo, motivo pelo qual o processo foi designado

“mixed computation”, e o avaliador comumente chamado de mix [32].

Suponha dispon´ıvel um avaliador parcial mix para uma linguagem L . Suponha tamb´ em que Int seja um interpretador de uma linguagem L, escrito em L , que recebe um programa S (escrito em L) e seus dados de entrada x. A avalia¸c˜ ao parcial de Int, dado S (est´ atico), resulta em um programa S , geralmente escrito em L , que recebe x e produz a mesma sa´ıda de S. Ou seja, S ´ e o resultado da compila¸c˜ ao de S para a linguagem L . A avalia¸c˜ ao parcial do pr´ oprio mix, dado como entrada est´ atica um interpretador Int de L, resulta em um compilador de L para L . Finalmente, a avalia¸c˜ ao parcial de mix dado como entrada est´ atica o pr´ oprio mix resulta em um gerador de compiladores, comumente chamado de cogen. Na realidade, cogen ´ e um programa mais geral do que um gerador de compiladores.

Se for aplicado a um interpretador, cogen produz um compilador. A aplica¸c˜ ao de cogen a um programa P qualquer produz o que se convencionou chamar de extens˜ ao de gera¸c˜ ao (g enerating extension) para P [70].

A possibilidade da realiza¸c˜ ao dos procedimentos descritos acima foi descoberta por Fu- tamura [33] no in´ıcio da d´ ecada de 70, mas s´ o foram realizados com sucesso pela primeira vez em meados dos anos 80 [57]. As equa¸c˜ oes que descrevem esses processos passaram a ser conhecidas como as Trˆ es Proje¸c˜ oes de Futamura. A primeira proje¸c˜ ao est´ a relacio- nada ` a compila¸c˜ ao por meio de avalia¸c˜ ao parcial, a segunda proje¸c˜ ao est´ a relacionada ` a gera¸c˜ ao de compiladores e a terceira proje¸c˜ ao de Futamura demonstra como um gerador de compiladores pode ser constru´ıdo usando um avaliador parcial.

Uma alternativa para avalia¸c˜ ao parcial ´ e a abordagem de extens˜ oes de gera¸c˜ ao [70].

Essa abordagem consiste em escrever ` a m˜ ao o programa cogen, que pode ser gerado au- tomaticamente por meio da auto-aplica¸c˜ ao de um avaliador parcial. O programa cogen ´ e denominado ent˜ ao gerador de extens˜ oes de gera¸c˜ ao. Se aplicado a um programa P com duas entradas, ´ e produzido um novo programa P _gen , designado extens˜ ao de gera¸c˜ ao para P . Se for fornecida a P _gen a primeira entrada in ₁ de P , ´ e produzido um programa P _in

, q ue

´ e a especializa¸c˜ ao de P em rela¸c˜ ao ` a sua primeira entrada. Em suma, um gerador de ex- tens˜ oes de gera¸c˜ ao produz avaliadores parciais espec´ıficos para um determinado programa.

A constru¸c˜ ao de um gerador de extens˜ oes de gera¸c˜ ao ´ e geralmente mais complicada que a constru¸c˜ ao de um avaliador parcial tradicional, se n˜ ao forem considerados problemas rela- cionados ` a auto-aplica¸c˜ ao. Por outro lado, um compilador ´ e gerado automaticamente pela aplica¸c˜ ao de um gerador de extens˜ oes de gera¸c˜ ao a um interpretador, sem a necessidade da auto-aplica¸c˜ ao de um avaliador parcial, como discutido acima.

Avaliadores parciais foram constru´ıdos com sucesso para linguagens de paradigma im-

perativo [2, 3, 66], funcional [54, 60, 11, 68] e l´ ogico [46, 78, 69]. Embora as t´ ecnicas

utilizadas sejam semelhantes, cada paradigma e at´ e mesmo cada linguagem possui carac-

ter´ısticas especiais que necessitam de adapta¸c˜ oes espec´ıficas. Cada constru¸c˜ ao especial de

uma linguagem pode demandar a adapta¸c˜ ao ou cria¸c˜ ao de novas t´ ecnicas de avalia¸c˜ ao par- cial. O mesmo ´ e v´ alido para a abordagem de extens˜ oes de gera¸c˜ ao. O uso dessa abordagem

´ e mais recente, sendo aplicada com sucesso principalmente em linguagens estaticamente tipadas [50, 12, 13, 80].

1.3 Geradores de Compiladores

Ferramentas como geradores de analisadores sint´ aticos e avaliadores de gram´ aticas de atributos s˜ ao muito utilizadas para gera¸c˜ ao de compiladores. Nessas ferramentas, o usu´ ario fica totalmente respons´ avel por garantir a consistˆ encia do c´ odigo gerado quanto ` a semˆ antica da linguagem compilada. Geradores autom´ aticos dirigidos por semˆ antica evitam esse pro- blema. Se for estabelecida uma prova formal da corre¸c˜ ao do gerador, os compiladores produzidos ser˜ ao tamb´ em automaticamente corretos em rela¸c˜ ao ` a semˆ antica da linguagem descrita.

Os primeiros geradores de compiladores dirigidos por semˆ antica se baseavam em se- mˆ antica denotacional, como o de Mosses [71], Jones e Schmidt [56], os sistemas CERES [83] e Script [10]. O modelo, embora bastante elegante, levava ` a obten¸c˜ ao de compiladores extremamente ineficientes, mesmo com testes simples. Alguns trabalhos, ainda adotando a semˆ antica denotacional, procuraram melhorar a eficiˆ encia dos compiladores gerados [38, 76, 64, 65]. Resultados expressivos foram conseguidos usando-se semˆ antica de a¸c˜ oes, como em [75].

A compila¸c˜ ao e a gera¸c˜ ao de compiladores usando avalia¸c˜ ao parcial foram realizadas com sucesso em diversos experimentos. A maioria dos experimentos de sucesso usava uma linguagem funcional de avalia¸c˜ ao estrita como linguagem objeto. Kahn e Carlsson realizaram a compila¸c˜ ao de programas Prolog para Lisp, por meio da avalia¸c˜ ao parcial de um interpretador de Prolog escrito em Lisp [62]. Consel e Khoo geraram um compilador de Prolog para Scheme, por meio da aplica¸c˜ ao da Segunda Proje¸c˜ ao de Futamura [24].

Jorgensen gerou um compilador de um subconjunto de Miranda para Scheme com eficiˆ encia compar´ avel a compiladores escritos ` a m˜ ao [60, 61].

1.4 Objetivos e Resultados Alcan¸ cados

Acreditamos que as M´ aquinas de Estado Abstratas constituam um formalismo ade- quado para se descrever a semˆ antica de linguagens de programa¸c˜ ao e de outros sistemas.

O objetivo principal do nosso trabalho de pesquisa foi o desenvolvimento de t´ ecnicas de avalia¸c˜ ao parcial adequadas ao modelo ASM, possibilitando a gera¸c˜ ao autom´ atica de espe- cifica¸c˜ oes mais eficientes.

Quando as especifica¸c˜ oes s˜ ao interpretadores de linguagens de programa¸c˜ ao, tem-se

descri¸c˜ oes da semˆ antica dessas linguagens. Usando t´ ecnicas de avalia¸c˜ ao parcial, pode-se

produzir automaticamente compiladores para essas linguagens, ou seja, gera¸c˜ ao de compi-

ladores dirigida por semˆ antica. Como uma das principais aplica¸c˜ oes de ASM ´ e a descri¸c˜ ao

da semˆ antica de linguagens de programa¸c˜ ao, o trabalho teve uma ˆ enfase maior na aplica¸c˜ ao

de avalia¸c˜ ao parcial para gera¸c˜ ao autom´ atica de compiladores.

Foram desenvolvidas t´ ecnicas e ferramentas para aplicar a teoria de avalia¸c˜ ao parcial sobre a linguagem das M´ aquinas de Estado Abstratas. Entre as caracter´ısticas especiais da linguagem, que demandam adapta¸c˜ oes das t´ ecnicas de avalia¸c˜ ao parcial, est˜ ao a execu¸c˜ ao paralela de comandos e a atualiza¸c˜ ao de fun¸c˜ oes.

O trabalho desenvolvido pode ser dividido em duas partes principais. A primeira parte compreendeu o desenvolvimento de t´ ecnicas para implementar um avaliador parcial mix para a linguagem das M´ aquinas de Estado Abstratas. Problemas com a auto-aplica¸c˜ ao foram encontrados. Foram demonstradas formalmente propriedades importantes do avali- ador parcial e dos programas por ele produzidos. Na segunda parte do trabalho, os esfor¸cos foram concentrados no desenvolvimento de um gerador de extens˜ oes de gera¸c˜ ao para ASM.

Nessa segunda etapa, resultados pr´ aticos na gera¸c˜ ao de compiladores foram obtidos com mais facilidade.

1.4.1 Avaliador Parcial para ASM

Nesta se¸c˜ ao, vamos apresentar uma introdu¸c˜ ao ` a primeira parte do trabalho, cujo re- sultado principal foi o desenvolvimento de um avaliador parcial mix para a linguagem das M´ aquinas de Estado Abstratas. Uma abordagem mais detalhada pode ser encontrada nos cap´ıtulos 4 e 5.

Qualquer linguagem de programa¸c˜ ao pode ser utilizada para implementar o avaliador parcial mix para ASM. No nosso caso, a implementa¸c˜ ao foi conduzida em Java. O avaliador parcial recebe como entrada uma especifica¸c˜ ao escrita em ASM e parte da sua entrada, produzindo uma especifica¸c˜ ao especializada.

O avaliador parcial pode ser aplicado a interpretadores de linguagens de programa¸c˜ ao escritos em ASM, tendo como entrada est´ atica um programa da linguagem interpretada.

Como explicado anteriormente, esses interpretadores podem ser vistos como a descri¸c˜ ao da semˆ antica de linguagens em ASM. O resultado da avalia¸c˜ ao parcial ´ e um programa compilado, sendo assim ´ e realizada uma compila¸c˜ ao dirigida por semˆ antica.

Foi tamb´ em implementada uma vers˜ ao de mix escrita na pr´ opria linguagem ASM. Isso nos permite a auto-aplica¸c˜ ao, ou seja, avaliar parcialmente o pr´ oprio mix. Se o interpre- tador de uma linguagem L for fornecido como entrada est´ atica, pode-se produzir automa- ticamente um compilador de L para ASM, ou seja, gera¸c˜ ao de compiladores dirigida por semˆ antica. Um avaliador parcial para ASM foi apresentado por Huggins e Gurevich em [43], mas n˜ ao permitia a auto-aplica¸c˜ ao e conseq¨ uentemente n˜ ao possibilitava a gera¸c˜ ao de compiladores.

Usando a vers˜ ao do avaliador parcial para ASM implementada em Java, foram con- duzidos testes que envolveram sua aplica¸c˜ ao sobre algumas descri¸c˜ oes de semˆ antica de linguagens, como por exemplo, um subconjunto de C. O resultado, seguindo a Primeira Proje¸c˜ ao de Futamura, foi a compila¸c˜ ao de programas escritos nessas linguagens para a linguagem das M´ aquinas de Estado Abstratas. Nessa vers˜ ao, a linguagem dos programas ASM fornecidos como entrada ´ e n˜ ao tipada.

Como explicado anteriormente, foi tamb´ em desenvolvida uma segunda vers˜ ao do ava-

liador parcial, escrita na pr´ opria linguagem ASM dinamicamente tipada. Esse avaliador,

que foi designado mix _ASM , pode servir de entrada para o primeiro avaliador parcial escrito em Java. Essa “auto-aplica¸c˜ ao”, de acordo com a Segunda Proje¸c˜ ao de Futamura, produz um compilador a partir da especializa¸c˜ ao de um avaliador parcial em rela¸c˜ ao a um inter- pretador. Entretanto, mix _ASM carece de v´ arias otimiza¸c˜ oes, o que tornou a auto-aplica¸c˜ ao restrita. Foram realizados testes que consistiram na especializa¸c˜ ao de mix _ASM em rela¸c˜ ao a interpretadores simples, como, por exemplo, um interpretador para a M´ aquina de Turing.

O resultado alcan¸cado, como esperado, foi a gera¸c˜ ao de compiladores das linguagens des- critas para a linguagem das M´ aquinas de Estado Abstratas. Os compiladores gerados s˜ ao, entretanto, bastante ineficientes.

Devido a dificuldades em se obter um compilador eficiente usando auto-aplica¸c˜ ao, de- sisitimos de ir al´ em e aplicar a Terceira Proje¸c˜ ao de Futamura. O objetivo seria a gera¸c˜ ao de um gerador de compiladores para ASM. Um problema s´ erio que contribuiu para essa decis˜ ao ´ e discutido na Se¸c˜ ao 4.5. Sendo assim, adotamos uma nova abordagem que tamb´ em utiliza t´ ecnicas de avalia¸c˜ ao parcial, denominada abordagem de extens˜ oes de gera¸c˜ ao, que discutiremos a seguir.

Os resultados descritos nesta se¸c˜ ao foram publicados inicialmente em [28]. Nesse artigo, as t´ ecnicas utilizadas para implementar um avaliador parcial para ASM foram apresenta- das. Mais tarde, um novo artigo foi produzido, descrevendo os resultados da gera¸c˜ ao de compiladores simples com a auto-aplica¸c˜ ao do avaliador parcial [30].

1.4.2 Extens˜ oes de Gera¸ c˜ ao para ASM

Os trabalhos envolvendo avalia¸c˜ ao parcial e ASM fazem parte de uma s´ erie de proje- tos do grupo de pesquisa em Linguagens de Programa¸c˜ ao do DCC-UFMG, relacionados

`

a utiliza¸c˜ ao das M´ aquinas de Estado Abstratas. Um dos projetos ´ e a proposta de uma vers˜ ao estaticamente tipada para a linguagem das M´ aquinas de Estado Abstratas, desig- nada Machˇına [81]. A linguagem Machˇına foi projetada de modo a facilitar uma compila¸c˜ ao eficiente para linguagens imperativas comuns.

A gera¸c˜ ao de compiladores por meio da aplica¸c˜ ao das proje¸c˜ oes de Futamura n˜ ao ´ e muito adequada a linguagens estaticamente tipadas. A abordagem indicada, nesse caso, ´ e a constru¸c˜ ao de um gerador de extens˜ oes de gera¸c˜ ao. Como discutido na Se¸c˜ ao 1.2, essa abordagem consiste em escrever ` a m˜ ao o programa cogen, que pode ser gerado automati- camente por auto-aplica¸c˜ ao de um avaliador parcial.

Uma das raz˜ oes de termos adotado inicialmente a abordagem das proje¸c˜ oes de Futa- mura foi devido ao fato de n˜ ao termos dispon´ıvel uma vers˜ ao estaticamente tipada da linguagem ASM quando o trabalho foi iniciado. A proposta da linguagem Machˇına surgiu quando boa parte da pesquisa com avalia¸c˜ ao parcial j´ a havia sido conduzida. Al´ em disso, descobrimos que algumas constru¸c˜ oes da linguagem ASM tornavam muito dif´ıcil obter bons resultados com auto-aplica¸c˜ ao. Esses motivos fizeram com que a constru¸c˜ ao de um gerador de extens˜ oes de gera¸c˜ ao passasse a fazer parte dos nossos objetivos.

Entretanto, um compilador confi´ avel para Machˇına n˜ ao foi implementado a tempo. O

nosso procedimento, ent˜ ao, foi desenvolver um gerador de extens˜ oes de gera¸c˜ ao cujo n´ ucleo

processa constru¸c˜ oes b´ asicas de uma linguagem abstrata baseada no modelo das M´ aquinas

de Estado Abstratas. Para o funcionamento do sistema, devem ser acoplados m´ odulos

de leitura e gera¸c˜ ao para uma linguagem concreta espec´ıfica. Nos testes que realizamos, utilizamos a linguagem Xasm, que possui um compilador para C bastante utilizado [6]. Um m´ odulo para a linguagem Machˇına poder´ a ser desenvolvido e testado no futuro, quando o compilador estiver dispon´ıvel.

Usando o gerador de extens˜ oes de gera¸c˜ ao e o compilador de Xasm, foram conduzidos testes de gera¸c˜ ao de compiladores para linguagens mais complexas. Por exemplo, a partir da descri¸c˜ ao da semˆ antica de um significativo subconjunto da linguagem C, escrito em Xasm, geramos automaticamente um compilador dessa linguagem para Xasm. Os detalhes de implementa¸c˜ ao e os resultados dos testes s˜ ao descritos no Cap´ıtulo 7.

As contribui¸c˜ oes da nossa pesquisa podem ser comparadas principalmente com os re- sultados dos trabalhos envolvendo avalia¸c˜ ao parcial e gera¸c˜ ao de compiladores, como em [62, 24, 60, 61]. De maneira diversa desses trabalhos, procuramos implementar um ambi- ente onde a linguagem objeto ´ e uma linguagem imperativa eficiente (linguagem C), sem abrir m˜ ao de uma linguagem de descri¸c˜ ao de semˆ antica de alto n´ıvel (modelo ASM).

1.5 Organiza¸ c˜ ao do Documento

O Cap´ıtulo 2 apresenta o formalismo das M´ aquinas de Estado Abstratas. O texto concentra-se nos aspectos relativos ao uso do modelo para descri¸c˜ ao da semˆ antica de lin- guagens de programa¸c˜ ao, apresentando o subconjunto de ASM utilizado para especificar sistemas seq¨ uenciais. A Se¸c˜ ao 2.1 apresenta o modelo de maneira informal. As ASMs s˜ ao caracterizadas como m´ aquinas abstratas cujos estados s˜ ao representados por fun¸c˜ oes e rela¸c˜ oes. Um programa para a m´ aquina ´ e uma regra de transi¸c˜ ao, aplicada sobre o es- tado corrente para produzir o pr´ oximo estado. Entre as principais regras de transi¸c˜ ao, s˜ ao apresentadas a regra de atualiza¸c˜ ao, a regra condicional e o construtor de blocos. Uma s´ erie de exemplos pode ser encontrada na Se¸c˜ ao 2.2, tornando mais claro o entendimento dos conceitos envolvidos. A Se¸c˜ ao 2.3 repete a maioria dos conceitos, desta feita aplicando uma abordagem mais formal. Um leitor familiarizado com o modelo ASM pode dispensar a leitura desse cap´ıtulo. Para entender os conceitos discutidos nos cap´ıtulos seguintes, pode ser suficiente a leitura das se¸c˜ oes 2.1 e 2.2, al´ em das conclus˜ oes.

O Cap´ıtulo 3 discute aspectos te´ oricos e pr´ aticos relacionados ` a avalia¸c˜ ao parcial de programas. Apresentamos uma descri¸c˜ ao bastante completa, cobrindo diferentes aborda- gens, combinando aspectos te´ oricos e pr´ aticos e fornecendo muitos exemplos. Uma vers˜ ao ainda mais desenvolvida desse texto foi apresentada como um tutorial sobre avalia¸c˜ ao par- cial de programas [29]. Se o leitor conhecer o assunto, pode dispensar a leitura do texto.

Para entender os conceitos abordados neste documento, recomenda-se pelo menos a lei- tura da introdu¸c˜ ao do cap´ıtulo (Se¸c˜ ao 3.1) e da Se¸c˜ ao 3.5. Essa ´ ultima se¸c˜ ao traz uma abordagem mais formal do assunto e discute detalhadamente a aplica¸c˜ ao de avalia¸c˜ ao par- cial na gera¸c˜ ao de compiladores, explorando a abordagem das proje¸c˜ oes de Futamura e a abordagem de extens˜ oes de gera¸c˜ ao. Recomenda-se ler tamb´ em as conclus˜ oes.

As t´ ecnicas utilizadas para desenvolver um avaliador parcial para ASM s˜ ao discutidas no

Cap´ıtulo 4. Esse cap´ıtulo apresenta resultados alcan¸cados com a utiliza¸c˜ ao das Proje¸c˜ oes

de Futamura para compila¸c˜ ao e gera¸c˜ ao de compiladores.

Os detalhes de uma implementa¸c˜ ao do avaliador parcial para ASM na pr´ opria linguagem ASM s˜ ao apresentados no Cap´ıtulo 5. Propriedades importantes sobre o funcionamento desse avaliador parcial, bem como dos programas gerados, s˜ ao formalmente demonstradas no Cap´ıtulo 6.

O Cap´ıtulo 7 apresenta o gerador de extens˜ oes de gera¸c˜ ao para ASM. A gera¸c˜ ao de compiladores para linguagens mais complexas, como um significativo subconjunto da lin- guagem C, ´ e o resultado mais expressivo desse cap´ıtulo.

As conclus˜ oes finais s˜ ao apresentadas no Cap´ıtulo 8.

Cap´ıtulo 2

M´ aquinas de Estado Abstratas

Este cap´ıtulo apresenta o modelo de especifica¸c˜ ao formal ASM, anteriormente conhecido como Evolving Algebras. O texto utilizado foi, em grande parte, extra´ıdo do tutorial de ASM apresentado em [82].

M´ aquinas de Estado Abstratas (ASM, do inglˆ es Abstract State Machines ), introdu- zidas por Yuri Gurevich em [39, 40], constituem um conceito expressivo e elegante para modelagem matem´ atica de sistemas dinˆ amicos discretos.

A id´ eia original era descrever a semˆ antica operacional para algoritmos elaborando a tese impl´ıcita de Turing, isto ´ e, “todo algoritmo pode simulado por uma m´ aquina de Turing apropriada”. Desta maneira, Turing descreveu a semˆ antica operacional de algoritmos.

Entretanto, esta semˆ antica ´ e muito inconveniente, pois pode ser necess´ aria uma longa seq¨ uˆ encia de passos na m´ aquina de Turing para simular um ´ unico passo do algoritmo.

Assim, as ASM foram criadas com o objetivo de simular algoritmos de maneira mais natural [39]. A Tese de ASM Seq¨ uencial diz que “todo algoritmo seq¨ uencial, em qualquer n´ıvel de abstra¸c˜ ao, pode ser visto como uma ASM” [41].

As ASM possuem recursos para modelar intera¸c˜ ao do programa com o “mundo exte- rior”, possibilitando formalizar as a¸c˜ oes do ambiente no qual o sistema est´ a inserido. A metodologia de ASM provˆ e recursos expressivos para especificar a semˆ antica operacional de sistemas dinˆ amicos discretos, em um n´ıvel de abstra¸c˜ ao natural e de uma maneira di- reta e essencialmente livre de codifica¸c˜ ao [27]. Com isso, tem-se por objetivo diminuir a distˆ ancia que h´ a entre modelos formais de computa¸c˜ ao e m´ etodos pr´ aticos de especifica¸c˜ ao.

A metodologia utiliza conceitos simples e bem conhecidos, o que facilita a leitura e a escrita de especifica¸c˜ oes de sistemas.

Na literatura, h´ a v´ arios exemplos de utiliza¸c˜ ao de ASM na especifica¸c˜ ao formal de sis- temas, dentre os quais podemos citar: arquiteturas [15, 16, 19], linguagens de programa¸c˜ ao [20, 21, 22, 42, 84], sistemas distribu´ıdos [7, 8, 17, 44] e de tempo real [35, 45], entre outros [18].

Interessa-nos especialmente o uso de ASM para especificar semˆ antica de linguagens de

programa¸c˜ ao. A semˆ antica de uma linguagem L ´ e geralmente dada por um interpretador

escrito em ASM, que recebe como entradas um programa P escrito em L e a entrada

desse programa. O interpretador simula a execu¸c˜ ao de P sobre sua entrada. Vamos

nos concentrar nas linguagens de programa¸c˜ ao seq¨ uenciais, isto ´ e, as que n˜ ao permitem

execu¸c˜ ao paralela ou concorrente de processos.

Neste cap´ıtulo, vamos apresentar o conceito de M´ aquinas de Estado Abstratas Seq¨ uenci- ais, que s˜ ao as ASMs usadas para especificar sistemas seq¨ uenciais. Embora contenham pri- mitivas para disparo de regras em paralelo, como veremos adiante, n˜ ao permitem execu¸c˜ ao de v´ arios agentes simultaneamente. ASM possibilita especifica¸c˜ ao de modelos multiagentes de modo simples e elegante [40], mas vamos nos concentrar apenas no modelo seq¨ uencial.

Na Se¸c˜ ao 2.1, os conceitos s˜ ao introduzidos de uma maneira informal. Na Se¸c˜ ao 2.2, v´ arios exemplos de uso s˜ ao apresentados. A Se¸c˜ ao 2.3 cont´ em a defini¸c˜ ao formal do modelo. As conclus˜ oes deste cap´ıtulo s˜ ao apresentadas na Se¸c˜ ao 2.4.

2.1 Introdu¸ c˜ ao ao Modelo ASM

Esta se¸c˜ ao apresenta o modelo ASM de maneira informal.

Em linhas gerais, as ASMs s˜ ao m´ aquinas abstratas, cujos estados s˜ ao formados por fun¸c˜ oes e rela¸c˜ oes. Estas fun¸c˜ oes ou rela¸c˜ oes possuem nomes e s˜ ao definidas em um conjunto denominado o superuniverso do estado. O conjunto dos nomes de fun¸c˜ oes e rela¸c˜ oes de um estado ´ e o vocabul´ ario do estado. A interpreta¸c˜ ao de um nome de fun¸c˜ ao ou rela¸c˜ ao ´ e um mapeamento dos nomes pertencentes ao vocabul´ ario nas respectivas fun¸c˜ oes ou rela¸c˜ oes.

A mudan¸ca de estado da m´ aquina ´ e dada por uma regra de transi¸c˜ ao. Uma regra de transi¸c˜ ao modifica a interpreta¸c˜ ao de alguns nomes de fun¸c˜ ao do vocabul´ ario do estado.

Uma regra de transi¸c˜ ao de ASM tem a forma de um programa como de uma linguagem imperativa comum. A diferen¸ca principal ´ e a ausˆ encia de itera¸c˜ ao, pois esse conceito est´ a impl´ıcito na execu¸c˜ ao da m´ aquina. Com efeito, a execu¸c˜ ao da m´ aquina consiste em executar a sua regra de transi¸c˜ ao repetidas vezes, modificando a cada vez o estado atual.

Dessa forma, ´ e formada uma seq¨ uˆ encia de estados de mesmo vocabul´ ario e compostos por diferentes fun¸c˜ oes e rela¸c˜ oes. Dizemos que a interpreta¸c˜ ao dos nomes pertencentes ao vocabul´ ario ´ e modificada de estado para estado durante a execu¸c˜ ao.

Mais precisamente, um vocabul´ ario Υ ´ e um conjunto de nomes de fun¸c˜ oes e rela¸c˜ oes, cada nome com uma aridade fixa associada. Por exemplo, suponha que a aridade da fun¸c˜ ao de nome i seja 0 e da fun¸c˜ ao de nome f seja 1. Temos que o conjunto { i, f } ´ e um vocabul´ ario. Os nomes das rela¸c˜ oes de zero argumento true, false, o nome da fun¸c˜ ao de zero argumento undef, os operadores booleanos usuais e o sinal de igualdade est˜ ao presentes em todo vocabul´ ario.

Um estado S de vocabul´ ario Υ ´ e um conjunto X, denominado o superuniverso de S, junto com as interpreta¸c˜ oes, em X, dos nomes de fun¸c˜ oes e rela¸c˜ oes pertencentes a Υ.

Se f ´ e um nome de fun¸c˜ ao de aridade r, ent˜ ao f ´ e interpretado como uma fun¸c˜ ao f : X ^r → X. Se f ´ e um nome de rela¸c˜ ao de aridade r, ent˜ ao f ´ e interpretado como uma fun¸c˜ ao f : X ^r → { true, false } . Se U ´ e um nome de rela¸c˜ ao pertencente a Υ, ent˜ ao o conjunto U = { x ¯ : U (¯ x) = true } ´ e um universo contido em X. Neste caso, dizemos que U (¯ x) = true e ¯ x ∈ U s˜ ao equivalentes.

Um novo estado ´ e criado a partir do estado atual, por uma regra de transi¸c˜ ao, por meio

da mudan¸ca da interpreta¸c˜ ao de cada nome de fun¸c˜ ao. As regras mais simples, conhecidas

como regras b´ asicas, s˜ ao atualiza¸c˜ ao, bloco e condicional.

Uma regra de atualiza¸c˜ ao ´ e da forma

R ≡ f(¯ x) := y,

onde o comprimento de ¯ x ´ e igual ` a aridade de f . Esta regra cria, a partir de um estado S, um novo estado S

, tal que a interpreta¸c˜ ao do nome de fun¸c˜ ao f ´ e uma fun¸c˜ ao f : X ^r → X, que, no ponto x ¯ (a avalia¸c˜ ao da tupla ¯ x), o seu valor ´ e y (a avalia¸c˜ ao de y). Por exemplo, a regra f (1) := 2 determina um novo estado no qual o valor da fun¸c˜ ao f , no ponto 1, ´ e 2.

Uma regra condicional da forma

R ≡ if g then R ₁ else R ₂ endif

tem a seguinte semˆ antica: se a express˜ ao g avaliar em verdadeiro, ent˜ ao o estado resultante

´ e o resultado da regra R ₁ ; caso contr´ ario, o estado resultante ´ e o resultado da regra R ₂ . Uma regra bloco da forma

R ≡ R ₁ , . . . , R _n

tem a seguinte semˆ antica: o estado formado por R ´ e o resultado da execu¸c˜ ao de todas as regras R _i em paralelo. Por exemplo, a execu¸c˜ ao da regra bloco

f (1) := 2, f(2) := 4

produz um novo estado, no qual o valor da fun¸c˜ ao f , no ponto 1, ´ e 2 e, no ponto 2, ´ e 4.

Uma especifica¸c˜ ao ASM cont´ em a defini¸c˜ ao de um estado inicial, S ₀ , e uma regra, R, que define as mudan¸cas de estado. A execu¸c˜ ao de uma especifica¸c˜ ao ´ e uma seq ¨ uˆ encia de estados S _n : n ≥ 0 , onde um estado S _i ´ e obtido executando a regra R em S _{i −1} . Para exemplificar estes conceitos, apresentaremos uma especifica¸c˜ ao ASM para a fun¸c˜ ao fatorial.

Example 1 (Fun¸c˜ ao Fatorial)

Suponha que o estado inicial S ₀ seja dado com o vocabul´ ario Υ = { f, i } , onde i ´ e um nome de fun¸c˜ ao de zero argumento, interpretado como 0, e f ´ e um nome de fun¸c˜ ao un´ aria, interpretado como a fun¸ c˜ ao f = λx.(x = 0 → 1, undef) ¹ .A regra da especifica¸c˜ ao ´ e o bloco:

f(i + 1) := (i + 1) × f(i), i := i + 1

Ao executarmos a regra no estado S ₀ , obtemos um novo estado S ₁ , no qual i ´ e interpretado como 1 e f ´ e interpretado como a fun¸ c˜ ao

f = λx.(x = 0 → 1, (x = 1 → 1, undef))

Como podemos ver na Figura 2.1, ao executarmos a regra no estado S ₁ , obtemos um novo estado S ₂ , no q ual i ´ e interpretado como 2 e a interpreta¸c˜ ao de f, no ponto 2, passa a ser igual a 2. Da mesma forma, obtemos os estados S ₃ , S ₄ , ....

Pode-se ver facilmente que, no estado S _k , k ≥ i, a interpreta¸c˜ ao de f, f , ´ e uma fun¸c˜ ao que, aplicada a i , retorna i !.

1

Se f = λx.E, ent˜ao f ´e uma fun¸c˜ao dada por f ( x ) = E. Mais detalhes sobre a nota¸c˜ao lambda podem

ser encontrados em [59]. A nota¸c˜ao a → b, c, utilizada em [37], ´e equivalente a if a then b else c.

Estado f (0) f(1) f (2) f (3) f (4) · · · f (n) S ₀ 1 undef undef undef undef · · · undef S ₁ 1 1 undef undef undef · · · undef

S ₂ 1 1 2 undef undef · · · undef

S ₃ 1 1 2 6 undef · · · undef

S ₄ 1 1 2 6 24 · · · undef .. . .. . .. . .. . .. . .. . . .. .. . S _n 1 1 2 6 24 · · · n!

Figura 2.1: Interpreta¸c˜ ao do nome de fun¸c˜ ao f.

Um aspecto importante que deve ser modelado na especifica¸c˜ ao de sistemas ´ e q ue, em geral, eles s˜ ao afetados pelo ambiente. O ambiente se manifesta por meio de algumas fun¸c˜ oes b´ asicas, chamadas fun¸ c˜ oes externas. Um exemplo t´ıpico de fun¸c˜ ao externa ´ e uma entrada fornecida pelo usu´ ario. Pode-se pensar em fun¸c˜ oes externas como or´ aculos, tais que, a especifica¸c˜ ao fornece argumentos e o or´ aculo fornece o resultado [40].

Al´ em das regras b´ asicas, mostradas acima, h´ a tamb´ em as regras que utilizam vari´ aveis ² . Em ASM, vari´ aveis s˜ ao utilizadas para modelar paralelismo, n˜ ao-determinismo e a “cria¸c˜ ao”de novos elementos. As regras que utilizam vari´ aveis s˜ ao as regras import, choose e var.

Uma regra import ´ e da forma

import v R ₀ endimport,

onde v ´ e uma vari´ avel e R ₀ ´ e uma regra. O efeito dessa regra ´ e executar R ₀ em um estado em que a vari´ avel v est´ a associada a um valor importado de um universo especial chamado Reserve. Este universo est´ a contido em X, o superuniverso dos estados da m´ aquina, e cont´ em todos os elementos que ser˜ ao importados.

Em geral, regras import s˜ ao utilizadas para estender universos, isto ´ e, adicionar novos elementos aos universos. Assim, regras da forma

import v U(v) := true, R ₀ endimport

onde U ´ e um nome de universo e R ₀ ´ e uma regra, podem ser escritas utilizando a seguinte regra extend :

extend U with v R ₀ endextend.

Uma regra choose ´ e da forma

choose v in U satisfying g R ₀ endchoose

onde v ´ e uma vari´ avel, U ´ e o nome de um universo finito, g ´ e um termo booleano e R ₀ ´ e uma regra. O efeito desta regra ´ e executar a regra R ₀ em um estado no qual a vari´ avel v est´ a associada a um valor pertencente ao universo U. Este valor ´ e escolhido de maneira n˜ ao-determinista e satisfaz a guarda g.

2

Vari´ aveis s˜ ao s´ımbolos que podem denotar elementos do superuniverso.

Uma regra var ´ e da forma

var v ranges over U R ₀ endvar,

onde v ´ e uma vari´ avel, U ´ e o nome de um universo finito e R ₀ ´ e uma regra. O efeito desta regra ´ e criar uma instˆ ancia de R ₀ para cada elemento pertencente ao universo U. Em cada instˆ ancia de R ₀ , a vari´ avel v est´ a associada ao elemento correspondente de U. Ap´ os criadas as instˆ ancias, todas s˜ ao executadas em paralelo.

Para simplificar as especifica¸c˜ oes, vamos supor que conjuntos como o dos n´ umeros inteiros, dos racionais, das listas e dos conjuntos estejam contidos no superuniverso de um estado.

2.2 Exemplos

Nesta se¸c˜ ao, apresentaremos alguns exemplos de defini¸c˜ ao de sistemas em ASM.

Example 2 Pesquisa Bin´ aria

Este exemplo tem por finalidade mostrar a utiliza¸c˜ ao de fun¸ c˜ oes e regras b´ asicas para especifica¸c˜ ao de algoritmos simples.

O problema consiste em encontrar um valor k em um arranjo ordenado de inteiros, a, de comprimento n, indexado de 1 a n. Um algoritmo bastante utilizado para resolu¸ c˜ ao deste problema ´ e a busca bin´ aria, que, a cada passo, restringe o espa¸ co de busca da chave pela metade.

Na solu¸c˜ ao proposta, o arranjo a ´ e representado pela fun¸c˜ ao f , de modo que f (k) = a[k], para k inteiro.

No estado inicial, inf ´ e interpretado como 1, sup ´ e interpretado como n, k ´ e interpretado como o valor da chave de pesquisa, o nome de rela¸ c˜ ao encontrado ´ e interpretado como false e o nome de fun¸c˜ ao f ´ e interpretado como uma fun¸ c˜ ao que, aplicada a um n´ umero inteiro i, 1 ≤ i ≤ n, retorna a[i]. Todos os outros nomes de fun¸ c˜ ao s˜ ao interpretados como undef.

A regra da especifica¸ c˜ ao ´ e

if (not encontrado and inf ≤ sup) then if (k = f ((inf + sup)/2)) then

encontrado := true, pos := (inf + sup)/2

elseif (k < f ((inf + sup)/2)) then sup := (inf + sup)/2 − 1 else

inf := (inf + sup)/2 + 1 endif

endif

Diversos passos s˜ ao executados at´ e que a chave seja encontrada ou o algoritmo possa

determinar que a chave n˜ ao est´ a presente no arranjo. Se a chave k for encontrada, ent˜ ao

encontrado = true e o nome de fun¸c˜ ao pos ´ e interpretado como a posi¸ c˜ ao no arranjo onde

est´ a a chave, isto ´ e, f(pos) = a[pos] = k.

Example 3 Ordena¸c˜ ao por sele¸c˜ ao

Da mesma forma que no Exemplo 2, a fun¸ c˜ ao f representa os elementos que desejamos ordenar. Quando a execu¸c˜ ao convergir, esperamos que se 1 ≤ i ≤ j ≤ n, ent˜ ao f(i) ≤ f(j ).

No estado inicial, o nome de fun¸c˜ ao Modo ´ e interpretado como 1, i ´ e interpretado como 1 e f ´ e interpretado como no Exemplo 2. Todos os outros nomes de fun¸ c˜ ao s˜ ao interpretados como undef.

A regra da especifica¸ c˜ ao ´ e a seguinte:

if Modo = 1 and i < n then k := i, j := i + 1, Modo := 2 elseif Modo = 2 then

if j > n then Modo := 3

elseif f (j) < f (k) then k := j, j := j + 1 endif

elseif Modo = 3 then if k = i then

f (k) := f(i), f (i) := f(k) endif

i := i + 1, Modo := 1 endif

A m´ aquina executa at´ e que i atinja o valor n. Neste estado, o arranjo est´ a ordenado.

A fun¸c˜ ao Modo ´ e utilizada para que o modelo, essencialmente paralelo, simule a execu¸ c˜ ao dos passos seq¨ uenciais do algoritmo. Observe que a permuta¸c˜ ao de dois valores do arranjo n˜ ao demanda a utiliza¸c˜ ao de um tempor´ ario.

Example 4 N´ umeros Primos

Neste exemplo, especificaremos um algoritmo bastante simples para encontrar todos os primos menores ou iguais a um n´ umero n qualquer. Para isso, definiremos um universo Numeros, subconjunto dos n´ umeros inteiros, tal que Numeros = { x ∈ Inteiros : 2 ≤ x ≤ n } . O vocabul´ ario cont´ em os nomes de fun¸c˜ ao primo de aridade 1, e x e n de aridade zero.

No estado inicial, faremos x ser interpretado como o n´ umero 3 e a fun¸c˜ ao primo aplicada a qualquer elemento pertencente ao universo Numeros retornar true. A regra marcar´ a com false todos os n´ umeros de 2 a n que n˜ ao forem primos.

A regra da especifica¸ c˜ ao ´ e a seguinte:

if x ≤ n then

var y ranges over Numeros if y < x and x%y = 0 then

primo(x) := false endif

endvar,

x := x + 1

endif

A m´ aquina executar´ a v´ arios passos at´ e que x atinja o valor n + 1. Neste estado, o nome de fun¸ c˜ ao primos ser´ a interpretada como uma fun¸ c˜ ao que, aplicada a um n´ umero inteiro k, 2 ≤ k ≤ n, retorna true, se k for um n´ umero primo, ou false, se k for um n´ umero composto.

Example 5 Interpretador para a M´ aquina de Turing

Este exemplo exibe um interpretador de uma vers˜ ao da M´ aquina de Turing. Um inter- pretador para uma linguagem escrito em ASM pode ser visto como uma maneira geral de se especificar a semˆ antica dessa linguagem. Assim, este exemplo especifica a semˆ antica da linguagem de uma vers˜ ao da M´ aquina de Turing, descrita a seguir.

A m´ aquina possui as seguintes instru¸ c˜ oes: right, left, write a, goto i, if a goto i. Um estado ´ e caracterizado pela instru¸ c˜ ao I _i que ser´ a executada no pr´ oximo passo, juntamente com uma fita infinita cujas c´ elulas podem armazenar elementos do conjunto { 0, 1, undef } e um valor que indica a posi¸ c˜ ao da cabe¸ca de leitura/grava¸c˜ ao, ou seja, qual c´ elula da fita est´ a sendo analisada no momento. Apenas um n´ umero finito de c´ elulas da fita possui valor diferente de undef e inicialmente a cabe¸ca indica a primeira c´ elula com essa caracter´ıstica, se houver.

A instru¸c˜ ao write a altera o conte´ udo da c´ elula analisada para 0, 1 ou undef, conforme o valor de a; right desloca a cabe¸ca uma c´ elula para a direita; left desloca a cabe¸ca uma c´ elula para a esquerda; goto i desvia o fluxo do programa para a instru¸ c˜ ao I _i ; if a goto i ´ e um desvio que s´ o ocorre se o conte´ udo da c´ elula analisada for a. O programa exemplo apresentado a seguir, extra´ıdo de [55], pode provocar uma altera¸ c˜ ao na fita ou entrar em loop infinito, se a fita n˜ ao contiver nenhum s´ımbolo 0:

0: if 0 goto 3 1: right

2: goto 0 3: write 1

Apresentamos em seguida uma regra de transi¸ c˜ ao ASM que implementa um interpreta- dor para a MT descrita acima. Vamos supor que a fita seja representada pela fun¸ c˜ ao fita, inicializada de forma adequada. Vamos supor tamb´ em que o programa possa ser recuperado por meio das fun¸ c˜ oes cod, par1 e par2 que, dado o n´ umero de uma instru¸ c˜ ao, fornecem respectivamente o c´ odigo, valor do primeiro parˆ ametro e valor do segundo parˆ ametro dessa instru¸c˜ ao. O n´ umero da instru¸c˜ ao corrente ´ e indicado por cont, e a c´ elula da fita analisada

´

e indicada por cabeca. No estado inicial, cont indica a primeira instru¸ c˜ ao do programa MT e cabeca indica a primeira c´ elula da fita com valor diferente de undef, se houver. O c´ odigo ASM ´ e exibido abaixo:

if cod(cont) = LEF T then cont := cont + 1, cabeca := cabeca − 1

elseif cod(cont) = RIGHT then cont := cont + 1,

cabeca := cabeca + 1

elseif cod(cont) = W RIT E then

cont := cont + 1,

f ita(cabeca) := par1(cont) elseif cod(cont) = GOT O then

cont := par1(cont)

elseif cod(cont) = IF GOT O then if par1(cont) = f ita(cabeca) then

cont := par2(cont) else

cont := cont + 1 endif

endif

2.3 O Modelo Formal de ASM

Nesta se¸c˜ ao apresentaremos o modelo formal de ASM.

2.3.1 Defini¸ c˜ ao da M´ aquina

ASM s˜ ao sistemas de transi¸c˜ ao que especificam computa¸c˜ oes cujos estados s˜ ao ´ alge- bras [27]. Os universos de ´ algebras que formam os estados da computa¸c˜ ao constituem o superuniverso da ASM.

Definition 1 (Vocabul´ ario) Um vocabul´ ario Υ ´ e uma cole¸c˜ ao finita de nomes de fun¸c˜ ao ou rela¸c˜ ao, cada nome com uma aridade fixa. Est˜ ao presentes em todo vocabul´ ario: o sinal de igualdade, true, false e undef e os operadores booleanos usuais.

A fun¸c˜ ao undef ´ e utilizada para modelar fun¸c˜ oes parciais.

Definition 2 (Estado) Um estado S ´ e uma ´ algebra [34], dada por:

• um vocabul´ ario Υ, o vocabul´ ario do estado S;

• um conjunto X, denominado o superuniverso de S, no qual est˜ ao contidos os con- juntos dos n´ umeros inteiros, dos valores l´ ogicos, dos n´ umeros racionais, das cadeias de caracteres, das listas, das tuplas e das partes de conjuntos;

• uma fun¸c˜ ao Val : Υ → X ^∗ → X, que fornece a interpreta¸ c˜ ao dos nomes de fun¸c˜ oes pertencentes a Υ em fun¸ c˜ oes de X ^∗ → X.

Para os conjuntos do superuniverso, est˜ ao definidas as opera¸c˜ oes usuais (como, no caso dos inteiros, adi¸c˜ ao, multiplica¸c˜ ao, etc.).

A no¸c˜ ao de estado ´ e importante, pois cada estado constitui um passo na execu¸c˜ ao da

m´ aquina.

Definition 3 (Fun¸c˜ oes Est´ aticas e Fun¸c˜ oes Dinˆ amicas) Uma fun¸ c˜ ao ´ e dinˆ amica se puder sofrer atualiza¸ c˜ oes, isto ´ e, se durante uma mudan¸ ca de estado, a sua interpreta¸c˜ ao puder ser modificada em alguns pontos. Caso contr´ ario, dizemos que a fun¸ c˜ ao ´ e est´ atica.

Os conceitos de fun¸c˜ oes est´ aticas e dinˆ amicas s˜ ao importantes nas defini¸c˜ oes de regras e atualiza¸c˜ ao, dadas abaixo. Basicamente, o car´ ater dinˆ amico do sistema ´ e modelado pelas altera¸c˜ oes, de estado para estado, na interpreta¸c˜ ao de fun¸c˜ oes dinˆ amicas.

Definition 4 (Termo) Termos s˜ ao definidos recursivamente como:

• uma vari´ avel ´ e um termo;

• um nome de fun¸c˜ ao ou rela¸c˜ ao de zero argumento ´ e um termo;

• se f ´ e um nome de fun¸c˜ ao ou rela¸c˜ ao r-´ aria, r > 0, e x ¯ = (x ₁ , . . . , x _r ) ´ e uma tupla onde cada x _i , 1 ≤ i ≤ r ´ e um termo, ent˜ ao f (¯ x) ´ e um termo.

Termos sem vari´ aveis s˜ ao interpretados, em um estado S, da maneira descrita a seguir:

• se f ´ e um nome de fun¸c˜ ao ou rela¸c˜ ao de zero argumento, sua interpreta¸c˜ ao ´ e ;

• se f ´ e um nome de fun¸c˜ ao r-´ aria e (x ₁ , . . . , x _r ) ´ e uma tupla de comprimento r, ent˜ ao Val _S (f (x ₁ , . . . , x _r )) = Val _S (f )(Val _S (x ₁ ), . . . , Val _S (x _r ))

A interpreta¸c˜ ao de termos que contˆ em vari´ aveis ser´ a mostrada na Se¸c˜ ao 2.3.2, onde definiremos as regras n˜ ao-b´ asicas, isto ´ e, as regras que utilizam vari´ aveis.

Definition 5 (Endere¸co) Um endere¸co em um estado S = (Υ, X, Val) ´ e um par (f, x), ¯ onde f ∈ Υ ´ e um nome de fun¸c˜ ao dinˆ amica, e x ¯ ∈ X ^∗ ´ e uma tupla cujo comprimento ´ e igual ` a aridade de f .

Definition 6 (Atualiza¸c˜ ao) Uma atualiza¸c˜ ao em um estado S = (Υ, X, Val) ´ e um par (l, y), onde l ´ e um endere¸co em S e y ∈ X.

A no¸c˜ ao de atualiza¸c˜ ao ´ e importante para a defini¸c˜ ao de regras e disparo de regras. Para cada regra definimos um conjunto de atualiza¸c˜ oes, que conter´ a os pontos em que haver´ a mudan¸ca na interpreta¸c˜ ao de alguns nomes de fun¸c˜ oes dinˆ amicas no estado seguinte.

Definition 7 (Consistˆ encia de um Conjunto de Atualiza¸ c˜ oes) O conjunto de atualiza¸ c˜ oes

∆ ´ e consistente, se

((f, x), y ¯ ₁ ) ∈ ∆ ∧ ((f, x), y ¯ ₂ ) ∈ ∆ ⇒ y ₁ = y ₂ ,

isto ´ e, se n˜ ao houver, em ∆, duas atualiza¸c˜ oes diferentes para o mesmo endere¸ co.

Definition 8 (Regra) Regras s˜ ao definidas recursivamente por: