Program Transformation

The Western Research Laboratory (WRL) is a computer systems research group that was founded by Digital Equipment Corporation in 1982. Our focus is computer science research relevant to the design and application of high performance scientific computers. We test our ideas by designing, building, and using real systems. The systems we build are research prototypes; they are not intended to become products.

We consider in this paper that a DSL (Domain Specific Language) may be defined by a set of models. A typical DSL is the ATLAS Transformation Language (ATL). An ATL program transforms a source model (conforming to a source metamodel) into a target model (conforming to a target metamodel). Being itself a model, the transformation program conforms to the ATL metamodel. The notion of metamodel is thus used to define the source DSL, the target DSL and the transformation DSL itself. As a consequence we can see that agility to define metamodels and precision of these definitions is of paramount importance in any model engineering activity. In order to fullfill the goals of agility and precision in the definition of our metamodels, we have been using a notation called KM3 (Kernel MetaMetaModel). KM3 may itself be considered as a DSL for describing metamodels. This paper presents the rationale for using KM3, some examples of its use and a precise definition of the language.

The aim of this paper is to explore the role of design in supporting user-centred development of services and transformation of service organisations. Especially the focus is on bottom-up and top-down service development approaches in the context of service ensembles provided by multiple, interlinked public, private and third sector organisations. The paper presents findings from two separate design case studies. The first study focuses on the organisational perspective in the context of services for elderly, and the second on the customers' perspective in the context of services for immigrants. The findings highlight how the designerly ways of gathering, visualizing, analysing and sharing information may enhance service development.

Formal methods and testing are two important approaches that assist in the development of high-quality software. While traditionally these approaches have been seen as rivals, in recent years a new consensus has developed in which they are seen as complementary. This article reviews the state of the art regarding ways in which the presence of a formal specification can be used to assist testing.

Matsuda et al. [2007, ICFP] and Voigtländer [2009, POPL] introduced two techniques that given a source-to-view function provide an update propagation function mapping an original source and an updated view back to an updated source, subject to standard consistency conditions. Being fundamentally different in approach, both techniques have their respective strengths and weaknesses. Here we develop a synthesis of the two techniques to good effect. On the intersection of their applicability domains we achieve more than what a simple union of applying the techniques side by side delivers.

—The banking experience for many people today is fundamentally an application of technology to be able to carry out their financial tasks. While the need to visit a bank branch remains essential for a number of activities, increasingly the need to support mobile usage is becoming the central focus of many bank strategies. The core banking systems that process financial transactions must remain highly available and able to support large volumes of activity. These systems represent a long term investment for banks and when the need arises to modernize these large systems, the transformation initiative is often very expensive and of high risk. We present in this paper our experiences in bank modernization and transformation, and outline the strategies for rolling out these large programs. As banking institutions embark upon transformation programs to upgrade their banking channels and core banking systems, it is hoped that the insights presented here are useful as a framework to support these initiatives.

We present the iterative solutions of the Towers of Hanoi problems (standard, cyclic, and generalized) using the program transformation methodology of Burstall-Darlington. We derive algorithms with minimal time x space requirements. Their correctness proofs are trivial, as ~asual when applying the program transformation technique.

Celem artykułu jest ukazanie relacji i zależności, jakie zachodzą pomiędzy procesem demokratyzacji a wprowadzaniem mechanizmów wolnego rynku. Odniesiono się tu do istoty procesów demokratyzacji na świecie w czasie trzech fal demokratyzacji, głównie jednak skoncentrowano się na warunkach i sytuacji krajów Europy Środkowo-Wschodniej, a szczególnie państw bałtyckich: Łotwy, Estonii i Litwy.

of program transformations, including straight-line code parallelization, do loop transformations, and parallelization of recursive routines. The last section of the paper surveys several experimental studies on the effectiveness of parallelizing compilers.

GPUs are a class of specialized parallel architectures with tremendous computational power. The new Compute Unified Device Architecture (CUDA) programming model from NVIDIA facilitates programming of general purpose applications on their GPUs. However, manual development of high-performance parallel code for GPUs is still very challenging. In this paper, a number of issues are addressed towards the goal of developing a compiler framework for automatic parallelization and performance optimization of affine loop nests on GPGPUs: 1) approach to program transformation for efficient data access from GPU global memory, using a polyhedral compiler model of data dependence abstraction and program transformation; 2) determination of optimal padding factors for conflict-minimal data access from GPU shared memory; and 3) model-driven empirical search to determine optimal parameters for unrolling and tiling. Experimental results on a number of kernels demonstrate the effectiveness of the compiler optimization approaches developed.

