Source transformation

About: Source transformation is a research topic. Over the lifetime, 103 publications have been published within this topic receiving 2244 citations.

Notes for pipelines of transformations for ML

Abstract: These notes attempt to survey basic manipulations that can be done to a ML functional program prior to compilation The paper does not consider transformations for improvement of the code but it only considers manipulations of the source text which can allow the compiler to do a better job Which manipulation to choose depends on the target language The survey can be useful for answering the above question and hence for choosing a convenient pipeline of transformations to prepare translation towards a given target language Functional program transformation modi es the whole structure of a func tional program in order to facilitate the production of a better code It can also make the program use less memory Functional programs have a precise mathematical semantic which allows to use source to source transformation techniques in order to provide any semantically correct desired form of pro gram In this paper we address a catalog of eager semantic transformations on a functional language like ML We consider only here fully automatic pro gram transformation Most of these transformations are usually well known though it can happen that the paper makes some contribution in some of the transformations that are described The goal of the paper consists mostly in classifying basic transformations and in seeing how they can be combined into diverses transformation strategies It might happen that the transfor mation strategy we describe as a composition of basic transformations could be expressed directly in a more speci c and e cient algorithm However the division into basic parts makes the transformation toolkit which is proposed in the paper very exible and reusable The author was supported by a contract with Air Force Materiel Command F C A transformation strategy serves a certain purpose The concern can be the target language of the translation For example monomorphization is a useful transformation if the target language is a nonpolymorphic language and defunctionalization is useful if the target language is rst order and lambda lifting is useful if the target language is a term rewriting system The sole concern can be optimization In this case transformation strategies such as deforestation or tuppling are useful Another concern can be the model of the implementation sequential or parallel or distributed In this paper we limit ourselves to some transformation strategies of the rst category Some basic transformations are easily recognized as belonging in a spe ci c strategy but they can also be used as steps in other strategies For example a type enumeration can be a step for a monomorphization but it can also be useful to perform type enumeration as a step of a defunctional ization in a polymorphic program In the rst section we attempt to classify these basic transformations with respect to the area of the structure of the program they modify Then we will see how to combine them into safe and e ective strategies Classi cation of basic transformations Basic transformations exists for every areas of the program structure renamings patterns and case expressions abstractions and let expressions functions and applications types expressions Renaming Uniqueness of identi ers is a useful prerequisite for all transformation strate gies Two di erent kinds of renaming can be distinguished renaming ensures scope independence for the identi ers in lambda abstractions and local let declarations Pattern renaming ensures scope independence for variables in local patterns Pattern and case transformations The simpler the syntax of the core language of the transformation the sim pler the transformation algorithm Also limitation of the number of the possible constructions can be very useful as prerequisite for e ective trans formation strategies Transformation about the patterns and the case ex pressions in a functional program are well known We class them as follows Commodity pattern removals These transformations removes com modity for programmers like the wild card and the as constructions Pattern limitation to case expressions This transformationmakes pat terns appear only in case expressions It has been studied by Auguston in Conversion to simple patterns The simple patterns are interesting because a case expression consisting only of single patterns can be compiled easily into an e cient code This transformation is described in It is supposed that the patterns occurs only in cases The algorithm can increase the size of the code by a large amount but it does not change its e ciency The algorithm can be written so that it creates wild card patterns but it works only on a program without commodity patterns Case removal from application arguments The transformation re moves case expressions as operators in function applications So f t case e of p e j j pn en tm is transformed into case e of p f t e tm j pn f t en tm This transformation increases the size of the code Case and if application This transformation pushes the applied terms of a case or of a functional if expression inside the case For example case e of p e

Exhaustive Execution of CHR Through Source-to-Source Transformation

Abstract: Constraint Handling Rules (CHR) is a committed-choice rule-based programming language. Rules rewrite a global multi-set of constraints to another. Overlapping sets of constraints within the rules and the order of constraints within rules and queries entail different derivation paths. In this work, a novel operational strategy is proposed which enables a high-level form of execution control that empowers a comprehensive and customizable execution strategy. It allows full space exploration for any CHR program, thus finding all possible results to a query which is interesting for many non-confluent programs. The proposed transformation is performed as a source-to-source transformation from any CHR program to one utilizing disjunction to force an exhaustive explorative execution strategy. The work is complemented by formal arguments to prove the correctness and completeness of the transformation.

Laser-loading high-precision constant flow source transformation system for space

Abstract: The invention discloses a laser-loading high-precision constant flow source transformation system for space. The system comprises a constant flow source transformation module and a laser loading unit,and the constant flow source transformation module is connected with a storage battery pack; the laser loading unit is connected with the constant flow source transformation module; the constant flowsource transformation module comprises an interleaving BUCK circuit, a filtering coupling inductor, a circuit sampling unit and a voltage sampling unit; the interleaving BUCK circuit converts changedvoltage of the storage battery pack so that power supply can be matched with the laser loading unit; the filtering coupling inductor receives the current which is output by the interleaving BUCK circuit and outputs current filter; the circuit sampling unit and the voltage sampling unit sample the current and voltage which are output by the filtering coupling inductor respectively. The laser-loading high-precision constant flow source transformation system for space is simple in structure, efficient transformation of an optical fiber laser high-performance power supply system can be achieved,the high-performance power supply requirement of laser loading can be met, and the system has important significance on solution of the high-performance power supply problem in laser loading space engineering application.

Using Source-to-Source Transformation Tools to Provide Distributed Parallel Applications from OpenMP Source Code

Abstract: Thanks to an easy way to express parallel opportunities, OpenMP has become the reference to develop applications for shared-memory architectures. As a result, several works have tried to provide an OpenMP compiler for distributed architectures. This article presents how the Turing eXtended Language (TXL) has been interfaced with the GCC compiler to implement the Checkpointing Aided Parallel Execution (CAPE) concepts in order to provide an OpenMP compiler for distributed architectures.

Extensions of algorithmic differentiation by source transformation inspired by modern scientific computing

Abstract: The adjoint mode of Algorithmic Differentiation (AD) is particularly attractive for computing gradients. However, this mode needs to use the intermediate values of the original simulation in reverse order at a cost that increases with the length of the simulation. AD research looks for strategies to reduce this cost, for instance by taking advantage of the structure of the given program. In this work, we consider on one hand the frequent case of Fixed-Point loops for which several authors have proposed adapted adjoint strategies. Among these strategies, we select the one introduced by B. Christianson. We specify further the selected method and we describe the way we implemented it inside the AD tool Tapenade. Experiments on a medium-size application shows a major reduction of the memory needed to store trajectories. On the other hand, we study checkpointing in the case of MPI parallel programs with point-to-point communications. We propose techniques to apply checkpointing to these programs. We provide proof of correctness of our techniques and we experiment them on representative CFD codes