The HERMIT in the Tree

This paper describes our experience using the HERMIT tool- kit to apply well-known transformations to the internal core language of the Glasgow Haskell Compiler. HERMIT provides several mechanisms to support writing general-purpose transformations: a domain-specific language for strategic programming specialized to GHC's core language, a library of primitive rewrites, and a shell-style{based scripting language for interactive and batch usage. There are many program transformation techniques that have been described in the literature but have not been mechanized and made available inside GHC - either because they are too specialized to include in a general-purpose compiler, or because the developers' interest is in theory rather than implementation. The mechanization process can often reveal pragmatic obstacles that are glossed over in pen-and-paper proofs; understanding and removing these obstacles is our concern. Using HERMIT, we implement eleven examples of three program transformations, report on our experience, and describe improvements made in the process

The Polyhedral Model Beyond Loops Recursion Optimization and Parallelization Through Polyhedral Modeling

International audienceThere may be a huge gap between the statements outlined by programmers in a program source code and instructions that are actually performed by a given processor architecture when running the executable code. This gap is due to the way the input code has been interpreted, translated and transformed by the compiler and the final processor hardware. Thus, there is an opportunity for efficient optimization strategies, that are dedicated to specific control structures and memory access patterns, to apply as soon as the actual runtime behavior has been discovered, even if they could not have been applied on the original source code. In this paper, we develop this idea by identifying code extracts that behave as polyhedral-compliant loops at runtime, while not having been outlined at all as loops in the original source code. In particular, we are interested in recursive functions whose runtime behavior can be modeled as polyhedral loops. Therefore, the scope of this study exclusively includes recursive functions whose control flow and memory accesses exhibit an affine behavior, which means that there exists a semantically equivalent affine loop nest, candidate for poly-hedral optimizations. Accordingly, our approach is based on analyzing early executions of a recursive program using a Nested Loop Recognition (NLR) algorithm, performing the affine loop modeling of the original program runtime behavior , which is then used to generate an equivalent iterative program, finally optimized using the polyhedral compiler Polly. We present some preliminary results showing that this approach brings recursion optimization techniques into a higher level in addition to widening the scope of the polyhe-dral model to include originally non-loop programs

Convergence of program transformers in the metric space of trees

AbstractIn recent years increasing consensus has emerged that program transformers, e.g. partial evaluation and unfold/fold transformations, should terminate; a compiler should stop even if it performs fancy optimizations! A number of techniques to ensure termination of program transformers have been invented, but their correctness proofs are sometimes long and involved. We present a framework for proving termination of program transformers, cast in the metric space of trees. We first introduce the notion of an abstract program transformer; a number of well-known program transformers can be viewed as instances of this notion. We then formalize what it means that an abstract program transformer terminates and give a general sufficient condition for an abstract program transformer to terminate. We also consider some specific techniques for satisfying the condition. As applications we show that termination of some well-known program transformers either follows directly from the specific techniques or is easy to establish using the general condition. Our framework facilitates simple termination proofs for program transformers. Also, since our framework is independent of the language being transformed, a single correctness proof can be given in our framework for program transformers that use essentially the same technique in the context of different languages. Moreover, it is easy to extend termination proofs for program transformers to accommodate changes to these transformers. Finally, the framework may prove useful for designing new termination techniques for program transformers

Divide-and-conquer algorithms for multiprocessors

During the past decade there has been a tremendous surge in understanding the nature of parallel computation. A number of parallel computers are commercially available. However, there are some problems in developing application programs on these computers;This dissertation considers various issues involved in implementing parallel algorithms on Multiple Instruction Multiple Data (MIMD) machines with a bounded number of processors. Strategies for implementing divide-and-conquer algorithms on MIMD machines are proposed. Results linking time complexity, communication complexity and the complexity of divide-and-combine functions of divide-and-conquer algorithms are analyzed. An efficient criterion for partitioning a parallel program is proposed and a method for obtaining a closed form expression for time complexity of a parallel program in terms of problem size and number of processors is developed

Optimización del orden de evaluación de programas recursivos