Our research is driven by the motivation that change must be put in the center, if one wants to understand the complex processes of software evolution. We built a toolset named SpyWare which, using a monitoring plug-in for integrated development environments (IDEs), tracks the changes that a developer performs on a program as they happen. SpyWare stores these first-class changes in a change repository and offers a plethora of productivity-enhancing IDE extensions to exploit the recorded information.

The cost of maintaining legacy software systems has spiralled and their maintenance became a burden for many organisations. In this paper we present the first prototype of the LOBS-COQ system that attempts to transform COBOL legacy systems into relational database schema and produce SQL statements for data querying. The approach first transforms the COBOL source code into XML files, which are then processed to create tables and develop SQL statements. Frames are used to develop the SQL statements. COBOL statements are parsed and the information extracted is used to fill the frames' slots.

Obfuscation is gaining momentum as a protection mechanism for the intellectual property contained within or encapsulated by software. Usually, one of the following three directions is followed: source code obfuscation is achieved through source code transformations, Java bytecode obfuscation through transformations on the bytecode, and binary obfuscation through binary rewriting. In this paper, we study the effectiveness of source code transformations for binary obfuscation. The transformations applied by several existing source code obfuscators are empirically shown to have no impact on the stripped binary after compilation. Subsequently, we study which source code transformations are robust enough to percolate through the compiler into the binary.

VHDL programs are often tested by means of simulations, relying on test benches written intuitively. In this paper, we propose a formal approach to construct test benches from system specification. To consider the real-time properties of VHDL programs, we first transform them to timed automata and then perform model checking against the properties designated from the specification. Counterexamples returned from the model checker serve as a basis of test cases, i.e., they are used to form a test bench. The approach is demonstrated and complemented by a simple case study.

In the late 1970''s a modular, high-throughput architecture for large scale Fourier Transform processors was developed in [1,2]. This architecture uses only a few basic modules in a highly pipelined arrangement and some serial memory for temporary storage of operands. This streamlined architecture seemed predestined for implementation with "Charge Transfer Devices", which have proven themselves in many high-speed signal processing applications and for serial memory [3]. Thus we proposed to investigate the use of charge-coupled devices (CCDs) in the implementation of pipelined FFT processors. For various reasons which are explained below, the use of CCD''s was dropped at an early stage and the decision was made to design these same modules with standard silicon-gate NMOS technology.

Heterogeneous computers with processors and accelerators are becoming widespread in scientific computing. However, it is difficult to program hybrid architectures and there is no commonly accepted programming model. Ideally, applications should be written in a way that is portable to many platforms, but providing this portability for general programs is a hard problem. By restricting the class of programs considered, we can make this portability feasible. We present Liszt, a domainspecific language for constructing mesh-based PDE solvers. We introduce language statements for interacting with an unstructured mesh, and storing data at its elements. Program analysis of these statements enables our compiler to expose the parallelism, locality, and synchronization of Liszt programs. Using this analysis, we generate applications for multiple platforms: a cluster, an SMP, and a GPU. This approach allows Liszt applications to perform within 12% of handwritten C++, scale to large clusters, and experience order-of-magnitude speedups on GPUs.

SmartTools is a development environment generator that provides a structure editor and semantic tools as main features. The well-known visitor pattern technique is commonly used for designing semantic analysis, it has been automated and extended. SmartTools is easy to use thanks to its graphical user interface designed with the Java Swing APIs. It is built with an open architecture convinient

The evaluation function of a syntactic theory is canonically defined as the transitive closure of (1) decomposing a program into an evaluation context and a redex, (2) contracting this redex, and (3) plugging the contractum in the context. Directly implementing this evaluation function therefore yields an interpreter with a worst-case overhead, for each step, that is linear in the size of the input program. We present sufficient conditions over a syntactic theory to circumvent this overhead, by replacing the composition of (3) plugging and (1) decomposing by a single "refocusing" function mapping a contractum and a context into a new context and a new redex, if there are any. We also show how to construct such a refocusing function, we prove its correctness, and we analyze its complexity.

