The object-oriented style of programming facilitates program adaptation and enhances program genericness, but at the expense of efficiency. We demonstrate experimentally that state-of-the-art Java compilation technology fails to compensate for the use of object-oriented abstractions to implement generic programs, and that program specialization can be used to eliminate these overheads. We present an automatic program specializer for Java, and demonstrate experimentally that significant speedups in program execution time can be obtained through automatic specialization. Although automatic program specialization could be seen as overlapping with existing optimizing compiler technology, we show that specialization and compiler optimization are in fact complementary. 1 Introduction Object-oriented languages encourage a style of programming that facilitates program adaptation. Encapsulation enhances code resilience to program modifications and increases the possibilities for di...

Abstract. Embedded software requires concurrency formalisms other than threads and mutexes used in traditional programming languages like C. Actor-oriented design presents a high level abstraction for composing concurrent components. However, high level abstraction often introduces overhead and results in slower system. We address the problem of generating efficient implementation for the systems with such a high level description. We use partial evaluation as an optimized compilation technique for actor-oriented models. We use a helper-based mechanism, which results in flexible and extensible code generation framework. The end result is that the benefit offered by high level abstraction comes with (almost) no performance penalty. The code generation framework has been released in open source form as part of Ptolemy II 6.0.1. 1

Object-oriented and generic programming are both supported in C++. The former provides high expressiveness whereas the latter leads to more efficient programs by avoiding dynamic typing. This paper presents SCOOP, a new paradigm which enables both classical object-oriented design and high performance in C++ by mixing object-oriented programming and generic programming. We show how classical and advanced object-oriented features such as virtual methods, multiple inheritance, argument covariance, virtual types and multimethods can be implemented in a fully statically typed model, hence without run-time overhead.

Recent research suggests that the goal of fully automatic and reliable program generation for a broad range of applications is coming nearer to feasibility. However, several interesting and challenging problems remain to be solved before it becomes a reality. Solving them is also necessary, if we hope ever to elevate software engineering from its current state (a highly-developed handiwork) into a successful branch of engineering, capable of solving a wide range of new problems by systematic, well-automated and well-founded methods.

Abstract. The object-oriented style of programming facilitates program adaptation and enhances program genericness, but at the expense of efficiency. Automatic program specialization can be used to generate specialized, efficient implementations for specific scenarios, but requires the program to be structured appropriately for specialization and is yet another new concept for the programmer to understand and apply. We have unified automatic program specialization and inheritance into a single concept, and implemented this approach in a modified version of Java named JUST. When programming in JUST, inheritance is used to control the automatic application of program specialization to class members during compilation to obtain an efficient implementation. This paper presents the language JUST, which integrates object-oriented concepts, block structure, and techniques from automatic program specialization to provide both a generative programming language where object-oriented designs can be efficiently implemented and a simple yet powerful automatic program specializer for an object-oriented language. 1

The use of partial evaluation for specializing programs written in imperative languages such as C and Java is hampered by the difficulty of controlling the specialization process. We have developed a simple, declarative language for controlling the specialization of Java programs, and interfaced this language with the JSpec partial evaluator for Java. This language, named Pesto, allows declarative specialization of programs written in an object-oriented style of programming. The Pesto compiler automatically generates the context information needed for specializing Java programs, and automatically generates guards that enable the specialized code in the right context.

This is an evolving document describing sRuby, a subset of Ruby that can be easily compiled to fast low-level code. The purpose of developing sRuby is to use it to implement a Ruby virtual machine. However, we anticipate that it can be used to write Ruby extensions that needs to bridge the gap between Ruby and a low-level language (C) in an easy and portable way. 1

riented program can be elegantly expressed by encapsulating the specialized methods into an aspect. Concretely, the JSpec specializer generates specialized programs as AspectJ aspects [13], which are woven into the generic program as part of the compilation process. Specialization of an object-oriented program can be controlled using the specialization class framework [12]. A specialization class provides specialization information about a class in the program, by indicating what information is 1 Unneeded class members can be removed in a subsequent pass, for example using class hierarchy specialization [9]. known and what methods to specialize. Specialization classes are non-intrusive in that they are separate from the main program. A collection of specialization classes that together specify a complete specialization scenario (i.e., all configuration parameters of a program component) can be considered a declarative aspect that extends the pro

We present a value profiler for object-oriented programs that counts frequencies parameters to method calls. It is aimed at identifying methods that can be optimized by program specialization techniques. By adding timestamps to objects, the profiler accurately tests equality over mutable objects on a per-method basis. Our experiments with a 64602 lines of Java program showed that the profile report can reduce effort at manually finding the target methods of optimization, which speeded the overall execution time up more than 10%.

One of the major advantages of object-oriented languages is that they allow the easy construction of general software components, but this is achieved at high cost in terms of inefficiency. We can attenuate this inefficiency by adapting programs automatically to the environment where they are inserted. Partial evaluation is a program specialization technique to achieve this task, transforming a program into a more specialized version of it. Off-line partial evaluators perform as a first step a binding-time analysis, BTA, that determines which parts of the program can be executed in advance and annotates them accordingly. The BTA only works with the knowledge that some input values are known and some are not. Then, the analysis propagates this knowledge through the program and annotates each program construct, indicating whether the knowledge of the input value will make it possible to compute this program construct or not. Consequently, the design of a correct and precise BTA is of primary importance to perform efficient off-line partial evaluation. The mission of this work was to lay the foundations for that design. Thus, we have