A través de los años los científicos de la computación han identificado diversas técnicas (estrategias) generales que a menudo producen algoritmos eficientes para la resolución de muchas clases de problemas. Este trabajo presenta un análisis de la estrategia dynamic programming (programación dinámica), a partir de su formalización mediante una regla en el cálculo transformacional desarrollado en el proyecto CIP [Bauer, 85] [Bauer, 87]. La técnica especificada es utilizada en la optimización de programas recursivos ineficientes, derivados, en general, por razonamientos divide and conquer. A partir del análisis de la resolución de problemas sobre dominios de distinta complejidad, siguiendo un proceso sistemático y formal, se plantea una generalización de la estrategia programación dinámica formalizada que hace explícitas las condiciones del orden involucrado sobre el dominio de un problema. Asimismo, se formula una regla que combina la técnica de operacionalización divide and conquer recursivo [Grinspan, 95a] con la de optimización programación dinámica. Programación dinámica evita calcular subproblemas más de una vez, invirtiendo el orden computacional y eliminando recursiones no lineales. No obstante puede conducir a que se resuelvan subproblemas innecesarios en el cómputo de ciertos problemas. Esto provoca que tanto la complejidad en tiempo como en espacio de almacenamiento resulten mayores a las deseadas. Existe una técnica conocida como memorización [Turner, 81] (tabulación exacta [Bird, 80]) que evita, por un lado, recomputar valores y por el otro, computar valores innecesarios. Sin embargo memorización no elimina recursiones no lineales, complicándose luego este proceso en el contexto de una metodología de desarrollo de software transformacional. Este trabajo plantea una regla que combina las ventajas de ambas técnicas, a través de un refinamiento de programación dinámica, en función al orden involucrado sobre el dominio del problema. Técnicas y conceptos inherentes a la rama de análisis de algoritmos sirven de herramientas en la formalización y deducción de las condiciones necesarias para la utilización de las reglas propuestas. Asimismo, en la evaluación de los resultados obtenidos como consecuencia de un proceso de optimización. Dos casos de estudio siguen el desarrollo del artículo: “cálculo de números combinatorios” y “multiplicación eficiente de n matrices”. Éstos destacan la relevancia de cada una de estrategias –puras, generalizadas o combinadas– que se formalizan.Eje: TeoríaRed de Universidades con Carreras en Informática (RedUNCI

Optimización del orden de evaluación de programas recursivos

A través de los años los científicos de la computación han identificado diversas técnicas (estrategias) generales que a menudo producen algoritmos eficientes para la resolución de muchas clases de problemas. Este trabajo presenta un análisis de la estrategia dynamic programming (programación dinámica), a partir de su formalización mediante una regla en el cálculo transformacional desarrollado en el proyecto CIP [Bauer, 85] [Bauer, 87]. La técnica especificada es utilizada en la optimización de programas recursivos ineficientes, derivados, en general, por razonamientos divide and conquer. A partir del análisis de la resolución de problemas sobre dominios de distinta complejidad, siguiendo un proceso sistemático y formal, se plantea una generalización de la estrategia programación dinámica formalizada que hace explícitas las condiciones del orden involucrado sobre el dominio de un problema. Asimismo, se formula una regla que combina la técnica de operacionalización divide and conquer recursivo [Grinspan, 95a] con la de optimización programación dinámica. Programación dinámica evita calcular subproblemas más de una vez, invirtiendo el orden computacional y eliminando recursiones no lineales. No obstante puede conducir a que se resuelvan subproblemas innecesarios en el cómputo de ciertos problemas. Esto provoca que tanto la complejidad en tiempo como en espacio de almacenamiento resulten mayores a las deseadas. Existe una técnica conocida como memorización [Turner, 81] (tabulación exacta [Bird, 80]) que evita, por un lado, recomputar valores y por el otro, computar valores innecesarios. Sin embargo memorización no elimina recursiones no lineales, complicándose luego este proceso en el contexto de una metodología de desarrollo de software transformacional. Este trabajo plantea una regla que combina las ventajas de ambas técnicas, a través de un refinamiento de programación dinámica, en función al orden involucrado sobre el dominio del problema. Técnicas y conceptos inherentes a la rama de análisis de algoritmos sirven de herramientas en la formalización y deducción de las condiciones necesarias para la utilización de las reglas propuestas. Asimismo, en la evaluación de los resultados obtenidos como consecuencia de un proceso de optimización. Dos casos de estudio siguen el desarrollo del artículo: “cálculo de números combinatorios” y “multiplicación eficiente de n matrices”. Éstos destacan la relevancia de cada una de estrategias –puras, generalizadas o combinadas– que se formalizan.Eje: TeoríaRed de Universidades con Carreras en Informática (RedUNCI

Algorithms for computing Fibonacci numbers quickly

A study of the running time of several known algorithms and several new algorithms to compute the n[superscript th] element of the Fibonacci sequence is presented. Since the size of the n[superscript th] Fibonacci number grows exponentially with n, the number of bit operations, instead of the number of integer operations, was used as the unit of time. The number of bit operations used to compute f[subscript n] is reduced to less than 1/2 of the number of bit operations used to multiply two n bit numbers. The algorithms were programmed in Ibuki Common Lisp and timing runs were made on a Sequent Balance 21000. Multiplication was implemented using the standard n² algorithm. Times for the various algorithms are reported as various constants times n². An algorithm based on generating factors of Fibonacci numbers had the smallest constant. The Fibonacci sequence, arranged in various ways, is searched for redundant information that could be eliminated to reduce the number of operations. Cycles in the b[superscript th] bit of f[subscript n] were discovered but are not yet completely understood

Functional programming, program transformations and compiler construction

Dit proefschrift handelt over het ontwerp van de compilergenerator Elegant. Een compiler generator is een computer programma dat vanuit een speci??catie een compiler kan genereren. Een compiler is een computer programma dat een gestructureerde invoertekst kan vertalen in een uitvoertekst. Een compiler generator is zelf een compiler welke de speci??catie vertaalt in de programmatekst van de gegenereerde compiler. Dit heeft het mogelijk gemaakt om Elegant met zichzelf te genereren. Van een compilergenerator wordt verlangd dat deze een krachtig speci??catie formalisme vertaalt in een eÆci??ent programma, een eis waar Elegant aan voldoet. Een compiler bestaat uit een aantal onderdelen, te weten een scanner, een parser, een attribuutevaluator, een optimalisator en een codegenerator. Deze onderdelen kunnen door het Elegant systeem geneneerd worden, ieder uit een aparte speci??catie, met uitzondering van de parser en attribuutevaluator, welke gezamenlijk worden beschreven in de vorm van een zogenaamde attribuutgrammatica. De scanner wordt gegenereerd met behulp van een scannergenerator en heeft tot taak de invoertekst te splitsen in een rij symbolen. Deze rij symbolen kan vervolgens ontleed worden door een parser. Daarna berekent de attribuutevaluator eigenschappen van de invoertekst in de vorm van zogenaamde attributen. De attributenwaarden vormen een datastructuur. De vorm van deze datastructuur wordt gede??nieerd met behulp van typeringsregels in de Elegant programmeertaal. De optimalisator en codegenerator voeren operaties op deze datastructuur uit welke eveneens beschreven worden in de Elegant programmeertaal. Dit proefschrift beschrijft de invloed die functionele programmeertalen hebben gehad op het ontwerp van Elegant. Functionele talen zijn programmeertalen met als belangrijkste eigenschap dat functies een centrale rol vervullen. Functies kunnen worden samengesteld tot nieuwe functies, ze kunnen worden doorgegeven aan functies en worden opgeleverd als functieresultaat. Daarnaast staan functionele talen niet toe dat de waarde van een variable wordt gewijzigd, het zogenaamde nevene??ect, in tegenstelling tot imperatieve talen die zo'n nevene??ect wel toestaan. Deze laatste beperking maakt het mogelijk om met behulp van algebra??ische regels een functioneel programma te herschrijven in een ander functioneel programma met dezelfde betekenis. Dit herschrijfproces wordt ook wel progammatransformatie genoemd. De invloed van functionele talen op Elegant omvat: ?? Het beschrijven van ontleedalgorithmen als functionele programma's. Traditioneel worden ontleedalgorithmen beschreven met behulp van de theorie van stapelautomaten. In hoofdstuk 3 wordt aangetoond dat deze theorie niet nodig is. Met behulp van programmatransformaties zijn vele uit de literauur bekende ontleedalgorithmen af te leiden en worden ook nieuwe ontleedalgorithmen gevonden. Deze aanpak maakt het bovendien mogelijk om de vele verschillende ontleedalgorithmen met elkaar te combineren. ?? De evaluatie van attributen volgens de regels van een attribuutgrammatica blijkt eveneens goed te kunnen worden beschreven met behulp van functionele talen. Traditioneel bouwt een ontleedalgorithme tijdens het ontleden een zogenaamde ontleedboom op. Deze ontleedboom beschrijft de structuur van de invoertekst. Daarna wordt deze ontleedboom geanalyseerd en worden eigenschappen ervan in de vorm van attributen berekend. In hoofdstuk 4 van het proefschrift wordt aangetoond dat het niet nodig is de ontleedboom te construeren. In plaats daarvan is het mogelijk om tijdens het ontleden functies die attributen kunnen berekenen samen te stellen tot nieuwe functies. Uiteindelijk wordt er zo ??e??en functie geconstrueerd voor een gehele invoertekst. Deze functie wordt vervolgens gebruikt om de attribuutwaarden te berekenen. Voor de uitvoering van deze functie is het noodzakelijk gebruik te maken van zogenaamde "luie evaluatie". Dit is een mechanisme dat attribuutwaarden slechts dan berekent wanneer deze werkelijk noodzakelijk zijn. Dit verklaart de naam Elegant, welke een acroniem is voor "Exploiting Lazy Evaluation for the Grammar Attributes of Non- Terminals". ?? Scanners worden traditioneel gespeci??ceerd met behulp van zogenaamde reguliere expressies. Deze reguliere expressies kunnen worden afgebeeld op een eindige automaat. Met behulp van deze automaat kan de invoertekst worden geanalyseerd en gesplitst in symbolen. In hoofdstuk 5 wordt uiteengezet hoe functionele talen het mogelijk maken om scanneralgorithmen te construeren zonder gebruik te maken van automatentheorie. Door een reguliere expressie af te beelden op een functie en de functies voor de onderdelen van samengestelde reguliere expressies samen te stellen tot nieuwe functies kan een scannerfunctie geconstrueerd worden. Door gebruik te maken van programmatransformaties kan deze scanner deterministisch worden gemaakt en minimaal worden gehouden. ?? Het typeringssysteem van Elegant wordt beschreven in hoodstuk 6 en vormt een combinatie van systemen die in functionele en imperatieve talen worden gevonden. Functionele typeringssystemen omvatten typen welke bestaan uit een aantal varianten. Elk van deze varianten bestaat uit een aantal waarden. Bij een dergelijk typeringssysteem wordt een functie gede??ni??eerd door middel van een aantal deeelfuncties. Elke deelfunctie kan met behulp van zogenaamde patronen beschrijven voor welke van de varianten hij gede??ni??eerd is. Het blijkt dat imperatieve typesystemen welke subtypering mogelijk maken een generalisatie zijn van functionele typesystemen. In deze generalisatie kan een patroon worden opgevat als een subtype en een deelfunctie als een parti??ele functie. Het Elegant typesystemen maakt deze vorm van typering en functiebeschrijving mogelijk. Bij toepassing van een functie wordt de bijbehorende deelfunctie geselecteerd door de patronen te passen met de waarden van de actuele functieargumenten. In dit proefschrift wordt een eÆci??ent algorithme voor dit patroonpassen met behulp van programmatransformaties afgeleid uit de de??nitie van patronen. Het Elegant typeringssystemen bevat ook typen voor de modellering van luie evaluatie. De aanwezigheid van nevene??ekten maakt het mogelijk om drie verschillende luie typen te onderscheiden, welke verschillen in de wijze waarop de waarde van een lui object stabiliseert. ?? In hoofdstuk 7 wordt aangetoond dat de regels uit een attribuutgrammatica ook kunnen worden gebruikt om eigenschappen van een datastructuur te berekenen in plaats van eigenschappen van een invoertekst. Elegant biedt de mogelijkheid om zulke attribuutregels te gebruiken voor dit doel. ?? In hoofdstuk 8 tenslotte worden de Elegant programmeertaal en de eÆci??entie van de Elegant vertaler en door Elegant gegenereerde vertalers ge??evalueerd. Het blijkt dat de imperatieve Elegant programmeertaal dankzij abstractie mechanismen uit functionele talen een zeer rijke en krachtige taal is. Daarnaast zijn zowel Elegant zelf als de door Elegant gegenereerde vertalers van hoge eÆci??entie en blijken geschikt voor het maken van compilers voor professionele toepassingen