Empirical program optimizers estimate the values of key optimization parameters by generating different program versions and running them on the actual hardware to determine which values give the best performance. In contrast, conventional compilers use models of programs and machines to choose these parameters. It is widely believed that model-driven optimization does not compete with empirical optimization, but few quantitative comparisons have been done to date. To make such a comparison, we replaced the empirical optimization engine in ATLAS (a system for generating a dense numerical linear algebra library called the BLAS) with a model-driven optimization engine that used detailed models to estimate values for optimization parameters, and then measured the relative performance of the two systems on three different hardware platforms. Our experiments show that model-driven optimization can be surprisingly effective, and can generate code whose performance is comparable to that of...

This paper describes an automated approach to hardware design space exploration, through a collaboration between parallelizing compiler technology and high-level synthesis tools. We present a compiler algorithm that automatically explores the large design spaces resulting from the application of several program transformations commonly used in application-specific hardware designs. Our approach uses synthesis estimation techniques to quantitatively evaluate alternate designs for a loop nest computation. We have implemented this design space exploration algorithm in the context of a compilation and synthesis system called DE-FACTO, and present results of this implementation on five multimedia kernels. Our algorithm derives an implementation that closely matches the performance of the fastest design in the design space, and among implementations with comparable performance, selects the smallest design. We search on average only 0.3% of the design space. This technology thus significantly raises the level of abstraction for hardware design and explores a design space much larger than is feasible for a human designer.

This report outlines the evolution of computational geometry, highlights its past accomplishments, and discusses strategic directions for the future. It complements a recent report by Chazelle et al. on the impact of computational geometry on applied elds.

Higher education is being deeply challenged by the coronavirus. The immediate threats of the coronavirus come at the heels of an existing panoply of problems that already threaten higher education as we know it. These include, of course, the looming enrollment crisis, the high cost of higher education, intractable student debt, the corporatization of education, limited learning on campus, and a general loss of faith in higher education among many sectors of the nation.  How are colleges and universities to respond to these challenges?  This paper calls upon colleges and universities to consider the need for structural transformation in order to adapt to the multiple crises facing higher education. Toward this end, using the coronavirus crisis as a point of entry, I propose a model of transformative problem-solving to support the dynamic adaptation of higher education.  The model calls for deep reflexivity about basic assumptions, goals, values and practices that structure teaching and learning in the academy, and proposes ways to evaluate and transform complex and entrenched institutional systems in a time of extended crisis. I illustrate the approach with a description of how a single college program is preparing for structural changes brought forth by the coronavirus.  Turning attention to the broader crises facing the academy, I call for a need to reflect upon, rethink and consider the fate of goals, values and practices have been long been considered sacred in higher education.

A common trend in programming language specification is to generate various tools (e.g., compiler, editor, profiler, and debugger) from a grammar. In such a generative approach, it is desirable to have the definition of a programming language be modularized according to specific concerns specified in the grammar. However, it is often the case that the corresponding properties of the generated tools are scattered and tangled across the language specification. In this paper, separation of concerns within a programming language specification is demonstrated by considering debugging support within a domain-specific language (DSL). The paper first describes the use of AspectJ to weave the debugging semantics into the code created by a parser generator. The paper outlines several situations when the use of AspectJ is infeasible at separating language specification properties. To accommodate such situations, a second approach is presented that weaves the debugging support directly into a grammar specification using a program transformation engine. A case study for a simple DSL is presented to highlight the benefits of weaving across language specifications defined by grammars.

Sage++ is an object oriented toolkit for building program transformation and preprocessing tools. It contains parsers for Fortran 77 with many Fortran 90 extensions, C, and C++, integrated with a C++ class library. The library provides a means to access and restructure the program tree, symbol and type tables, and source-level programmer annotations. Sage++ provides an underlying infrastructure on which all types of program preprocessors can be built, including parallelizing compilers, performance analysis tools, and source code optimizers.

Sage++ is an object oriented toolkit for building program transformation and preprocessing tools. It contains parsers for Fortran 77 with many Fortran 90 extensions, C, and C++, integrated with a C++ class library. The library provides a means to access and restructure the ...

In previous work, we introduced the fundamentals and a supporting combinator library for strategic programming. This an idiom for generic programming based on the notion of a functional strategy: a first-class generic function that cannot only be applied to terms of any type, but which also allows generic traversal into subterms and can be customized with type-specific behaviour.

We build on Danvy and Nielsen's first-order program transformation into continuation-passing style (CPS) to design a new CPS transformation of flow information that is simpler and more efficient than what has been presented in previous work. The key to simplicity and efficiency is that our CPS transformation constructs the flow information in one go, instead of first computing an intermediate result and then exploiting it to construct the flow information.

