The last years have witnessed a flurry of new results in the area of partial evaluation. These tutorial notes survey the field and present a critical assessment of the state of the art. 1 Introduction Partial evaluation is a source-to-source program transformation technique for specializing programs with respect to parts of their input. In essence, partial evaluation removes layers of interpretation. In the most general sense, an interpreter can be defined as a program whose control flow is determined by its input data. As Abelson points out, [43, Foreword], even programs that are not themselves interpreters have important interpreter-like pieces. These pieces contain both compile-time and run-time constructs. Partial evaluation identifies and eliminates the compile-time constructs. 1.1 A complete example We consider a function producing formatted text. Such functions exist in most programming languages (e.g., format in Lisp and printf in C). Figure 1 displays a formatting functio...

Partial evaluation provides a unifying paradigm for a broad spectrum of work in

ing with credit is permitted. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from Publications Dept, ACM Inc., fax + 1 (212) 869-0481, or <permissions@acm.org>. 1 Specializing Shaders Brian Guenter, Todd B. Knoblock, Erik Ruf * Microsoft Research Abstract We have developed a system for interactive manipulation of shading parameters for three dimensional rendering. The system takes as input user-defined shaders, written in a subset of C, which are then specialized for interactive use. Since users typically experiment with different values of a single shader parameter while leaving the others constant, we can benefit by automatically generating a specialized shader that performs only those computations depending on the parameter being varied; all other values needed by the shader can be precomputed and cached. The specialized shaders are as much as 95 times faster than the origi...

Automatic program specialization has numerous application areas ranging from specialization of scientific computation to automatic compiler generation. During the last decade, several automatic partial evaluators have been developed and demonstrated their usefulness. However, none of these have both been for a typed imperative language and self-applicable. The main content of this thesis is the development of an automatic self-applicable program specializer for a substantial subset of the C programming language. The use of an imperative language introduce many problems not present in partial evaluation of functional languages. New problems addressed and solved in this thesis includes handling of static side-effects under dynamic control, treatment of the imperative data structures arrays and structures, partially static data structures and specialization time splitting of these, and representation of values and programs for efficient self-application. In the thesis we recall the founda...

In order to exploit specialization opportunities that exist in programs written by researchers outside of the programming language community, a partial evaluator needs to effectively treat existing realistic applications. Our empirical studies have demonstrated real-sized applications extensively use non-liftable values such as pointers and data structures. Therefore, it is essential that the binding-time analysis accurately treats nonliftable values. To achieve this accuracy, we introduce the notion of use sensitivity, and present a use-sensitive binding-time analysis for C programs which is obtained by a forward analysis followed by a backward analysis. This analysis has been implemented and integrated into our partial evaluator for C, called Tempo. To validate the effectiveness of our analysis and demonstrate that use sensitivity is critical to obtain highly-specialized programs, we have conducted experimental studies on various components of existing operating systems code. Our res...

Abstract not found

Profile­-driven optimizations and dynamic optimization through specialization have taken optimizations to a new level. By using actual run­time data, optimizers can generate code that is specially tuned for the task at hand. However, most existing compilers that perform these optimizations require separate test runs to gather profile information, and/or user annotations in the code. In this thesis, I describe run­time optimizations that a dynamic compiler can perform automatically --- without user annotations --- by utilizing real­time performance data. I describe the implementation of the dynamic optimizations in the framework of a Java Virtual Machine and give performance results.

Run-time code generation (RTCG) has been shown to be an effective optimiza-tion. Systems such as DyC, ’C, Tempo, and Fabius have demonstrated order of magnitude improvements on benchmark programs. In addition, by using binding time analyses, the benefits of RTCG can be obtained with minimal programmer effort. Languages like MetaML and PML have explored type systems for RTCG that can ensure programs using RTCG do not crash. In earlier work we presented Cyclone – a type-safe language based on C with support for RTCG. The safety guarantee provided by a type-safe source language may fail to hold of the compiler’s output. Rather than trusting that the compiler is correctly im-plemented, we can use a certifying compiler to check that the output is type safe. A certifying compiler produces a certificate, along with the object code, which together can be used to verify that the object code is safe. Here we develop a certifying and optimizing compiler for Cyclone supporting run-time code generation. The output of our compiler is TAL/T – x86 object code augmented with typing annotations. Part of our system is a verifier for TAL/T capable of mechanically checking that TAL/T programs are type safe – they cannot crash. This guarantee provides increased confidence in the compiler-generated code. The contributions of this thesis include: 1) a framework for compiling and opti-mizing programs supporting RTCG, 2) a formal proof that well-typed TAL/T pro-grams cannot crash, and 3) an evaluation of our compiler using micro-benchmarks, a raytracer, and an instruction set simulator.

Object-oriented simulations in an object-oriented environment are easier to construct and maintain than conventionally programmed simulations. Unfortunately, they are also slower because of message passing and other runtime overhead. We have developed an automatic program transformer that solves the efficiency problem for a large class of simulation programs. It automatically constructs an efficient program from the inefficient simulation program and the objects it will receive as input. Depending on the object-oriented language used, and the application, the new program can be more than an order of magnitude faster than the original program. In this paper we describe the benefits of object-oriented simulation, our transformer, and how such dramatic speedups are possible. This research has been supported in part by NSF Contract No. MIP-8902764, and in part by Advanced Research Projects Agency, Department of Defense, Contract No. N0039-91-K-0138. Key Words and Phrases: Object-Oriented S...

In this report describes techniques required to generate efficient compilers for realistic languages by partial evaluation and to what extent these techniques can be automated. It also describes a large application where a realistic compiler was generated for a strongly typed lazy functional language. Compiler generation is often emphasized as being the most important application of partial evaluation, but most of the larger practical applications have been outside this field. Especially, no one has generated compilers for languages other than small example languages. It is well known how compilers can be generated from interpreters by partial evaluation. So we show how to obtain interpreters (in strict functional languages) from formal language descriptions. One way is to specialize a meta-interpreter with respect to language definitions to generate interpreters. This meta-interpreter approach has the advantage that one may define new and better definition languages without having to write new partial evaluators. We have studied what kind of binding time improvements of interpreters are needed to obtain compilers which are both efficient and generate good target code.