Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
1999-08-02
2001-05-22
Powell, Mark R. (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
C717S152000, C717S152000
Reexamination Certificate
active
06237141
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of Invention
The present invention relates generally to methods and apparatus for optimizing the execution of software applications. More particularly, the present invention relates to methods and apparatus for dynamically determining whether portions of code should be interpreted or compiled in order to optimize a software application during run-time.
2. Description of the Relevant Art
The use of computer systems which share resources across a network of computer systems, e.g., local area networks, intranets and internets, is increasing. Accordingly, software applications, or computer programs, may be delivered in different formats to different computer systems, due to the fact that a particular computer system generally requires software applications to be in a format that is specific to that particular computer system. Alternatively, the computer programs may be delivered to a computer system in a machine-independent form, i.e., as byte codes, in order to enable one form of a computer program to be utilized by many different computer systems.
When computer programs are delivered in a machine independent form, the programs may be interpreted directly, or the programs may be translated into machinedependent code, i.e., “machine code.” Programs which are interpreted directly occupy less space in a computer system than programs which are translated into machine code. However, programs which are interpreted directly have slower execution speeds than programs which are translated into machine code, in most cases. As such, the determination of whether or not to interpret a computer program directly, in lieu of translating the computer program into machine code, is often based on the relative importance of space in relation to execution speed.
As mentioned above, computer programs may be delivered as byte codes to a computer system. Computer systems which receive byte codes generally include compilers which are used to compile byte codes at run-time. Compiling byte codes at run-time entails translating the byte codes into machine code.
FIG. 1
a is a block diagram representation of a computer system with a byte code compiler. Byte codes
104
, which may be arranged as a computer program, are delivered, or otherwise provided, to a computer system
105
. Byte codes
104
may generally be provided by a variety of different sources. When byte codes
104
, are executed, byte codes
104
are compiled using a compiler
106
at run-time. Compiled code
108
, which is produced by compiler
106
, is generally machine-dependent code that is specific to, and may be executed within, system
105
. That is, compiler
106
translates byte codes
104
into compiled code
108
at run-time.
Some computer systems enable portions of previously compiled code to be “re-compiled” into more efficiently executed forms when those portions of previously compiled code are found to be executed repeatedly. In other words, a second, more costly, compilation process may be used to compile repeatedly invoked, previously compiled code to allow for more efficient execution of the repeatedly invoked code.
FIG. 1
b
is a block diagram representation of a computer system with uses two compilation processes. A computer system
115
includes a first compiler
116
and a second compiler
122
. Byte codes
114
are provided to computer system
115
for execution. At run-time, first compiler
116
translates byte codes
114
into machine-dependent compiled code
118
, or machine code.
Machine-dependent compiled code
118
is executed, and different methods contained within machine-dependent compiled code
118
are tracked to determine when methods which are most often invoked are to be compiled with second compiler
122
. When highly, or repeatedly, executed compiled code
120
is identified, the highly executed compiled code
120
is re-compiled in order to increase the overall execution speed of a computer program. As such, second compiler
122
translates highly executed compiled code
120
into recompiled highly executed code
124
.
Second compiler
122
is often a slower compiler than first compiler
116
, although code compiled using second compiler
122
typically executes more efficiently than code compiled using first compiler
116
. Therefore, the determination of when to re-compile highly executed compiled code
120
generally involves a trade-off between additional compilation overhead, with respect to overall run-time, and the improved efficiency afforded by re-compiled highly executed code
124
.
One system which allows previously compiled code to be re-compiled for increased efficiency is the Self system, developed by Urs Hölzle and David Unger at Sun Microsystems, Inc. of Palo Alto, Calif. In the Self system, the determination of whether to re-compile previously compiled code is made based on how many times a specific portion of compiled code, such as a method, has been called. If the method has been invoked more times than a fixed limiting value, then the method is recompiled. The fixed limiting value is essentially a fixed threshold, which reflects the number of times the method is to be invoked before the method is re-compiled to increase efficiency in execution.
Significant compilation overhead is often added to the overall execution of a program when a compiler is used to translate byte codes into machine-dependent code at run-time. As such, although machine code may execute much faster than interpreted code, always compiling all parts of a program into machine code prior to executing the machine code may not be desirable if the increased execution speed does not compensate for the overhead associated with compiling the program. In other words, a program may execute more quickly as interpreted code in the event that the amount of time spent compiling the program is not recovered during the execution of the program.
In a system such as the Self system, although re-compiling routines in a compiled program may serve to enable the program to execute more efficiently, the use of a fixed limit to determine when a routine should be recompiled may instead result in an inefficient, e.g., non-optimal, execution. By way of example, if the fixed limit is set such that substantially every routine in a program is re-compiled, then the increased execution speed gained with the re-compilation may not compensate for the compilation overhead associated with the re-compilation.
Therefore, what is needed is a method for efficiently executing programs in byte code format. More specifically, what is desired is a method for dynamically determining when portions of a computer program should be interpreted, and when portions of the computer program should be translated into machine code, to thereby ensure an efficient execution of the computer program.
SUMMARY OF THE INVENTION
Methods and apparatus for dynamically determining whether portions of byte code should be interpreted or compiled in order to optimize a software application during run-time are disclosed. According to one aspect of the present invention, when a selected method is invoked, it is initially interpreted. An invocation tracker tracks the number of invocations of the selected method. When the number of invocations of the selected method exceeds a threshold value, the method is compiled. By independently tracking the usage of various methods or other code segments, a more intelligent decision can be made as to which methods should be compiled, and which methods should remain interpreted. In some embodiments, a single threshold value may be used for all of the methods. In other embodiments, a plurality of threshold values may be used, with each threshold value being associated with one or more methods. With the later arrangement, the threshold values associated with different methods may be varied.
In one embodiment, the a compilation overhead associated with compiling the selected method is measured and the threshold value is adjusted accordingly when it is determined that the compilation overhead is not within the accepta
Griesemer Robert
Griswold David
Holzle Urs
Beyer Weaver & Thomas LLP
Nguyen-Ba Hoang-Vu Antony
Powell Mark R.
Sun Microsystems Inc.
LandOfFree
Method and apparatus for dynamically optimizing byte-coded... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method and apparatus for dynamically optimizing byte-coded..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method and apparatus for dynamically optimizing byte-coded... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2525397