In this dissertation, we show how a relatively simple and extremely fast interprocedural optimization algorithm can be used to optimize many of the expensive features of statically typed, object-oriented languages --- in particular, C++ and Java. We present a new program analysis algorithm, Rapid Type Analysis, and show that it is fast both in theory and in practice, and significantly out-performs other "fast" algorithms for virtual function call resolution. We present optimization algorithms for the resolution of virtual function calls, conversion of virtual inheritance to direct inheritance, elimination of dynamic casts and dynamic type checks, and removal of object synchronization. These algorithms are all presented within a common framework that allows them to be driven by the information collected by Rapid Type Analysis, or by some other type analysis algorithm. Collectively, the optimizations in this dissertation free the programmer from having to sacrifice modularity and extensibility for performance. Instead, the programmer can freely make use of the most powerful features of object-oriented programming, since the optimizer will remove unnecessary extensibility from the program.

Object-oriented applications may contain data members that can be removed from the application without affecting program behavior. Such "dead" data members may occur due to unused functionality in class libraries, or due to the programmer losing track of member usage as the application changes over time. We present a simple and efficient algorithm for detecting dead data members in C++ applications. This algorithm has been implemented using a prototype version of the IBM VisualAge C++ compiler, and applied to a number of realistic benchmark programs ranging from 600 to 58,000 lines of code. For the non-trivial benchmarks, we found that up to 27.3% of the data members in the benchmarks are dead (average 12.5%), and that up to 11.6% of the object space of these applications may be occupied by dead data members at run-time (average 4.4%). 1 Introduction Object-oriented applications may contain data members (instance variables) that can be removed from the application without affecting p...

We describe two generic optimization techniques to improve run-time performance of C++ virtual function calls: type specification and type prediction. Both involve program analysis that results in a set of call sites to be optimized, and code transformations that replace the original dispatching mechanism in these sites by more efficient call expressions. We implement two special cases. The first is a type-specification optimization, called unique name, that requires static global view of the whole program in order to substitute indirect virtual function call sites by direct calls. The other is a type-prediction kind of optimization, referred to as single type prediction, that uses type-profiling information to replace virtual function calls by conditional expressions which involve direct function calls.

Increasing code complexity can become a serious issue even in a software project as small as a microkernel. This paper reports on how we address this problem in the L4Ka::Pistachio microkernel. We define multiple configuration dimensions and assign code fragments to the appropriate dimensions. The kernel build system combines code fragments for the specific configuration. While this approach avoids the run-time costs of a full-blown object-oriented design, it does not avoid code duplication. To address the code duplication problem, we model the code selection with class hierarchies using multiple inheritance and polymorphism. However, the run-time overhead of virtual functions results in a serious (2x) performance hit for the time-critical kernel functionality. To address this latter problem, we apply class flattening to completely eliminate the overhead of virtual function calls. Our evaluation shows that a kernel with flattened class hierarchies performs as fast as one without class hierarchies. Thus, advanced object-oriented programming techniques need no longer be avoided in performance-focused microkernels.