Load-reuse analysis finds instructions that repeatedly access the same memory location. This location can be promoted to a register, eliminating redundant loads by reusing the results of prior memory accesses. This paper develops a load-reuse analysis and designs a method for evaluating its precision. In designing the analysis, we aspire for completeness-the goal of exposing all reuse that can be harvested by a subsequent program transformation. For register promotion, a suitable transformation is partial redundancy elimination (PRE). To approach the ideal goal of PRE-completeness, the load-reuse analysis is phrased as a dataflow problem on a program representation that is path-sensitive, as it detects reuse even when it originates in a different instruction along each control flow path. Furthermore, the analysis is comprehensive, as it treats scalar, array and pointer-based loads uniformly. In evaluating the analysis, we compare it with an ideal analysis. By observing the run-time stream of memory references, we collect all PRE-exploitable reuse and treat it as the ideal analysis performance. To compare the (static) load-reuse analysis with the (dynamic) ideal reuse, we use an estimator algorithm that computes, given a dam-flow solution and a program profile, the dynamic amount of reuse detected by the analysis. We developed a family of estimators that differ in how well they bound the profiling error inherent in the edge profile. By bounding the error, the estimators offer a precise and practical method for determining the run-time optimization benefit. Our experiments show that about 55% of loads executed in Spec95 exhibit reuse. Of those, our analysis exposes about 80%.

In this paper, we demonstrate how Functional Reactive Programming (FRP), a framework for the description of interactive systems, can be extended to encompass parallel systems. FRP is based on Haskell, a purely functional programming language, and incorporates the concepts of time variation and reactivity. Parallel FRP serves as a declarative system model that may be transformed into a parallel implementation using the standard program transformation techniques of functional programming. The semantics of parallel FRP include non-determinism, enhancing opportunities to introduce parallelism. We demonstrate a variety of program transformations based on parallel FRP and show how a FRP model may be transformed into explicitly parallel code. Parallel FRP is implemented using the Linda programming system to handle the underlying parallelism. As an example of parallel FRP, we show how a specification for a web-based online auctioning system can be transformed into a parallel implementation.

Improving the design quality of large object-oriented systems during maintenance and evolution is widely regarded as a high-priority objective. Furthermore, for such systems that are subject to frequent modifications, detection and correction of design defects may easily become a very complex task that is even not tractable for manual handling. Therefore, the use of automatic or semi-automatic detection and correction techniques and tools can assist reengineering activities. This paper proposes a framework whereby object-oriented metrics can be used as indicators for automatically detecting situations for particular transformations to be applied in order to improve specific design quality characteristics.

The many approaches which have been proposed in the literature for proving the correctness of unfold/fold program transformations, consist in associating suitable well-founded orderings with the proof trees of the atoms belonging to the least Herbrand models of the programs. In practice, these orderings are given by 'clause measures', that is, measures associated with the clauses of the programs to be transformed. In the unfold/fold transformation systems proposed so far, clause measures are fixed in advance, independently of the transformations to be proved correct. In this paper we propose a method for the automatic generation of the clause measures which, instead, takes into account the particular program transformation at hand. During the transformation process we construct a system of linear equations and inequations whose unknowns are the clause measures to be found, and the correctness of the transformation is guaranteed by the satisfiability of that system. Through some examples we show that our method is able to establish in a fully automatic way the correctness of program transformations which, by using other methods, are proved correct at the expense of fixing sophisticated clause measures.

High-performance, I/O-intensive applications often require complicated, split-phase, event-based implementations. Threads appear to be an attractive alternative because they allow the programmer to write a single sequence of operations and ignore the points at which the execution may be blocked. Unfortunately, the typical amount of memory required to support this technique prevents applications from scaling to large numbers of threads. Rather than relying on event-based programming, we use a program transformation to provide a lowcost thread implementation. This transformation retains the advantages of user-scheduled, eventbased programs, yet efficiently supports large numbers of threads. We replace the standard Java thread mechanism with lightweight PicoThreads and a cooperative, event-based, user-level scheduler. This is accompanied by a PicoThread-aware, asynchronous network library. To evaluate our implementation, we measure the performance of a simple web crawler running thousands of threads. Our results show that PicoThreaded programs perform comparably or substantially better than threaded programs when using large numbers of threads.