Specializing programs with respect to run-time values has been shown to drastically improve code performance on realistic programs ranging from operating systems to graphics. Recently, various approaches to specializing code at run-time have been proposed. However, these approaches still suffer from shortcomings that limit their applicability: they are manual, too expensive, or require programs to be written in a dedicated language. We solve these problems by introducing new techniques to implement run-time specialization. The key to our approach is the use of code templates. Templates are automatically generated from ordinary programs and are optimized before run time, allowing high-quality code to be quickly generated at run time. Experimental results obtained on scientific and graphics code indicate that our approach is highly effective. Little run-time overhead is introduced, since code generation primarily consists of copying instructions. Run-time specialized programs run up to 1...

Designing and implementing generic software components is encouraged by languages such as object-oriented ones and commonly advocated in most application areas. Generic software components have many advantages among which the most important is reusability. However, it comes at a price: genericity often incurs a loss of efficiency. This paper presents an approach aimed at reconciling genericity and efficiency. To do so, we introduce declarations to the Java language to enable a programmer to specify how generic programs should be specialized for a particular usage pattern. Our approach has been implemented as a compiler from our extended language into standard Java. 1 Introduction The object-oriented paradigm has well-recognized advantages for application design, and more specifically for program structure. It makes it possible to decompose an application in terms of well-defined, generic components, closely corresponding to the structure of the modeled problem. This structuring leads...

Automatic program specialization can derive e#cient implementations from generic components, thus reconciling the often opposing goals of genericity and e#ciency. This technique has proved useful within the domains of imperative, functional, and logical languages, but so far has not been explored within the domain of object-oriented languages.

Flexibility is recognized as a key feature in structuring software, and many architectures have been designed to that effect. However, they often come with performance and code size overhead, resulting in a flexibility vs. efficiency dilemma. The source of inefficiency in software architectures can be identified in the data and control integration of components, because flexibility is present not only at the design level but also in the implementation. We peopose

Much research effort in program transformation has traditionally been devoted to better compile programs. Key examples include program optimization and program parallelization. Program transformation has sometimes been used in program development to derive implementations from high-level specifications. This position paper advocates another promising application of program transformation: program adaptation. That is, the ability for a program to adapt to the context in which it is used. We claim that program adaptation is a key technique in the program development process and is applicable to real size systems.

Fast remote procedure call (RPC) is a major concern for distributed systems. Many studies aimed at efficient RPC consist of either new implementations of the RPC paradigm or manual optimization of critical sections of the code. This paper presents an experiment that achieves automatic optimization of an existing, commercial RPC implementation, namely the Sun RPC. The optimized Sun RPC is obtained by using an automatic program specializer. It runs up to 1.5 times faster than the original Sun RPC. Close examination of the specialized code does not reveal further optimization opportunities which would lead to significant improvements without major manual restructuring. The contributions of this work are: (1) the optimized code is safely produced by an automatic tool and thus does not entail any additional maintenance; (2) to the best of our knowledge this is the first successful specialization of mature, commercial, representative system code; and (3) the optimized Sun RPC runs significantly faster than the original code.

Most operating systems heavily rely on intermediate data structures for modularity or portability reasons. This paper extends program specialization to eliminate these intermediate data structures in a uniform manner. Our transformation process is fully automatic and is based on a specializer for C programs, named Tempo. The key advantage of our approach is that the degree of safety of the source program is preserved by the optimization. As a result, mature system code can be reused without requiring additional verification. Our preliminary results on the automatically optimized RPC code are very promising in that they are identical to the results we obtained by manual specialization of the same code. In this last experiment, performance measurement of the specialized RPC fragments shows a minimal speedup of 30% compared to the non-specialized code. Elimination of intermediate data structures is part of our research effort towards optimizing operating system components via program sp...

Abstract. Code specialization is an approach that can be used to improve the sequence of optimizations to be performed by the compiler. The performance of code after specialization may vary, depending upon the structure of the application. For FFT libraries, the specialization of code with different parameters may cause an increase in code size, thereby impacting overall behavior of applications executing in environment with small instruction caches. In this article, we propose a new approach for specializing FFT code that can be effectively used to improve performance while limiting the code increase by incorporating dynamic specialization. Our approach makes use of a static compile time analysis and adapts a single version of code to multiple values through runtime specialization. This technique has been applied to different FFT libraries over Itanium IA-64 platform using icc compiler v 9.0. For highly efficient libraries, we are able to achieve speedup of more than 80 % with small increase in code size. 1

Specializing programs with respect to run-time invariants is an optimization technique that has shown to improve the performance of programs substantially. It allows a program to adapt to execution contexts that are valid for a limited time. Run-time specialization is being actively investigated in a variety of areas. For example, recently, major operating system research projects have been focusing on run-time specialization as a means to obtain efficiency from highly extensible and parameterized systems. This paper describes a general approach to run-time specialization. For a given program and a declaration of its runtime invariants, it automatically produces source templates at compile time, and transforms them so that they can be processed by a standard compiler. At run time, only minor operations need to be performed: selecting and copying templates, filling holes with run-time values, and relocating jump targets. As a consequence, run-time specialization is performed very effi...