U.S. patent application number 11/189411 was filed with the patent office on 2006-02-02 for method and related system of dynamic compiler resolution.
This patent application is currently assigned to Texas Instruments Incorporated. Invention is credited to Gilbert Cabillic, Jean-Philippe Lesot, Mikael Peltier.
Application Number | 20060026580 11/189411 |
Document ID | / |
Family ID | 34931294 |
Filed Date | 2006-02-02 |
United States Patent
Application |
20060026580 |
Kind Code |
A1 |
Cabillic; Gilbert ; et
al. |
February 2, 2006 |
Method and related system of dynamic compiler resolution
Abstract
A method and related system of dynamic compiler resolution. Some
of the illustrative embodiments are a computer-implemented method
comprising compiling a source file containing an application
program (the compiling creates a destination file containing a
compiled version of the application program), and inserting in the
compiled version of the application program a series of commands
that (when executed at run time of the application program)
generate an optimized code portion using a value available at run
time.
Inventors: |
Cabillic; Gilbert; (Brece,
FR) ; Peltier; Mikael; (Bourg-des-Comptes, FR)
; Lesot; Jean-Philippe; (Etrelles, FR) |
Correspondence
Address: |
TEXAS INSTRUMENTS INCORPORATED
P O BOX 655474, M/S 3999
DALLAS
TX
75265
US
|
Assignee: |
Texas Instruments
Incorporated
Dallas
TX
|
Family ID: |
34931294 |
Appl. No.: |
11/189411 |
Filed: |
July 26, 2005 |
Current U.S.
Class: |
717/151 ;
711/E12.067 |
Current CPC
Class: |
Y02D 10/13 20180101;
G06F 9/30174 20130101; G06F 12/1081 20130101; Y02D 10/00 20180101;
G06F 9/45504 20130101; G06F 2212/6012 20130101; G06F 12/0802
20130101 |
Class at
Publication: |
717/151 |
International
Class: |
G06F 9/45 20060101
G06F009/45 |
Foreign Application Data
Date |
Code |
Application Number |
Jul 27, 2004 |
EP |
04291918.3 |
Claims
1. A computer-implemented method comprising: compiling a source
file containing an application program, the compiling creates a
destination file containing a compiled version of the application
program; and inserting in the compiled version of the application
program a series of commands that, when executed at run time of the
application program, generate an optimized code portion using a
value available at run time.
2. The computer-implemented method as defined in claim 1 wherein
compiling further comprises compiling a source file containing
human-readable source code of the application program.
3. The computer-implemented method as defined in claim 1 wherein
compiling creates the compiled version of the application program
that is executable.
4. The computer-implemented method as defined in claim 3 wherein
compiling creates the compiled version of the application program
that is directly executable by a processor.
5. The computer-implemented method as defined in claim 3 wherein
compiling creates the compiled version of the application program
executable on a processor by way of an interpreter.
6. The computer-implemented method as defined in claim 1 further
comprising, after inserting, replacing the series of commands with
the optimized code portion.
7. The computer-implemented method as defined in claim 1 wherein
the compiling and inserting take place prior to execution of the
application program.
8. The computer-implemented method as defined in claim 1 wherein
the compiling and inserting take place on a first portion of the
application program while a second portion of the application
program is executed.
9. A computer-readable medium storing a compiler program that, when
executed by a processor, performs a method comprising: compiling
source code of an application program to create a compiled version
of the application program; and inserting in the compiled version
of the application program a series of commands that, when executed
at run time of the application program, generate optimized code
using a value available at run time.
10. The computer-readable medium as defined in claim 9 wherein
compiling further comprises compiling to create an executable
version of the application program.
11. The computer-readable medium as defined in claim 10 wherein
compiling further comprises compiling to create the compiled
version of the application program that is directly executable by a
processor.
12. The computer-readable medium as defined in claim 10 wherein
compiling further comprises compiling to create the compiled
version of the application program that is platform independent and
executable on a processor by way of an interpreter.
13. The computer-readable medium as defined in claim 9 wherein
compiling further comprises the source code of the application
program that is human readable.
14. The computer-readable medium as defined in claim 9 wherein the
method further comprises, after inserting, replacing the series of
commands in the compiled version of the application program with
the optimized code.
15. The computer-readable medium as defined in claim 9 wherein the
compiling and inserting take place prior to execution of the
application program.
16. The computer-readable medium as defined in claim 9 wherein the
compiling and inserting takes place on a first portion of the
application program while a second portion of the application
program is executed.
17. A system comprising: a memory, wherein the memory contains a
source file of an program; and a first processor coupled to the
memory; wherein the first processor is configured to compile the
program of the source file to create a compiled program, and
wherein the processor is configured to insert in the compiled
program a series of commands that, when executed at run time,
generate an optimized code portion using a value available at run
time.
18. The system as defined in claim 17 wherein the source file in
the memory is a human readable source code file for the application
program.
19. The system as defined in claim 17 wherein the compiled version
of the program in the destination file is executable on the
processor by way of an interpreter program.
20. The system as defined in claim 17 wherein the compiled version
of the program in the destination file is directly executable on
the processor.
21. The system as defined in claim 17 further comprising: a second
processor coupled to the memory and the first processor; wherein
the second processor is configured to directly execute at least one
command of the compiled program.
22. The system as defined in claim 17 further comprising wherein
the first processor is configured to create a first portion of the
compiled program while a second portion of the compiled program
executes on one or both the first and second processors.
23. The system as defined in claim 17 further comprising wherein
the first processor is configured to create the compiled program
prior to execution of any portion of the compiled program.
Description
CROSS-REFERENCE TO RELATED APPLICATIONS
[0001] This application claims the benefit of European Patent
Application No. 04291918.3, filed Jul. 27, 2004, incorporated by
reference herein as if reproduced in full below. This application
is related to co-pending and commonly assigned application Ser. No.
______ [atty. docket TI-38588 (1962-22900)] entitled "Method And
System Of Adaptive Compiler Resolution."
BACKGROUND OF THE INVENTION
[0002] 1. Technical Field of the Invention
[0003] Embodiments of the present invention relate to compilers and
creation of optimized executable code.
[0004] 2. Background Information
[0005] A compiler is a software program that takes a source file
containing a program in a particular form, and converts the program
to another form. In some cases, the compiler starts with a
human-readable source code file (e.g. a program written in JAVA.TM.
or C++) and converts or compiles to a binary file that may be
directly executable or that may require interpretation or further
compiling.
[0006] Compilers come in several varieties, such as static
compilers (sometimes referred to as "ahead-in-time" compilers) or
dynamic compilers (sometimes referred to as "just-in-time"
compilers). Static compilers complete their work on the source file
before the program is executed. Dynamic compilers, by contrast,
compile the source file during execution of the program embodied in
the source file. Both static and dynamic compilers also may perform
optimization as part of the compiling processing, possibly to
reduce execution time.
[0007] Static compilers perform some optimizations, such as
inlining of methods, but in many cases optimization requires the
knowledge of values of runtime parameters which are not known when
static compiling is performed. Dynamic compilers thus have the
advantage of having available the values of runtime parameters, and
thus may make optimizations based on those parameters, but gain
realized by optimization performed by dynamic compilers is offset
by the fact the compiler too is running and sharing time on the
processor, thus slowing the overall execution of the application
program.
SUMMARY
[0008] The problems noted above are solved in large part by a
method and related system of dynamic compiler resolution. Some of
the illustrative embodiments are a computer-implemented method
comprising compiling a source file containing an application
program (the compiling creates a destination file containing a
compiled version of the application program), and inserting in the
compiled version of the application program a series of commands
that (when executed at run time of the application program)
generate an optimized code portion using a value available at run
time.
[0009] Other illustrative embodiments are a computer-readable
medium storing a compiler program that performs a method comprising
compiling source code of an application program to create a
compiled version of the application program, and inserting in the
compiled version of the application program a series of commands
that, when executed at run time of the application program,
generate optimized code using a value available at run time.
[0010] Yet still other illustrative embodiments are a system
comprising a memory (wherein the memory contains a source file of
an program), and a first processor coupled to the memory. The first
processor is configured to compile the program of the source file
to create a compiled program, and the processor is configured to
insert in the compiled program a series of commands that (when
executed at run time) generate an optimized code portion using a
value available at run time.
NOTATION AND NOMENCLATURE
[0011] Certain terms are used throughout the following description
and claims to refer to particular system components. As one skilled
in the art will appreciate, semiconductor companies may refer to a
component by different names. This document does not intend to
distinguish between components that differ in name but not
function. In the following discussion and in the claims, the terms
"including" and "comprising" are used in an open-ended fashion, and
thus should be interpreted to mean "including, but not limited to .
. . ". Also, the term "couple" or "couples" is intended to mean
either an indirect or direct connection. Thus, if a first device
couples to a second device, that connection may be through a direct
connection, or through an indirect connection via other devices and
connections.
BRIEF DESCRIPTION OF THE DRAWINGS
[0012] For a more detailed description of the preferred embodiments
of the present invention, reference will now be made to the
accompanying drawings, wherein:
[0013] FIG. 1 shows a diagram of a system in accordance with
embodiments of the invention;
[0014] FIG. 2 illustrates graphically operation of a compiler and
application program in accordance with embodiments of the
invention;
[0015] FIG. 3 illustrates a flow diagram implemented partially
within a compiler and partially within an application program
compiled by the compiler, in accordance with embodiments of the
invention;
[0016] FIG. 4 illustrates graphically operation of a compiler and
application program in accordance with alternative embodiments of
the invention;
[0017] FIG. 5 illustrates a flow diagram implemented partially
within a compiler and partially within an application program
compiled by the compiler, in accordance with alternative
embodiments of the invention; and
[0018] FIG. 6 illustrates a system in accordance with at least some
embodiments of the invention.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0019] The following discussion is directed to various embodiments
of the invention. Although one or more of these embodiments may be
preferred, the embodiments disclosed should not be interpreted, or
otherwise used, as limiting the scope of the disclosure, unless
otherwise specified. In addition, one skilled in the art will
understand that the following description has broad application,
and the discussion of any embodiments is meant only to be exemplary
of those embodiments, and not intended to intimate that the scope
of the disclosure is limited to those embodiments.
[0020] Moreover, the various embodiments were developed in the
context of processors executing Java.TM. bytecodes, and thus the
description is related to the developmental context; however, the
various embodiments find application outside the Java environment,
such as Microsoft's ".NET" (pronounced "dot net") framework or in
programs written in C and C++, and thus the description in relation
to a Java environment should not be construed as a limitation as to
the breadth of the disclosure.
[0021] Java is a programming language that, at the source code
level, is similar to object oriented programming languages such as
C++. Java language source code is compiled into an intermediate
representation based on a plurality hardware platform independent
"bytecodes" that define specific tasks. An "opcode" is a single
member of the group bytecodes. In some implementations, the
bytecodes are further compiled to machine language for a particular
processor. Some processors, however, are designed to execute some
or all the Java bytecodes directly.
[0022] FIG. 1 shows a system 100 in accordance with embodiments of
the invention. As shown, the system may comprise at least two
processors 102 and 104. Processor 102 may be referred to for
purposes of this disclosure as a Java Stack Machine ("JSM") and
processor 104 may be referred to as a Main Processor Unit ("MPU").
System 100 may also comprise memory 106 coupled to both the JSM 102
and MPU 104. At least a portion of the memory 106 may be shared by
both processors, and if desired, other portions of the memory 106
may be designated as private to one processor or the other. System
100 also comprises a Java Virtual Machine ("JVM") 108, compiler
110, and a display 114. The JVM 108 may comprise a class loader,
bytecode verifier, garbage collector, and a bytecode interpreter
loop to interpret the bytecodes that are not executed on the JSM
processor 102. Other components (not specifically shown) may be
used as desired for various applications.
[0023] Bytecodes 112 may be provided to the JVM 108, possibly
compiled by compiler 110, and provided to the JSM 102 and/or MPU
104 for execution. In accordance with some embodiments of the
invention, the JSM 102 may execute at least some Java bytecodes
directly. When appropriate, however, the JVM 108 may also request
the MPU 104 to execute one or more Java bytecodes not executed or
executable by the JSM 102. In addition to executing compiled Java
bytecodes, the MPU 104 also may execute non-Java instructions. The
MPU 104 may thus also host an operating system ("O/S") (not
specifically shown) which performs various functions such as system
memory management, system task management that schedules the
software aspects of the JVM 108 and most or all other native tasks
running on the system, management of the display 114, and receiving
input from input devices (not specifically shown). Java code,
whether executed on the JSM 102 or MPU 104, may be used to perform
any one of a variety of applications such as multimedia, games or
web based applications in the system 100, while non-Java code,
which may comprise the O/S and other native applications, may still
run on the system on the MPU 104.
[0024] FIG. 2 graphically illustrates operation of a compiler and
an application program in accordance with embodiments of the
invention. In particular, FIG. 2 illustrates a source file 200,
which source file contains an application program comprising, at
least in part, a method 202. The method 202 could be, for example,
a subroutine of the larger application program. The application
program of the source file 200 is compiled (such as by compiler 110
of FIG. 1), and the results of the compiling are placed in a
destination file 204. In some embodiments the source file is
human-readable source code, such as written in Java or C++. In
other embodiments, the application program of the source file 200
may be code that is already at least partially compiled, such as a
Java language application program compiled to bytecodes. The
results of the compiling may likewise take many forms. The compiled
version of the application program may be executable directly or
indirectly by a processor. For example, Java language
human-readable source code may be compiled to bytecodes which are
directly executable by some processors (such as JSM 102), or which
need further compiling to platform dependent instruction sets for
processors that do not directly execute bytecodes (such as MPU
104).
[0025] Regardless of the form of the source and destination files,
in accordance with embodiments of the invention the compiler
inserts into the compiled version of the application program in the
destination file a series of commands 206. The terms "series of
commands" are used to distinguish the original method; however, the
series of commands may be another method of the application
program, albeit drafted by the compiler rather than the author of
the source code. The series of commands 206 are generated by the
compiler such that when the application program is actually
executed, and in particular when the series of commands 206 as part
of the application program are executed, the series of commands
determine a value of a parameter which is available at runtime (and
which may not have been available in a static compiling), and the
series of commands generate an optimized version of the method
based on the value. For example, an indirect reference both in the
human-readable source code file and the compiled version of the
application program may be resolved at run time, and the
illustrative method may be optimized using the resolved value.
[0026] In accordance with at least some embodiments, the series of
commands may be executed multiple times, and each time generate the
optimized version of the method that is thereafter executed. In
alternative embodiments, however, the series of commands 206 are
further configured to replace themselves with the optimized method
208, thus creating a modified destination file 210. In these
embodiments, the series of commands execute one time, to determine
the value of interest, generate an optimized method based on that
value, and overwrite the series of commands with the optimized
method.
[0027] FIG. 3 illustrates a flow diagram that is implemented
partially within a compiler, and partially within an application
program compiled by the compiler. More particularly, FIG. 3
illustrates the operation of the compiler and modified application
program as discussed with respect to FIG. 2. The process starts
(block 300), and in addition to other duties of the compiler, a
determination is made as to whether a method (e.g., method 202 of
FIG. 2) can be optimized based on a value available at run time
(block 304). If not, a determination is made as to whether other
methods exist in the application program for possible optimization
(block 312). If there are no further methods, the process ends
(block 316). If there are further methods, however, the process
starts anew with the determination of whether the next method can
be optimized based on a value available at run time (again block
304).
[0028] Still referring to FIG. 3, if a method can be optimized
based on a run time value, the compiler inserts a series of
commands into the compiled version of the application program for
generating, at run time of the application program, an optimized
version of the method (block 308). Thereafter, a determination is
made as to whether more methods exist for possible run time
optimization (block 312). The illustrative steps of FIG. 3
discussed to this point are preferably implemented within a
compiler. The remaining steps (blocks 320 and 324) are preferably
implemented as part of the application program previously (wholly
or partially) compiled by the compiler.
[0029] The series of commands, executed as part of the application
program and not the compiler program, generate the optimized method
using the value available at run time (block 320). Moreover, and in
at least some embodiments, the series of commands overwrite
themselves with the optimized method (block 324). In some
embodiments the series of commands are overwritten only in the copy
of the application program stored in volatile memory (e.g., RAM),
but not in the compiled version of the application stored on a
non-volatile memory (e.g., a disk drive). If the value available at
run time is expected to the same each and every time the
application program thereafter runs, then the series of commands
may also be overwritten on non-volatile memory device.
[0030] The discussion of the various embodiments to this point has
assumed that sufficient optimization of the overall application
program may be achieved with an optimized method for only one run
time value, and this assumption is valid in many situations. In
alternative embodiments, however, an illustrative method may be
optimized based on several values available at run time, and
further still, the values for which the method is optimized may
change over the course of the execution of the application program.
FIG. 4 illustrates operation of a compiler and an application
program in accordance with alternative embodiments of the
invention. In particular, FIG. 4 illustrates a source file 400,
which source file contains an application program comprising, at
least in part, a method 402. The method 402 could be, for example,
a subroutine of the larger application program. The application
program of the source file 400 is compiled (such as by compiler 110
of FIG. 1), and the results of the compiling are placed in a
destination file 404. Much like the embodiments discussed with
respect to FIG. 2, the source file and destination may take many
forms.
[0031] In accordance with these alternative embodiments, the
compiler inserts into the compiled version of the destination file
a series of commands 406. The series of commands 406 are generated
by the compiler such that when the application program is actually
executed, and in particular when the series of commands 406 as part
of the application program are executed, the series of commands
perform several actions. In particular, the series of commands may
implement dynamic monitoring code 408 (discussed more fully below),
and may also determine a value or values of parameters which are
available at run time (and which may not have been available in a
static compiling). Further, the series of commands 406 also
generate optimized versions of the method based on the value or
values determined by the dynamic monitoring code 408.
[0032] In accordance with these alternative embodiments, the
dynamic monitoring code 408 runs as part of the application
program, and determines which run time values are predominantly
used by the method 410 (which is method 402 compiled and optimized
(to the extent possible) for general data). The terms "dynamic
monitoring code" are used to distinguish the original method;
however, the dynamic monitoring code may be another method of the
application program, albeit drafted by the compiler rather than the
author of the source code. Stated otherwise, the dynamic monitoring
code 408 (part of the series of commands written by the compiler)
monitors a plurality of executions of the method 410, and
determines which run time values are predominantly used. Based on
this determination, the series of commands 406 then generate a
plurality of optimized versions of the method 402/410 (e.g., first
optimized method 412 and a second optimized method 414), one each
for each of the predominantly used values, and writes the optimized
methods to the modified destination file 416. Although not
specifically shown in FIG. 4, the series of commands also write
"glue" code that directs program flow to the proper optimized
method based on the run time value, or if there is not an optimized
method for the particular run time value, to the method 410 for
general data.
[0033] In accordance with some embodiments, when a plurality of
predominantly used run time values has been determined, the
optimized methods overwrite the dynamic monitoring code in the
modified destination file. In alternative embodiments, however, the
dynamic monitoring code remains, and in the event the predominantly
used run time values change over the course of executing the
application program, the dynamic monitor code 408 generates new
optimized methods that either replace or augment the previously
generated optimized methods.
[0034] FIG. 5 illustrates a flow diagram that is implemented
partially within a compiler, and partially within an application
program compiled by the compiler. More particularly, FIG. 5
illustrates the operation of the compiler and modified application
program as discussed with respect to FIG. 4. The process starts
(block 500), and in addition to other duties of the compiler, a
determination is made as to whether the method (e.g., method 402 of
FIG. 4) can be optimized based on a value available at run time
(block 502). If not, a determination is made as to whether other
methods exist in the application program for possible optimization
(block 510). If there are no further methods, the process ends
(block 512). If there are further methods, however, the process
starts anew with the determination of whether the next method can
be optimized based on a value available at run time (again block
502).
[0035] Still referring to FIG. 5, if the method can be optimized
based on a run time value, the compiler inserts a series of
commands for run time monitoring of values into the compiled
version of the application program (block 504). The compiler also
inserts a series of commands for run time optimization of the
method (block 506), and further inserts a compiled version of the
method optimized (to the extent possible) for general data (block
508). Thereafter, a determination is made as to whether more
methods exist for possible run time optimization (block 510). The
illustrative steps discussed to this point are preferably
implemented within a compiler. The remaining steps are preferably
implemented as part of the application program previously (wholly
or partially) compiled by the compiler.
[0036] The run time portion of the various embodiments start (block
516) with execution of the application program, and the series of
commands monitor a plurality of executions of the method optimized
for general data (block 518). Based on data obtained from the
monitoring, a determination is made as to whether there are any
predominantly used values (block 520). If there are no
predominantly used values, the illustrative method retreats to
further monitoring (block 518). If there are predominantly used
values (again block 520), a determination is made as to whether
optimized versions of the method have already been generated for
those values (block 522). If so, then the illustrative method
retreats again to monitoring execution of the method optimized for
general data (block 518). If, on the other hand, the illustrative
method has not generated an optimized method for the predominantly
used values, optimized methods are generated and written to the
modified destination file (block 524). In some embodiments, each
method optimized for a particular value is retained, and further
optimized methods added. In cases where storage space in the
modified destination file is limited, each time an optimized method
is generated it may overwrite other optimized versions of the
method. Further still, if storage space is an issue, the dynamic
monitor code may be overwritten. Stated otherwise, once one or more
predominantly used values are determined, the illustrative method
may no longer perform the dynamic monitoring.
[0037] System 100 may be implemented as a mobile cell phone such as
that shown in FIG. 6. As shown, the mobile communication device
includes an integrated keypad 612 and display 614. The JSM
processor 102 and MPU processor 104 and other components may be
included in electronics package 610 connected to the keypad 612,
display 414, and radio frequency ("RF") circuitry 416. The RF
circuitry 416 may be connected to an antenna 418.
[0038] From the description provided herein, those skilled in the
art are readily able to combine software created as described with
appropriate general purpose or a special purpose computer hardware
to create a computer system and/or computer subcomponents embodying
aspects of the invention, to create a computer system and/or
computer subcomponents for carrying out the method embodiments of
the invention, and/or to create a computer-readable medium storing
a software program to implement method aspects of the various
embodiments. Moreover, the embodiments of the illustrative methods
could be implemented together in a single program (with various
subroutines), or split up into two or more programs executed on the
processor.
[0039] While the various embodiments of the invention have been
shown and described, modifications thereof can be made by one
skilled in the art without departing from the spirit and teachings
of the invention. The embodiments described herein are illustrative
only, and are not intended to be limiting. Many variations and
modifications of the invention disclosed herein are possible and
are within the scope of the invention. For example, compiling in
accordance with embodiments of the invention may take place
statically (ahead-in-time) or dynamically. Each and every claim is
incorporated into the specification as an embodiment of the present
invention.
* * * * *