We are designing and implementing a flexible infrastructure for mobile-object systems. Two fundamental innovations distinguish our architecture from other proposed solutions. First, our representation of mobile code is based on adaptive compression of syntax trees. Not only is this representation more than twice as dense as Java byte-codes, but it also encodes semantic information on a much higher level than linear abstract-machine representations such as p-code or Java byte-codes. The extra structural information that is contained in our mobile-code format is directly beneficial for advanced code optimizations. Second, our architecture achieves superior run-time performance by integrating the activity of generating executable code into the operating system itself. Rather than being an auxiliary function performed off-line by a stand-alone compiler, code generation constitutes a central, indispensable service in our system. Our integral code generator has two distinct modes of operation: instantaneous load-time translation and continuous dynamic re-optimization. In contrast to just-in-time compilers that translate individual procedures on a call-by-call basis, our system's integral code-generator translates complete code-closures in a single burst during loading. This has the apparent disadvantage that it introduces a minor delay prior to the start of execution. As a consequence, to some extent we have to favor compilation speed over code quality at load time. But then, the second operation mode of our embedded code generator soon corrects this shortcoming. Central to our run-time architecture is a thread of activity that continually optimizes all of the already executing software in the background. Since this is strictly a re-compilation of already existing code, and since it occurs completely in the background, speed is not critical, so that aggressive, albeit slow, optimization techniques can be employed. Upon completion, the previously executing version of the same code is supplanted by the newly generated one and re-optimization starts over. By constructing globally optimized code-images from mobile software components, our architecture is able to reconcile dynamic composability with the run-time efficiency of monolithic applications.
[1]
Michael Franz,et al.
The Oberon System family
,
1995,
Softw. Pract. Exp..
[2]
Michael Franz,et al.
Technological Steps toward a Software Component Industry
,
1994,
Programming Languages and System Architectures.
[3]
Scott A. Mahlke,et al.
Using profile information to assist classic code optimizations
,
1991,
Softw. Pract. Exp..
[4]
Douglas J. Ingalls.
The execution time profile as a programming tool
,
1971
.
[5]
Michael Franz.
Emulating an operating system on top of another
,
1993,
Softw. Pract. Exp..
[6]
Michael Franz,et al.
Slim binaries
,
1997,
CACM.
[7]
Jack W. Davidson,et al.
A retargetable instruction reorganizer
,
1986,
SIGPLAN '86.
[8]
Kathleen Jensen,et al.
Pascal-P Implementation Notes
,
1981,
Pascal - The Language and its Implementation.
[9]
Frank Yellin,et al.
The Java Virtual Machine Specification
,
1996
.
[10]
Christopher W. Fraser,et al.
Code selection through object code optimization
,
1984,
TOPL.
[11]
Niklaus Wirth,et al.
The oberon system
,
1989,
Softw. Pract. Exp..
[12]
David William Barron.
Pascal - The Language and its Implementation
,
1981,
Pascal - The Language and its Implementation.
[13]
Michael Steffen Oliver Franz,et al.
Code_generation On_the_fly: a Key to Portable Software
,
1994
.
[14]
Gilbert Joseph Hansen,et al.
Adaptive systems for the dynamic run-time optimization of programs.
,
1974
.
[15]
Terry A. Welch,et al.
A Technique for High-Performance Data Compression
,
1984,
Computer.
[16]
David W. Wall,et al.
Experience with a software-defined machine architecture
,
1992,
TOPL.
[17]
Niklaus Wirth,et al.
The programming language oberon
,
1988,
Softw. Pract. Exp..
[18]
Urs Hölzle,et al.
Eliminating Virtual Function Calls in C++ Programs
,
1996,
ECOOP.
[19]
Niklaus Wirth,et al.
Project Oberon - the design of an operating system and compiler
,
1992
.