Connect public, paid and private patent data with Google Patents Public Datasets

Methods and apparatus for compiling computer programs using partial function inlining

Download PDF

Info

Publication number
US6986130B1
US6986130B1 US09628694 US62869400A US6986130B1 US 6986130 B1 US6986130 B1 US 6986130B1 US 09628694 US09628694 US 09628694 US 62869400 A US62869400 A US 62869400A US 6986130 B1 US6986130 B1 US 6986130B1
Authority
US
Grant status
Grant
Patent type
Prior art keywords
execution
subprogram
code
path
compiler
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active, expires
Application number
US09628694
Inventor
Michael Boucher
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Oracle America Inc
Original Assignee
Sun Microsystems Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Grant date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformations of program code
    • G06F8/41Compilation
    • G06F8/44Encoding
    • G06F8/443Optimisation
    • G06F8/4441Reducing the execution time required by the program code
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformations of program code
    • G06F8/41Compilation
    • G06F8/44Encoding
    • G06F8/447Target code generation

Abstract

A method and system makes inlining decisions that are efficient for subprograms that have significantly varying execution times over a range of variables or execution paths. A subprogram of a computer program is identified and certain execution paths of the subprogram are selectively inlined. The subprogram may be identified based on execution characteristics of the subprogram. The selective inlining of the execution paths may be based on execution characteristics of the paths. The paths may be selectively inlined based on an inline indication associated with an execution path, where the inline indication may be an inline directive. The inline directive may be included as part of a program comment statement. A compiler makes determinations whether to inline a specific execution path of a subprogram by evaluating certain information supplied in conjunction with the path. By supplying information in association with the subprogram path, the compiler may more easily determine the various execution characteristics of the execution paths and may inline or not based on the execution characteristic indication associated with the subprogram execution path.

Description

I. FIELD OF THE INVENTION

The present invention relates to optimizing computer code during compilation, and more particularly, to partial function inlining during compilation.

II. BACKGROUND OF THE INVENTION

Modem computer program languages are based on modular design models, where computer code is written in small, modular units or subprograms that define certain objects or functions. These subprograms may be called (i.e. invoked) wherever desired in the program by a simple reference to the subprogram. While modular program design is an effective programming technique, additional overhead may be introduced during the execution stage after the program is compiled. An overhead penalty is introduced when a subprogram is called frequently but the execution time of the subprogram is small relative to the time required to call the subprogram.

Most compilers are equipped with various optimization routines that determine how to represent the original source code in an efficient executable form, such as reducing the size and required execution time of various calls to the subprogram. One well known optimization technique is referred to as inlining. Inlining techniques replace the subprogram calls at the various locations in the computer program with the lines of code that define the subprogram. Inlining is typically performed when a subprogram is called many times in a program and when the execution time of the subprogram is small compared with the time necessary to set-up for and call the subprogram.

Inlining provides performance improvements for various reasons. First, the subprogram linkage is removed, including the code to save and restore registers, allocate stack space, and the branch itself. Second, the code surrounding the call site can be improved, since the call itself, which may be a barrier for some optimization procedures, is no longer present. By removing the call site, it is also possible to perform better instruction scheduling, register allocation, etc. Third, the subprogram code that is substituted for the call can be optimized for the specific call context.

The decision to inline a subprogram may be determined by the compiler automatically or assisted by user directed inlining. With user directed inlining, the programmer specifies which subprograms should be inlined. The compiler then attempts to inline the subprograms chosen by the user at each of its call sites. When automatic inlining is used, the compiler determines which subprograms should be inlined by following a set of inline optimization rules. However, the typical rules implemented by a compiler do not account for subprograms that exhibit varying execution characteristics due to the range of variables or arguments over which the subprogram operates. With the varying arguments, the subprogram's actual run-time may be substantially influenced depending on the argument received. For example, within a subprogram various execution paths may be taken based on the argument received. In some cases, the path taken is shorter and faster than others and the path may be taken more frequently. However, because subprograms are inlined based on the execution time of the subprogram as a whole, the disparate execution times and disparate frequency of execution of the different paths are not accounted for very well in optimization techniques.

One method used to help the compiler determine whether to inline based on different variables is referred to as profiling. When using profiling, the computer program is executed at compile time using different data scenarios to determine how programs will perform (profiling) before producing the final compiled code. The use of profiling information typically requires at least two passes to compile the program. One pass is performed then the compiled program is executed to generate the profiling information, and the other pass performs the automatic inlining based on the profiling information. The compiler's determination of whether to inline a subprogram that has been profiled is typically based on the number of times a subprogram is called and the execution time of the subprogram. While using profiling to determine whether to inline a subprogram is beneficial in some cases, it does not solve the optimization problem introduced by subprograms that exhibit significantly different execution or run-time characteristics based on the arguments used or execution paths taken in the subprograms. That is, profiling only provides a guess as to the best way to inline based on the data sets used to perform the profiling. Hence, the compiler's decision whether to inline may be correct or efficient for some scenarios but costly for others.

Thus, there is a need for a system and method that enables a compiler to make inlining decisions that are efficient for subprograms that have significantly varying execution times over a range of variables or execution paths.

III. SUMMARY OF THE INVENTION

Methods and systems consistent with the present invention enable a compiler to make inlining decisions that are efficient for subprograms that have significantly varying execution times over a range of variables or execution paths.

In one aspect consistent with the present invention, a subprogram of a computer program is identified and certain execution paths of the subprogram are selectively inlined. The subprogram may be identified based on execution characteristics of the subprogram and the selective inlining of the execution paths may be based on execution characteristics of the paths. These execution characteristics may be based on the execution time for the paths and/or on the frequency of execution of the paths. The paths may be selectively inlined based on an inline indication associated with an execution path, where the inline indication may be an inline directive. The inline directive may be included as part of a program comment statement. The selective inlining of the paths may be determined using information profiles associated with the execution path.

In another aspect of the present invention, a subprogram is identified that operates in a first manner when operands passed to the subprogram fall within a first range of values and that operates in a second manner when operands passed to the subprogram fall within a second range of values. Subprogram statements that cause the subprogram to operate in the first manner are replaced with expanded code.

A compiler makes determinations whether to inline a specific execution path of a subprogram by evaluating certain information supplied in conjunction with the path. By supplying information in association with the subprogram path, the compiler may more easily determine the various execution characteristics of the execution paths. Subprograms may be programmed to indicate or may be associated with the range of variables or parameters that cause the subprogram to exhibit a specific execution characteristic. When the compiler encounters an indication of a subprogram path that may exhibit one of multiple execution characteristics, the compiler makes the decision whether to inline or not based on the execution characteristic indication associated with the subprogram call.

IV. BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of a compiler system consistent with the present invention;

FIG. 2 is a detailed drawing of a compiler consistent with the present invention;

FIG. 3 is a block diagram of modules associated with optimization procedures consistent with the present invention.

FIG. 4 is a diagram of the process of creating computer code consistent with the present invention; and

FIG. 5 is a diagram of the process for inlining that is consistent with the present invention.

V. DETAILED DESCRIPTION OF THE INVENTION

Referring to the figures, a detailed description of the preferred embodiments of the present invention is described. A system or method operating consistent with the present invention identifies a subprogram that has a first and a second execution characteristic and replaces a first portion of the subprogram with expanded code that exhibits the first execution characteristic while leaving intact a second portion of the subprogram that exhibits the second execution characteristic. The first execution characteristic may be exhibited when operands passed to the subprogram fall within a first range of values and the second execution characteristic may be exhibited when operands passed to the subprogram fall within a second range of values. Such systems and methods are particularly useful in a compiler for selectively inlining portions of identified subprogram calls of a particular subprogram based on various execution characteristics of the subprogram. The term subprogram generally refers to user defined or predefined computer program routines or functions designed to carry out a desired task and expanded code generally refers to replacement computer program code that more explicitly defines the steps of an operation than the code it replaced.

Within a subprogram various execution paths may be taken based on the arguments received, and in some cases, the paths that may be taken vary in complexity, execution time, and frequency of traversal. In prior systems, because subprograms are typically inlined based on the execution time and frequency of execution of the subprogram as a whole, the path dependent execution times and frequency of execution are not accounted for very well in optimization techniques. However, a system or method operating consistent with the present invention enables various execution paths of a subprogram to be evaluated separately for consideration for inlining. In an embodiment consistent with the present invention, directives may be included in the various execution paths within a subprogram to indicate that the path should be inlined or considered for inlining. A compiler consistent with the present invention recognizes the directive as an indication to consider the program instructions of the particular execution path for inlining. As a result, various branches within a subprogram may be selectively inlined according to the specifications or characteristics of a particular execution path or branch.

Referring to FIG. 1, a compiler system 10 consistent with the present invention operating in a computer system 14 is illustrated. It should be appreciated that certain components of the computer system 14 are not illustrated because such components are not necessary for an understanding of the present invention. The computer system 14 includes a central processing unit (CPU) 18, memory module 20, input/output ports 24, and a computer system bus 28. The computer system bus 28 communicates data and signals among the components of the computer system 14.

The memory module 20 is representative of random access memory, read only memory and other memory elements used for storage and processing in the computer system 14. The memory module 20 includes source code 30 of a program to be compiled, a compiler 32, intermediate code 36 (without inlining), intermediate code 38 (with inlining), and the assembly code 40. As known to those skilled in the art, CPU 18 executes compiler 32 in a manner consistent with the present invention. A computer program represented by the source code 30 is first converted to the intermediate code 36 by the compiler 32 prior to the compiler 32 applying optimization procedures. The compiler 32 inlines selected portions of subprograms, consistent with the present invention, to produce intermediate code 38. The intermediate code 38 is then optimized to produce the assembly code 40. The compiler 32 consistent with the present invention is adapted to selectively inline portions of subprograms that exhibit various execution characteristics. Particularly, selected execution branches of a subprogram are inlined based on the branches' execution characteristics.

Referring to FIG. 2, a more detailed view of the compiler 32 is illustrated. The compiler 32 includes several subcomponents: an internal representation translator unit 210 that produces the intermediate code 36 from the source code 30, optimization procedures 220, and an assembler 240. The internal representation of the source code 30 is subjected to an array of optimization procedures 220 that are modeled into the compiler 32. The optimization procedures 220 are modeled consistent with the present invention to recognize directives included as part of an execution path of a subprogram. The directives are used in association with execution paths to indicate that a path of a subprogram is to be given special consideration for inlining as discussed herein. The optimization procedures 220 produce the inlined intermediate code 38, which is provided to the assembler 240 to produce the assembly code 40. It should be appreciated that optimization procedures, other than those discussed herein, that are well known in the art may be used in combination with an embodiment consistent with the present invention.

Referring to FIG. 3, a more detailed view of the optimization procedures 220 is illustrated. The optimization procedures 220 may include an inline eligibility module 310, an inline profitability module 320, and a profiling module 330. The inline eligibility module 310 determines the portions of the source code that are eligible for inlining by identifying subprograms using inlining eligibility rules as known to those skilled in the art. After a program module is identified as eligible for inlining, the profitability of inlining each identified subprogram is determined by the profitability module 320. Generally speaking, the profitability module 320 determines whether execution time will be saved by inlining subprograms and inlines the subprograms after making the determination. The profitability module 320 estimates the profitability of inlining based on rules encoded into the profitability module 320, by assessing user inline directives, and/or by invoking the profiling module 330.

When a developer includes a inline directive in a branch or execution path of a subprogram, consistent with the present invention, the inline profitability module 320 considers the identified path separately for inlining from other paths of the subprogram or other instructions or operations of the subprogram. For example, an inline directive may indicate to the compiler that it is likely that a particular conditional execution statement, such as an “if” statement or branch, will be taken. The compiler 32 uses this directive to determine whether to inline. Consequently, the inline profitability module 320 may inline an identified path of a subprogram that has a different characteristic than other paths of the subroutine. It should be appreciated by those skilled in the art that procedures for determining profitability are well known and therefore, are not discussed in detail herein, as generally discussed in U.S. Pat. No. 5,740,443.

As discussed above, a compiler may profile a program by compiling the code and executing the compiled code with different sets of data to determine the best way to finally compile the code. When profiling is desired, an option to profile the code may be selected to invoke the profiling module 330. When profiling is used, the inline profitability module 320 and the profiling module 330 implement a two stage compiling process. In the first stage, the program is compiled and run a number of times using different scenarios or data. The subprograms identified as possessing multiple execution characteristics have identified portions (e.g. including an inline directive along a selected path or paths of the subprogram) of the subprogram evaluated individually, with corresponding profiling information. Inline directives are program statements that provide hints to aid the compiler in making the decision of whether to inline a particular segment of code.

The profiling module 330 may base profiling considerations on a single set of profiling information and/or execution characteristics exhibited by certain paths or portions of the subprogram in view of the various data sets designated for a specific path or portion. The profiling module 330 collects and records information on how many branches of or within the subprogram were taken and how long it took the branches of the subprogram to run. In the second stage, the program is recompiled using the recorded information to determine whether to inline a subprogram or portion of the subprogram based on the gathered data. Subprograms or portions thereof that where not frequently utilized and/or had relatively long execution times are not inlined and those that were frequently utilized and had relatively short execution times are inlined.

As discussed above, a system operating consistent with the present invention identifies a subprogram that has multiple execution characteristics and inlines certain segments of the subprogram based on the execution characteristics of the subprogram. For example, in a first scenario, some subprograms' operations are straightforward or not very time consuming when the operands sent to the subprogram fall within a normal range of values. In another scenario, the operands sent to the subprogram fall outside the normal operating ranges for the subprogram and special processing is used to accomplish the desired task. The special processing can include error trapping, error recovery, or it may require alternative computational methods. Systems and methods operating consistent with the present invention treat the invocation of a subprogram for operands that produce normal processing and operands that produce special processing as distinct cases for consideration for inlining. The normal case processing is considered for inlining according to the general inlining procedures specified for the compiler and special case processing, which frequently occupies the bulk of the subprogram, is not likely to be inlined.

Many subprograms, such as the mathematical sine function, have different execution characteristics based on the variables or arguments over which it operates. In a computer program, for angles (Θ)<π/8, a sine subprogram executes in a relatively fast manner compared to the time required to call the sine subprogram in a computer program. However, the sine subprogram executes in a relatively slower manner compared to the time required to call the sine function for angles (Θ)≧π/8. In conventional compilers, the compiler would assess whether the sine subprogram, in general, takes a long time to execute based on conventional profitability analysis and would either inline the entire sine subprogram based on the determined profitability. This results in optimization of sine subprograms in certain situations and not others. However, a system or method operating consistent with the present invention distinguishes between the various execution characteristics of subprograms, such as a sine subprogram, and selectively inlines portions of the sine subprogram based on the execution characteristic that a branch of the sine subprogram will likely exhibit.

Thus, in a system or method operating consistent with the present invention, since inlining the sine function is profitable for angles<π/8, the compiler 32 inlines code along the sine subprogram path that receive angles (Θ)<π/8 and does not inline code along the sine subprogram path that receive angles (Θ)>π/8. Consequently, subprograms are partially inlined based on the execution characteristic of a particular branch.

The following is an example of source code used to illustrate an implementation consistent with the present invention. It should be appreciated that this source code example is not intended to represent a specific source code (high level) language but instead represents the general type logic statements that may be implemented in various computer program languages, such as Java, C. Fortran, Pascal, or other high level language and does not limit the invention to any specific computer language. (Java is a registered trademark of Sun Microsystems Corporation.) The following represents a subprogram to compute the “sine” function:

    • If (Θ<π/8) then
    • c$dir INLINE PATH
    • {compute sine with a quick formula}
    • else
    • {compute sine with long process}
    • end if

In the subprogram code illustrated above, the sine subprogram has two execution paths: one path that computes sine using a quick formula when Θ<π/8 (the short path) and another path that computes sine using a long formula when Θ≧π/8 (the long path). In this example, the calculation of sine along the short path may be considered a first execution characteristic of the subprogram and the calculation of sine along the long path may be considered a second execution characteristic of the subprogram. The computation of sine along the short path takes less time than the computation of sine along the long path. A directive “c$dir INLINE PATH” is included along the short path to identify the short path as having a certain execution characteristic. The “c” indicates the language following is a program comment and the “$dir” indicates that the compiler is to interpret this comment as a special directive. In this example, the directive is named “INLINE PATH” and indicates to the compiler that this path or branch of the subprogram is to be inlined. By using the comment “c” syntax, if this code is evaluated by a compiler that does not have the logic consistent with the present invention modeled therein, the compiler treats the statement as a program comment and does not perform any action with respect to the statement. Without an element to distinguish execution paths, such as the directive statement discussed above, a compiler would not be able to distinguish whether one path of subprogram was shorter/faster and would not know whether the path is frequently or infrequently executed.

When the compiler 32 encounters a path of a subprogram that includes a directive specified in accordance with the present invention, the compiler 32 inlines or considers for inlining the code along the short path. When profiling is used, a compiler consistent with the present invention may evaluate data collected after testing different sets of data to determine execution paths that were taken frequently and executed quickly as opposed to only evaluating the entire subprogram as in conventional compilers.

It should be appreciated that the sine subprogram discussed is intended only as an example of a subprogram that may be evaluated and inlined consistent with the principles of the present invention and that other subprograms with different execution characteristics may be inlined consistent the principles of the present invention. Another example of a subprogram that can be inlined consistent with the present invention is the mathematical tangent function, which processes normally for a certain range of variables but requires special case processing for another range of variables.

Referring to FIGS. 4-5, flow diagrams consistent with an embodiment of the present invention are illustrated. FIG. 4. is a flow diagram of the process used in developing source code that is consistent with the present invention. Such source code enables a compiler to identify the range of variables that are associated with a specific execution characteristic of a subprogram. A subprogram is identified that exhibits varying execution characteristics based on the range of variables that cause the different execution characteristics (step 402). After identifying the ranges, the specific ranges of variables identifying execution characteristics are associated with the particular conditional branch of the subprogram that causes the associated execution characteristic to be exhibited (step 410). The subprogram path or paths that are to be given special consideration, such as for inlining, are identified and a directive consistent with the present invention is included along the path to identify the path that is to be given special consideration for inlining (step 430).

Referring to FIG. 5, a flow diagram of the processes for inlining computer code consistent with the present invention is shown. Since the inlining process is the same for various compilation systems, the discussion associated with FIG. 5 describes the processes that occur during the second pass of compilation when profiling is used and describes the inlining processes when a single compilation stage compiler is used. After optimization processing begins, the compiler identifies a subprogram that is eligible for inlining (510). The compiler determines whether the subprogram has multiple execution characteristics (step 512). If the subprogram normal inlining procedures (step 516). The compiler determines that the subprogram does not have multiple execution characteristics if an inline directive statement is not associated with the subprogram. The compiler then determines whether additional subprograms are to be evaluated for inlining (step 540). If all subprograms have been evaluated, the process ends (step 544). If all subprograms have not been evaluated, the process continues (step 510).

If the compiler determines that a subprogram has multiple execution characteristics (i.e. a directive consistent with the present invention is associated with a particular execution path of the subprogram) (step 512), the compiler considers the indicated execution path for inlining separately from the subprogram as a whole (step 524). If the compiler determines that inlining should not be applied to the execution path (step 524), the process checks for other paths to be evaluated, and if no other paths exist (step 536) within the subprogram, other subprograms, if any more exist, are evaluated (step 510). If the compiler determines that inline processing is to occur (step 524), the subprogram execution path is inlined (step 530). If there are no other execution paths in subprogram (step 536), the process determines whether other subprograms are to be evaluated (step 540). If there is another execution path of the subprogram to be evaluated (step 536), the process determines whether an inline directive is associated with the branch (step 524). If an inline directive is associated with the execution path, the execution path will be given special consideration for inlining (step 524), as discussed herein.

In summary, a compiler consistent with the present invention makes determinations as to whether to inline a specific call to a subprogram by evaluating certain information supplied in conjunction with the subprogram call. By supplying information in association with the subprogram call, the compiler may more easily determine the various execution characteristics of the execution paths of a subprogram. For many subprograms, the source code developer knows or can determine that certain predefined or developer defined subprograms exhibit different characteristics based on the different variables operated on by the subprogram. Thus, subprograms may be programmed to indicate or may be associated with the range of variables or parameters that cause the subprogram to exhibit a specific execution characteristic. When the compiler encounters an indication of a the compiler makes the decision whether to inline or not based on the execution characteristic indication associated with the subprogram call.

By processing subprograms in a manner consistent with the present invention, two disadvantages of normal inlining are solved. First, since only a small portion of the subprogram is inlined, it is much less likely that the executable code produced as a result of the inlining will grow to unacceptable bounds. Second, the optimization is performed more efficiently since less code will be inlined.

It should be appreciated by those skilled in the art that the present invention may be used in various compilers or stages of compilation that perform optimization. For example, a system or method consistent with the present invention may be used for optimization as described herein when compiling source code to intermediate code, such as Java byte codes. Additionally, a system or method consistent with the present invention may be used for optimization when byte codes are converted to object code.

It should be understood by those skilled in the art that various changes and modifications may be made to the described embodiments and principles, and equivalents may be substituted for elements without departing from the scope of the invention. Modifications may be made to adapt a particular element, technique, or implementation to the teachings of the present invention without departing from the scope of the invention. It should be appreciated that steps for performing processes consistent with the present invention may be reordered. Steps may also be removed or added without departing from the scope of the present invention. Although the described implementation is discussed specifically in terms of software, the invention may be implemented as a combination of hardware and software. Additionally, although aspects of the present invention are described as being stored in memory, one skilled in the art will appreciate that these aspects can also be stored on other types of computer-readable media, such as secondary storage devices, like hard disks, floppy disks, or CD-ROM; a carrier wave from the Internet; or other forms of RAM or ROM. Therefore, the described embodiments should be taken as illustrative and not restrictive, of the invention defined by the following claims and their scope of equivalents.

Claims (32)

1. A computer-implemented method for inlining code of a computer program, comprising:
identifying a subprogram of the computer program, wherein the subprogram exhibits varying execution characteristics associated with corresponding execution paths;
identifying a range of variables associated with a first execution characteristic of the subprogram;
associating the range of variables with a first execution path of the subprogram;
coding an inline directive as part of a program comment statement associated with the first execution path; and
selectively inlining computer code of the first execution path of the subprogram based on the inline directive.
2. The method of claim 1, wherein the varying execution characteristics are each associated with certain ranges of variables.
3. The method of claim 1 wherein selectively inlining includes:
leaving intact a second execution path that exhibits a second execution characteristic different from the first characteristic based on a second range of variables.
4. The method of claim 1, wherein the execution characteristics are based on an execution time for the execution paths.
5. The method of claim 4 wherein the execution characteristics are based on the frequency of execution of the paths.
6. A computer program compiler for inlining computer program code, comprising:
a subprogram identification module that identifies subprograms of the computer code by
identifying ranges of variables that each relate to a corresponding execution characteristic of a corresponding subprogram included in the computer code,
associating the ranges of variables with certain execution paths of each of the subprograms, and
inserting inline directives in a part of a program comment statement associated with each of the certain execution paths; and
a path identification module that selectively inlines computer code of the certain execution paths of the subprograms based on the inline directives.
7. A computer-implemented method of determining whether to replace subprogram code of a computer program, comprising the steps of:
identifying a subprogram that has a first and a second execution characteristic;
identifying certain arguments that cause the subprogram to exhibit the first execution characteristic:
associating the certain arguments that cause the subprogram to exhibit the first execution characteristic with a portion of the subprogram;
replacing the portion of the subprogram that exhibits the first execution characteristic with program instructions that explicitly define operations of the first execution characteristic; and
leaving intact a second portion of the subprogram that exhibits the second execution characteristic.
8. The method of claim 7 wherein said second execution characteristic is an atypical characteristic associated with program code that requires special processing.
9. The method of claim 8 wherein said atypical characteristic is an execution time duration.
10. The method of claim 9 wherein said execution time duration exceeds a predetermined threshold.
11. The method of claim 10 wherein said first execution characteristic is a typical execution characteristic associated with program code that requires normal processing.
12. The method of claim 10 wherein said first and second execution characteristics are execution time durations.
13. The method of claim 12 wherein the first and second execution characteristics are invoked based on conditional execution computer statements associated with the characteristics.
14. The method of claim 7 wherein the certain arguments are associated with conditional execution computer statements associated with the first characteristic.
15. A computer readable medium for inlining computer program code, which when executed by a computer, performs the steps of:
identifying a subprogram that has a plurality of execution characteristics by identifying ranges of variables that cause the subprogram to exhibit the execution characteristics, associating a certain range of variables with one of the execution characteristics, and associating the certain range of variables with a selected portion of the subprogram that corresponds to the one execution characteristic;
inlining only the selected portion of the subprogram that corresponds to the one execution characteristic,
wherein the selected portion is defined by a selected path of a plurality of execution paths that may be executed by the subprogram and the selected path is determined by identifying a non-executable statement configured to direct the computer to interpret at least a portion of the non-executable statement as a special directive.
16. The medium of claim 15 wherein the program comment statement is included in the selected path.
17. The medium of claim 15 wherein the execution characteristics are identified by evaluating a conditional execution statement associated with a subprogram call.
18. A computer-implemented method of replacing subprogram code in a computer system, comprising the steps of:
identifying a subprogram that operates in a first manner when operands passed to the subprogram fall within a first range of values and that operates in a second manner when operands passed to the subprogram fall within a second range of values;
associating the operands with the first range of values with an execution path of the subprogram;
replacing subprogram statements included in the execution path that cause the subprogram to operate in the first manner with expanded code.
19. An apparatus having a processor and a memory containing programs for inlining code of a computer program which when executed using the processor perform steps comprising:
identifying a subprogram of the computer program, wherein the subprogram exhibits varying execution characteristics associated with corresponding execution paths, the identifying including:
identifying a range of variables associated with a first execution characteristic of the subprogram,
associating the range of variables with a first execution path of the subprogram, and
coding an inline directive as part of a program comment statement associated with the first execution path; and
selectively inlining computer code of the first execution path of the subprogram based on the inline directive.
20. The apparatus of claim 19, wherein the varying execution characteristics are each associated with certain ranges of variables.
21. The apparatus of claim 19 wherein selectively inlining includes:
leaving intact a second execution path that exhibits a second execution characteristic different from the first characteristic based on a second range of variables.
22. The apparatus of claim 21 wherein the execution characteristics are based on an execution time for the execution paths.
23. The apparatus of claim 21 wherein the execution characteristics are based on the frequency of execution of the paths.
24. An apparatus having a processor and a memory containing programs for determining whether to replace subprogram code of a computer program which when executed using the processor perform steps comprising:
identifying a subprogram that has a first and a second execution characteristic;
identifying certain arguments that cause the subprogram to exhibit the first execution characteristic;
associating the certain arguments that cause the subprogram to exhibit the first execution characteristic with a portion of the subprogram;
replacing the portion of the subprogram that exhibits the first execution characteristic with program instructions that explicitly define operations of the first execution characteristic; and
leaving intact a second portion of the subprogram that exhibits the second execution characteristic.
25. The apparatus of claim 24 wherein said second execution characteristic is an atypical characteristic associated with program code that requires special processing.
26. The apparatus of claim 25 wherein said atypical characteristic is an execution time duration.
27. The apparatus of claim 26 wherein said execution time duration exceeds a predetermined threshold.
28. The apparatus of claim 27 wherein said first execution characteristic is a typical execution characteristic associated with program code that requires normal processing.
29. The apparatus of claim 27 wherein said first and second execution characteristics are execution time durations.
30. The apparatus of claim 27 wherein the first and second execution characteristics are invoked based on conditional execution computer statements associated with the characteristics.
31. The apparatus of claim 24 wherein the certain arguments are associated with conditional execution computer statements associated with the first characteristic.
32. An apparatus having a processor and a memory containing programs for replacing subprogram code in a computer system which when executed using the processor perform steps comprising,
identifying a subprogram that operates in a first manner when operands passed to the subprogram fall within a first range of values and that operates in a second manner when operands passed to the subprogram fall within a second range of values;
associating the operands that fall within a first range of values with one of many execution paths of the subprogram; and
replacing the subprogram statements included in the one execution path that cause the subprogram to operate in the first manner with expanded code.
US09628694 2000-07-28 2000-07-28 Methods and apparatus for compiling computer programs using partial function inlining Active 2022-08-07 US6986130B1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US09628694 US6986130B1 (en) 2000-07-28 2000-07-28 Methods and apparatus for compiling computer programs using partial function inlining

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US09628694 US6986130B1 (en) 2000-07-28 2000-07-28 Methods and apparatus for compiling computer programs using partial function inlining
PCT/US2001/023466 WO2002010909A3 (en) 2000-07-28 2001-07-26 Methods and apparatus for compiling computer programs using partial function inlining

Publications (1)

Publication Number Publication Date
US6986130B1 true US6986130B1 (en) 2006-01-10

Family

ID=24519930

Family Applications (1)

Application Number Title Priority Date Filing Date
US09628694 Active 2022-08-07 US6986130B1 (en) 2000-07-28 2000-07-28 Methods and apparatus for compiling computer programs using partial function inlining

Country Status (2)

Country Link
US (1) US6986130B1 (en)
WO (1) WO2002010909A3 (en)

Cited By (18)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20030188187A1 (en) * 2002-03-25 2003-10-02 Nec Corporation Obfuscated source program, source program conversion method and apparatus, and source conversion program
US20040250234A1 (en) * 2003-06-09 2004-12-09 Sun Microsystems, Inc. Systems and methods for software performance tuning
US20040250235A1 (en) * 2003-06-09 2004-12-09 Sun Microsystems, Inc. Methods and apparatus for enhanced statistical performance
US20050021655A1 (en) * 2003-06-09 2005-01-27 Sun Microsystems, Inc. System for efficiently acquiring and sharing runtime statistics
US20050071826A1 (en) * 2003-09-30 2005-03-31 International Business Machines Corporation Determining how many class-type checks to inline
US20060101416A1 (en) * 1998-12-23 2006-05-11 Callahan Charles D Ii Parallelism performance analysis based on execution trace information
US20070010975A1 (en) * 2004-06-05 2007-01-11 International Business Machines Corporation Probabilistic regression suites for functional verification
US20070234307A1 (en) * 2006-03-06 2007-10-04 Chi-Keung Luk Methods and apparatus to inline conditional software instrumentation
US20080222637A1 (en) * 2004-09-09 2008-09-11 Marc Alan Dickenson Self-Optimizable Code
US20090254878A1 (en) * 2008-04-04 2009-10-08 Intuit Inc. Executable code generated from common source code
US20100204809A1 (en) * 2009-02-09 2010-08-12 Siemens Ag Method for Operating an Automation System, Corresponding Computer Program and System or Device that Operates According to the Method
US7818730B1 (en) * 2006-06-30 2010-10-19 The Math Works, Inc. Automatic minimal build dependency determination and building an executable with source code
US20140007064A1 (en) * 2012-07-02 2014-01-02 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US8701097B2 (en) 2010-11-05 2014-04-15 International Business Machines Corporation Partial inlining with software based restart
US20140130025A1 (en) * 2012-11-07 2014-05-08 International Business Machines Corporation Compiler optimization based on collectivity analysis
US8762974B1 (en) * 2005-06-30 2014-06-24 The Mathworks, Inc. Context-sensitive compiler directives
US9304748B2 (en) 2013-08-07 2016-04-05 Qualcomm Incorporated Method for controlling inlining in a code generator
US9430196B2 (en) * 2014-10-16 2016-08-30 Cisco Technology, Inc. Message inlining

Citations (105)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6173327B2 (en)
US4812996A (en) 1986-11-26 1989-03-14 Tektronix, Inc. Signal viewing instrumentation control system
US5075847A (en) 1989-05-26 1991-12-24 Hewlett-Packard Company Method and apparatus for computer program encapsulation
US5079707A (en) 1990-01-19 1992-01-07 The Boeing Company Integrated certification-calibration system for a testing system having multiple test instruments
US5119465A (en) 1989-06-19 1992-06-02 Digital Equipment Corporation System for selectively converting plurality of source data structures through corresponding source intermediate structures, and target intermediate structures into selected target structure
US5146593A (en) 1989-03-06 1992-09-08 International Business Machines Corporation Procedure call interface
US5168563A (en) 1989-03-29 1992-12-01 Hewlett-Packard Company Various possible execution paths measurement and analysis system for evaluating before writing source codes the efficiency performance of software designs
US5274821A (en) 1989-08-14 1993-12-28 International Business Machines Corporation Communication between prolog and an external process
US5301312A (en) 1991-08-21 1994-04-05 International Business Machines Corporation Method and system for utilizing benign fault occurrence to measure interrupt-blocking times
US5325499A (en) 1990-09-28 1994-06-28 Tandon Corporation Computer system including a write protection circuit for preventing illegal write operations and a write poster with improved memory
US5325533A (en) 1993-06-28 1994-06-28 Taligent, Inc. Engineering system for modeling computer programs
US5353401A (en) 1992-11-06 1994-10-04 Ricoh Company, Ltd. Automatic interface layout generator for database systems
US5390314A (en) 1992-10-09 1995-02-14 American Airlines, Inc. Method and apparatus for developing scripts that access mainframe resources that can be executed on various computer systems having different interface languages without modification
US5438659A (en) 1992-10-08 1995-08-01 Hewlett-Packard Company Object-action user interface management system
US5481708A (en) * 1992-06-05 1996-01-02 Borland International, Inc. System and methods for optimizing object-oriented compilations
US5485619A (en) 1993-12-29 1996-01-16 International Business Machines Corporation Array variable transformation system employing subscript table mapping to scalar loop indices
US5497458A (en) 1993-07-06 1996-03-05 Dell Usa, L.P. Cache testability circuit for embedded diagnostics
US5499349A (en) 1989-05-26 1996-03-12 Massachusetts Institute Of Technology Pipelined processor with fork, join, and start instructions using tokens to indicate the next instruction for each of multiple threads of execution
US5519866A (en) 1993-06-28 1996-05-21 Taligent, Inc. Method and apparatus of incrementally linking components of a modeled computer program
US5530816A (en) 1991-11-02 1996-06-25 International Computers Limited Data processing system for handling multiple independent data-driven instruction streams
US5535393A (en) * 1991-09-20 1996-07-09 Reeve; Christopher L. System for parallel processing that compiles a filed sequence of instructions within an iteration space
US5539907A (en) 1994-03-01 1996-07-23 Digital Equipment Corporation System for monitoring computer system performance
US5553235A (en) 1992-10-23 1996-09-03 International Business Machines Corporation System and method for maintaining performance data in a data processing system
US5574922A (en) 1994-06-17 1996-11-12 Apple Computer, Inc. Processor with sequences of processor instructions for locked memory updates
US5613063A (en) 1994-07-01 1997-03-18 Digital Equipment Corporation Method and apparatus for checking validity of memory operations
US5636374A (en) 1994-01-04 1997-06-03 Intel Corporation Method and apparatus for performing operations based upon the addresses of microinstructions
US5640550A (en) 1994-04-15 1997-06-17 Coker; Drake Computer system for generating SQL statements from COBOL code
US5673387A (en) 1994-05-16 1997-09-30 Lucent Technologies Inc. System and method for selecting test units to be re-run in software regression testing
US5689712A (en) 1994-07-27 1997-11-18 International Business Machines Corporation Profile-based optimizing postprocessors for data references
US5710727A (en) 1994-05-04 1998-01-20 National Instruments Corporation System and method for creating resources in an instrumentation system
US5724262A (en) 1994-05-31 1998-03-03 Paradyne Corporation Method for measuring the usability of a system and for task analysis and re-engineering
US5737605A (en) 1993-10-12 1998-04-07 International Business Machines Corporation Data processing system for sharing instances of objects with multiple processes
US5740431A (en) 1996-01-24 1998-04-14 Electronic Data Systems Corporation Configuration file management
US5740433A (en) 1995-01-24 1998-04-14 Tandem Computers, Inc. Remote duplicate database facility with improved throughput and fault tolerance
US5745897A (en) 1994-11-21 1998-04-28 Bay Networks Group, Inc. Method and system for compiling management information base specifications
US5748961A (en) 1993-07-12 1998-05-05 Digital Equipment Corporation Efficient method and apparatus for compiling and linking modules of computer code in a large software system
US5748892A (en) 1996-03-25 1998-05-05 Citrix Systems, Inc. Method and apparatus for client managed flow control on a limited memory computer system
US5754820A (en) 1991-07-09 1998-05-19 Kabushiki Kaisha Toshiba Microprocessor system with cache memory for eliminating unnecessary invalidation of cache data
US5761426A (en) 1995-08-24 1998-06-02 International Business Machines Corporation Method for executing communication between processors in parallel computer
US5774724A (en) 1995-11-20 1998-06-30 International Business Machines Coporation System and method for acquiring high granularity performance data in a computer system
US5805795A (en) 1996-01-05 1998-09-08 Sun Microsystems, Inc. Method and computer program product for generating a computer program product test that includes an optimized set of computer program product test cases, and method for selecting same
US5812799A (en) 1995-06-07 1998-09-22 Microunity Systems Engineering, Inc. Non-blocking load buffer and a multiple-priority memory system for real-time multiprocessing
US5835705A (en) 1997-03-11 1998-11-10 International Business Machines Corporation Method and system for performance per-thread monitoring in a multithreaded processor
US5850554A (en) 1995-12-29 1998-12-15 Intel Corporation Compiler tool set for efficiently generating and easily managing multiple program versions of different types
US5860024A (en) 1996-04-15 1999-01-12 Advanced Micro Devices, Inc. Microprocessor with automatic name generation including performance indication
US5867735A (en) 1995-06-07 1999-02-02 Microunity Systems Engineering, Inc. Method for storing prioritized memory or I/O transactions in queues having one priority level less without changing the priority when space available in the corresponding queues exceed
US5867649A (en) 1996-01-23 1999-02-02 Multitude Corporation Dance/multitude concurrent computation
US5872977A (en) 1997-08-08 1999-02-16 International Business Machines Corporation Object-oriented method and apparatus for creating a makefile
US5890171A (en) 1996-08-06 1999-03-30 Microsoft Corporation Computer system and computer-implemented method for interpreting hypertext links in a document when including the document within another document
US5905856A (en) 1996-02-29 1999-05-18 Bankers Trust Australia Limited Determination of software functionality
US5943499A (en) * 1996-11-27 1999-08-24 Hewlett-Packard Company System and method for solving general global data flow predicated code problems
US5963975A (en) 1994-04-19 1999-10-05 Lsi Logic Corporation Single chip integrated circuit distributed shared memory (DSM) and communications nodes
US5970510A (en) 1996-04-10 1999-10-19 Northrop Grumman Corporation Distributed memory addressing system
US5974536A (en) 1997-08-14 1999-10-26 Silicon Graphics, Inc. Method, system and computer program product for profiling thread virtual memory accesses
US5974510A (en) 1997-10-31 1999-10-26 Advanced Micro Devices, Inc. Method for testing the non-cacheable region functioning of a cache memory controller
US5991708A (en) 1997-07-07 1999-11-23 International Business Machines Corporation Performance monitor and method for performance monitoring within a data processing system
US6006031A (en) 1994-10-07 1999-12-21 Tandem Computers Incorporated Method and apparatus for reconciling conflicting translations by factoring and parameterizing differences
US6009514A (en) 1997-03-10 1999-12-28 Digital Equipment Corporation Computer method and apparatus for analyzing program instructions executing in a computer system
US6014517A (en) 1998-01-06 2000-01-11 Emc Corporation Automatic creation of C to assembler interface
US6016474A (en) 1995-09-11 2000-01-18 Compaq Computer Corporation Tool and method for diagnosing and correcting errors in a computer program
US6023583A (en) 1996-10-25 2000-02-08 Kabushiki Kaisha Toshiba Optimized variable allocation method, optimized variable allocation system and computer-readable memory containing an optimized variable allocation program
US6052763A (en) 1996-12-17 2000-04-18 Ricoh Company, Ltd. Multiprocessor system memory unit with split bus and method for controlling access to the memory unit
US6055368A (en) 1996-03-19 2000-04-25 Mitsubishi Denki Kabushiki Kaisha Batch execution control programming device and method
US6065019A (en) 1997-10-20 2000-05-16 International Business Machines Corporation Method and apparatus for allocating and freeing storage utilizing multiple tiers of storage organization
US6066181A (en) 1997-12-08 2000-05-23 Analysis & Technology, Inc. Java native interface code generator
US6077312A (en) 1998-05-06 2000-06-20 International Business Machines Corporation Apparatus, program product and method of debugging utilizing a context sensitive breakpoint
US6081868A (en) 1993-12-15 2000-06-27 Hewlett-Packard Company System and methods for performing cache latency diagnostics in scalable parallel processing architectures including calculating CPU idle time and counting number of cache misses
US6085029A (en) 1995-05-09 2000-07-04 Parasoft Corporation Method using a computer for automatically instrumenting a computer program for dynamic debugging
US6088771A (en) 1997-10-24 2000-07-11 Digital Equipment Corporation Mechanism for reducing latency of memory barrier operations on a multiprocessor system
US6098169A (en) 1997-12-23 2000-08-01 Intel Corporation Thread performance analysis by monitoring processor performance event registers at thread switch
US6101325A (en) 1996-10-10 2000-08-08 Microsoft Corporation Parameterized packaging system for programming languages
US6119198A (en) 1993-12-10 2000-09-12 Cray Research, Inc. Recursive address centrifuge for distributed memory massively parallel processing systems
US6145054A (en) 1998-01-21 2000-11-07 Sun Microsystems, Inc. Apparatus and method for handling multiple mergeable misses in a non-blocking cache
US6167565A (en) 1998-01-08 2000-12-26 Microsoft Corporation Method and system of custom marshaling of inter-language parameters
US6173368B1 (en) 1995-12-18 2001-01-09 Texas Instruments Incorporated Class categorized storage circuit for storing non-cacheable data until receipt of a corresponding terminate signal
US6173327B1 (en) 1996-07-11 2001-01-09 Jeroen De Borst Object-oriented method and apparatus for information delivery
US6205537B1 (en) 1998-07-16 2001-03-20 University Of Rochester Mechanism for dynamically adapting the complexity of a microprocessor
US6223134B1 (en) 1998-03-20 2001-04-24 National Instruments Corporation Instrumentation system and method including an improved driver software architecture
US6253252B1 (en) 1996-07-11 2001-06-26 Andrew Schofield Method and apparatus for asynchronously calling and implementing objects
US6263489B1 (en) * 1998-04-30 2001-07-17 Hewlett-Packard Company Method and apparatus for debugging of optimized code
US6263485B1 (en) 1996-07-11 2001-07-17 Andrew Schofield Method and apparatus for describing an interface definition language-defined interface, operation, and data type
US6269457B1 (en) 2000-06-01 2001-07-31 Testing Technologies, Inc. Technology regression and verification acceptance method
US6282702B1 (en) 1998-08-13 2001-08-28 Sun Microsystems, Inc. Method and apparatus of translating and executing native code in a virtual machine environment
US6286130B1 (en) 1997-08-05 2001-09-04 Intel Corporation Software implemented method for automatically validating the correctness of parallel computer programs
US6295600B1 (en) 1996-07-01 2001-09-25 Sun Microsystems, Inc. Thread switch on blocked load or store using instruction thread field
US6311320B1 (en) 1998-12-07 2001-10-30 Lsi Logic Corporation Alterable scripting tool and method
US6314429B1 (en) 1997-10-08 2001-11-06 Mitel Corporation Bi-directional conversion library
US6317871B1 (en) 1997-07-18 2001-11-13 Compaq Computer Corporation System for ensuring the accuracy of file structures in a source-to-source computer program translator
US6345384B1 (en) * 1998-04-22 2002-02-05 Kabushiki Kaisha Toshiba Optimized program code generator, a method for compiling a source text and a computer-readable medium for a processor capable of operating with a plurality of instruction sets
US6351845B1 (en) 1999-02-04 2002-02-26 Sun Microsystems, Inc. Methods, apparatus, and articles of manufacture for analyzing memory use
US6353869B1 (en) 1999-05-14 2002-03-05 Emc Corporation Adaptive delay of polling frequencies in a distributed system with a queued lock
US6353829B1 (en) 1998-12-23 2002-03-05 Cray Inc. Method and system for memory allocation in a multiprocessing environment
US6367071B1 (en) * 1999-03-02 2002-04-02 Lucent Technologies Inc. Compiler optimization techniques for exploiting a zero overhead loop mechanism
US6369725B1 (en) 2000-09-26 2002-04-09 International Business Machines Corporation Method for binary to decimal conversion
US6430657B1 (en) 1998-10-12 2002-08-06 Institute For The Development Of Emerging Architecture L.L.C. Computer system that provides atomicity by using a tlb to indicate whether an exportable instruction should be executed using cache coherency or by exporting the exportable instruction, and emulates instructions specifying a bus lock
US6434741B1 (en) * 1998-04-30 2002-08-13 Hewlett-Packard Company Method and apparatus for debugging of optimized code using emulation
US6434714B1 (en) 1999-02-04 2002-08-13 Sun Microsystems, Inc. Methods, systems, and articles of manufacture for analyzing performance of application programs
US6438745B1 (en) 1998-10-21 2002-08-20 Matsushita Electric Industrial Co., Ltd. Program conversion apparatus
US6442162B1 (en) 1998-11-17 2002-08-27 3Com Technologies Credit-based scheme for high performance communication between devices in a packet-based communication system
US6502136B1 (en) 1994-03-24 2002-12-31 Hitachi, Ltd. Exclusive control method with each node controlling issue of an exclusive use request to a shared resource, a computer system therefor and a computer system with a circuit for detecting writing of an event flag into a shared main storage
US6542919B1 (en) 1996-03-22 2003-04-01 Koninklijke Philips Electronics N.V. Operating system for use with protection domains in a single address space
US6574725B1 (en) 1999-11-01 2003-06-03 Advanced Micro Devices, Inc. Method and mechanism for speculatively executing threads of instructions
US6629214B1 (en) 1999-11-09 2003-09-30 International Business Machines Corporation Extended cache coherency protocol with a persistent “lock acquired” state
US6647546B1 (en) 2000-05-03 2003-11-11 Sun Microsystems, Inc. Avoiding gather and scatter when calling Fortran 77 code from Fortran 90 code
US6684296B2 (en) 2001-05-18 2004-01-27 Broadcom Corporation Source controlled cache allocation

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5740443A (en) * 1995-08-14 1998-04-14 International Business Machines Corporation Call-site specific selective automatic inlining
US6072951A (en) * 1997-10-15 2000-06-06 International Business Machines Corporation Profile driven optimization of frequently executed paths with inlining of code fragment (one or more lines of code from a child procedure to a parent procedure)

Patent Citations (107)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6173327B2 (en)
US4812996A (en) 1986-11-26 1989-03-14 Tektronix, Inc. Signal viewing instrumentation control system
US5146593A (en) 1989-03-06 1992-09-08 International Business Machines Corporation Procedure call interface
US5168563A (en) 1989-03-29 1992-12-01 Hewlett-Packard Company Various possible execution paths measurement and analysis system for evaluating before writing source codes the efficiency performance of software designs
US5075847A (en) 1989-05-26 1991-12-24 Hewlett-Packard Company Method and apparatus for computer program encapsulation
US5499349A (en) 1989-05-26 1996-03-12 Massachusetts Institute Of Technology Pipelined processor with fork, join, and start instructions using tokens to indicate the next instruction for each of multiple threads of execution
US5119465A (en) 1989-06-19 1992-06-02 Digital Equipment Corporation System for selectively converting plurality of source data structures through corresponding source intermediate structures, and target intermediate structures into selected target structure
US5274821A (en) 1989-08-14 1993-12-28 International Business Machines Corporation Communication between prolog and an external process
US5079707A (en) 1990-01-19 1992-01-07 The Boeing Company Integrated certification-calibration system for a testing system having multiple test instruments
US5325499A (en) 1990-09-28 1994-06-28 Tandon Corporation Computer system including a write protection circuit for preventing illegal write operations and a write poster with improved memory
US5754820A (en) 1991-07-09 1998-05-19 Kabushiki Kaisha Toshiba Microprocessor system with cache memory for eliminating unnecessary invalidation of cache data
US5301312A (en) 1991-08-21 1994-04-05 International Business Machines Corporation Method and system for utilizing benign fault occurrence to measure interrupt-blocking times
US5535393A (en) * 1991-09-20 1996-07-09 Reeve; Christopher L. System for parallel processing that compiles a filed sequence of instructions within an iteration space
US5530816A (en) 1991-11-02 1996-06-25 International Computers Limited Data processing system for handling multiple independent data-driven instruction streams
US5481708A (en) * 1992-06-05 1996-01-02 Borland International, Inc. System and methods for optimizing object-oriented compilations
US5438659A (en) 1992-10-08 1995-08-01 Hewlett-Packard Company Object-action user interface management system
US5390314A (en) 1992-10-09 1995-02-14 American Airlines, Inc. Method and apparatus for developing scripts that access mainframe resources that can be executed on various computer systems having different interface languages without modification
US5553235A (en) 1992-10-23 1996-09-03 International Business Machines Corporation System and method for maintaining performance data in a data processing system
US5353401A (en) 1992-11-06 1994-10-04 Ricoh Company, Ltd. Automatic interface layout generator for database systems
US5519866A (en) 1993-06-28 1996-05-21 Taligent, Inc. Method and apparatus of incrementally linking components of a modeled computer program
US5325533A (en) 1993-06-28 1994-06-28 Taligent, Inc. Engineering system for modeling computer programs
US5497458A (en) 1993-07-06 1996-03-05 Dell Usa, L.P. Cache testability circuit for embedded diagnostics
US5748961A (en) 1993-07-12 1998-05-05 Digital Equipment Corporation Efficient method and apparatus for compiling and linking modules of computer code in a large software system
US5737605A (en) 1993-10-12 1998-04-07 International Business Machines Corporation Data processing system for sharing instances of objects with multiple processes
US6119198A (en) 1993-12-10 2000-09-12 Cray Research, Inc. Recursive address centrifuge for distributed memory massively parallel processing systems
US6081868A (en) 1993-12-15 2000-06-27 Hewlett-Packard Company System and methods for performing cache latency diagnostics in scalable parallel processing architectures including calculating CPU idle time and counting number of cache misses
US5485619A (en) 1993-12-29 1996-01-16 International Business Machines Corporation Array variable transformation system employing subscript table mapping to scalar loop indices
US5636374A (en) 1994-01-04 1997-06-03 Intel Corporation Method and apparatus for performing operations based upon the addresses of microinstructions
US5539907A (en) 1994-03-01 1996-07-23 Digital Equipment Corporation System for monitoring computer system performance
US6502136B1 (en) 1994-03-24 2002-12-31 Hitachi, Ltd. Exclusive control method with each node controlling issue of an exclusive use request to a shared resource, a computer system therefor and a computer system with a circuit for detecting writing of an event flag into a shared main storage
US5640550A (en) 1994-04-15 1997-06-17 Coker; Drake Computer system for generating SQL statements from COBOL code
US5963975A (en) 1994-04-19 1999-10-05 Lsi Logic Corporation Single chip integrated circuit distributed shared memory (DSM) and communications nodes
US5710727A (en) 1994-05-04 1998-01-20 National Instruments Corporation System and method for creating resources in an instrumentation system
US5673387A (en) 1994-05-16 1997-09-30 Lucent Technologies Inc. System and method for selecting test units to be re-run in software regression testing
US5724262A (en) 1994-05-31 1998-03-03 Paradyne Corporation Method for measuring the usability of a system and for task analysis and re-engineering
US5574922A (en) 1994-06-17 1996-11-12 Apple Computer, Inc. Processor with sequences of processor instructions for locked memory updates
US5613063A (en) 1994-07-01 1997-03-18 Digital Equipment Corporation Method and apparatus for checking validity of memory operations
US5689712A (en) 1994-07-27 1997-11-18 International Business Machines Corporation Profile-based optimizing postprocessors for data references
US6006031A (en) 1994-10-07 1999-12-21 Tandem Computers Incorporated Method and apparatus for reconciling conflicting translations by factoring and parameterizing differences
US5745897A (en) 1994-11-21 1998-04-28 Bay Networks Group, Inc. Method and system for compiling management information base specifications
US5740433A (en) 1995-01-24 1998-04-14 Tandem Computers, Inc. Remote duplicate database facility with improved throughput and fault tolerance
US6085029A (en) 1995-05-09 2000-07-04 Parasoft Corporation Method using a computer for automatically instrumenting a computer program for dynamic debugging
US5867735A (en) 1995-06-07 1999-02-02 Microunity Systems Engineering, Inc. Method for storing prioritized memory or I/O transactions in queues having one priority level less without changing the priority when space available in the corresponding queues exceed
US5812799A (en) 1995-06-07 1998-09-22 Microunity Systems Engineering, Inc. Non-blocking load buffer and a multiple-priority memory system for real-time multiprocessing
US5761426A (en) 1995-08-24 1998-06-02 International Business Machines Corporation Method for executing communication between processors in parallel computer
US6016474A (en) 1995-09-11 2000-01-18 Compaq Computer Corporation Tool and method for diagnosing and correcting errors in a computer program
US5774724A (en) 1995-11-20 1998-06-30 International Business Machines Coporation System and method for acquiring high granularity performance data in a computer system
US6173368B1 (en) 1995-12-18 2001-01-09 Texas Instruments Incorporated Class categorized storage circuit for storing non-cacheable data until receipt of a corresponding terminate signal
US5850554A (en) 1995-12-29 1998-12-15 Intel Corporation Compiler tool set for efficiently generating and easily managing multiple program versions of different types
US5805795A (en) 1996-01-05 1998-09-08 Sun Microsystems, Inc. Method and computer program product for generating a computer program product test that includes an optimized set of computer program product test cases, and method for selecting same
US5867649A (en) 1996-01-23 1999-02-02 Multitude Corporation Dance/multitude concurrent computation
US5740431A (en) 1996-01-24 1998-04-14 Electronic Data Systems Corporation Configuration file management
US5905856A (en) 1996-02-29 1999-05-18 Bankers Trust Australia Limited Determination of software functionality
US6055368A (en) 1996-03-19 2000-04-25 Mitsubishi Denki Kabushiki Kaisha Batch execution control programming device and method
US6542919B1 (en) 1996-03-22 2003-04-01 Koninklijke Philips Electronics N.V. Operating system for use with protection domains in a single address space
US5748892A (en) 1996-03-25 1998-05-05 Citrix Systems, Inc. Method and apparatus for client managed flow control on a limited memory computer system
US5970510A (en) 1996-04-10 1999-10-19 Northrop Grumman Corporation Distributed memory addressing system
US5968114A (en) 1996-04-10 1999-10-19 Northrop Grumman Corporation Memory interface device
US5860024A (en) 1996-04-15 1999-01-12 Advanced Micro Devices, Inc. Microprocessor with automatic name generation including performance indication
US6295600B1 (en) 1996-07-01 2001-09-25 Sun Microsystems, Inc. Thread switch on blocked load or store using instruction thread field
US6263485B1 (en) 1996-07-11 2001-07-17 Andrew Schofield Method and apparatus for describing an interface definition language-defined interface, operation, and data type
US6173327B1 (en) 1996-07-11 2001-01-09 Jeroen De Borst Object-oriented method and apparatus for information delivery
US6253252B1 (en) 1996-07-11 2001-06-26 Andrew Schofield Method and apparatus for asynchronously calling and implementing objects
US5890171A (en) 1996-08-06 1999-03-30 Microsoft Corporation Computer system and computer-implemented method for interpreting hypertext links in a document when including the document within another document
US6101325A (en) 1996-10-10 2000-08-08 Microsoft Corporation Parameterized packaging system for programming languages
US6023583A (en) 1996-10-25 2000-02-08 Kabushiki Kaisha Toshiba Optimized variable allocation method, optimized variable allocation system and computer-readable memory containing an optimized variable allocation program
US5943499A (en) * 1996-11-27 1999-08-24 Hewlett-Packard Company System and method for solving general global data flow predicated code problems
US6052763A (en) 1996-12-17 2000-04-18 Ricoh Company, Ltd. Multiprocessor system memory unit with split bus and method for controlling access to the memory unit
US6009514A (en) 1997-03-10 1999-12-28 Digital Equipment Corporation Computer method and apparatus for analyzing program instructions executing in a computer system
US6052708A (en) 1997-03-11 2000-04-18 International Business Machines Corporation Performance monitoring of thread switch events in a multithreaded processor
US5835705A (en) 1997-03-11 1998-11-10 International Business Machines Corporation Method and system for performance per-thread monitoring in a multithreaded processor
US5991708A (en) 1997-07-07 1999-11-23 International Business Machines Corporation Performance monitor and method for performance monitoring within a data processing system
US6317871B1 (en) 1997-07-18 2001-11-13 Compaq Computer Corporation System for ensuring the accuracy of file structures in a source-to-source computer program translator
US6286130B1 (en) 1997-08-05 2001-09-04 Intel Corporation Software implemented method for automatically validating the correctness of parallel computer programs
US5872977A (en) 1997-08-08 1999-02-16 International Business Machines Corporation Object-oriented method and apparatus for creating a makefile
US5974536A (en) 1997-08-14 1999-10-26 Silicon Graphics, Inc. Method, system and computer program product for profiling thread virtual memory accesses
US6314429B1 (en) 1997-10-08 2001-11-06 Mitel Corporation Bi-directional conversion library
US6065019A (en) 1997-10-20 2000-05-16 International Business Machines Corporation Method and apparatus for allocating and freeing storage utilizing multiple tiers of storage organization
US6088771A (en) 1997-10-24 2000-07-11 Digital Equipment Corporation Mechanism for reducing latency of memory barrier operations on a multiprocessor system
US5974510A (en) 1997-10-31 1999-10-26 Advanced Micro Devices, Inc. Method for testing the non-cacheable region functioning of a cache memory controller
US6066181A (en) 1997-12-08 2000-05-23 Analysis & Technology, Inc. Java native interface code generator
US6098169A (en) 1997-12-23 2000-08-01 Intel Corporation Thread performance analysis by monitoring processor performance event registers at thread switch
US6014517A (en) 1998-01-06 2000-01-11 Emc Corporation Automatic creation of C to assembler interface
US6167565A (en) 1998-01-08 2000-12-26 Microsoft Corporation Method and system of custom marshaling of inter-language parameters
US6145054A (en) 1998-01-21 2000-11-07 Sun Microsystems, Inc. Apparatus and method for handling multiple mergeable misses in a non-blocking cache
US6223134B1 (en) 1998-03-20 2001-04-24 National Instruments Corporation Instrumentation system and method including an improved driver software architecture
US6345384B1 (en) * 1998-04-22 2002-02-05 Kabushiki Kaisha Toshiba Optimized program code generator, a method for compiling a source text and a computer-readable medium for a processor capable of operating with a plurality of instruction sets
US6434741B1 (en) * 1998-04-30 2002-08-13 Hewlett-Packard Company Method and apparatus for debugging of optimized code using emulation
US6263489B1 (en) * 1998-04-30 2001-07-17 Hewlett-Packard Company Method and apparatus for debugging of optimized code
US6077312A (en) 1998-05-06 2000-06-20 International Business Machines Corporation Apparatus, program product and method of debugging utilizing a context sensitive breakpoint
US6205537B1 (en) 1998-07-16 2001-03-20 University Of Rochester Mechanism for dynamically adapting the complexity of a microprocessor
US6282702B1 (en) 1998-08-13 2001-08-28 Sun Microsystems, Inc. Method and apparatus of translating and executing native code in a virtual machine environment
US6430657B1 (en) 1998-10-12 2002-08-06 Institute For The Development Of Emerging Architecture L.L.C. Computer system that provides atomicity by using a tlb to indicate whether an exportable instruction should be executed using cache coherency or by exporting the exportable instruction, and emulates instructions specifying a bus lock
US6438745B1 (en) 1998-10-21 2002-08-20 Matsushita Electric Industrial Co., Ltd. Program conversion apparatus
US6442162B1 (en) 1998-11-17 2002-08-27 3Com Technologies Credit-based scheme for high performance communication between devices in a packet-based communication system
US6311320B1 (en) 1998-12-07 2001-10-30 Lsi Logic Corporation Alterable scripting tool and method
US6353829B1 (en) 1998-12-23 2002-03-05 Cray Inc. Method and system for memory allocation in a multiprocessing environment
US6434714B1 (en) 1999-02-04 2002-08-13 Sun Microsystems, Inc. Methods, systems, and articles of manufacture for analyzing performance of application programs
US6351845B1 (en) 1999-02-04 2002-02-26 Sun Microsystems, Inc. Methods, apparatus, and articles of manufacture for analyzing memory use
US6367071B1 (en) * 1999-03-02 2002-04-02 Lucent Technologies Inc. Compiler optimization techniques for exploiting a zero overhead loop mechanism
US6353869B1 (en) 1999-05-14 2002-03-05 Emc Corporation Adaptive delay of polling frequencies in a distributed system with a queued lock
US6574725B1 (en) 1999-11-01 2003-06-03 Advanced Micro Devices, Inc. Method and mechanism for speculatively executing threads of instructions
US6629214B1 (en) 1999-11-09 2003-09-30 International Business Machines Corporation Extended cache coherency protocol with a persistent “lock acquired” state
US6647546B1 (en) 2000-05-03 2003-11-11 Sun Microsystems, Inc. Avoiding gather and scatter when calling Fortran 77 code from Fortran 90 code
US6269457B1 (en) 2000-06-01 2001-07-31 Testing Technologies, Inc. Technology regression and verification acceptance method
US6369725B1 (en) 2000-09-26 2002-04-09 International Business Machines Corporation Method for binary to decimal conversion
US6684296B2 (en) 2001-05-18 2004-01-27 Broadcom Corporation Source controlled cache allocation

Non-Patent Citations (28)

* Cited by examiner, † Cited by third party
Title
"Code Complete: A Practical Handbook of Software Construction," Steve McConnell, 1993, Microsoft Press.
"dcpid-DIGITAL Continuous Profiling Infrastructure daemon", Man pages for SCR-Installed Programs (Alpha/NT), Online <URL:http://research.compaq.com/SRC/dcpi/html/ntalpha/dcpi.html>, 1997, pp. 1-6.
"Visual Basic 5.0 Introduction", Windows 95 Student Manual, XX, XX, 1997, XP002926932.
Ayers et al, "Aggressive inlining", ACM PLDI, pp 134145, 1997. *
Broberg et al., "Visualization and Performance Prediction of Multithreaded Solaris Programs by Tracing Kernel Threads", Department of Software Engineering and Computer Science, University of Karlskrona/Ronneby, Sweden, 7 pages.
Browne et al., "PAPI: Portable Interface to Hardware Performance Counters," Cewes Major Shared Resources Center Pet Technical Reports, vol. 99-06, 1999, Online, <URL:http://www.wes.hpc.mil/pet/tech_reports/reports/pdf/tr_9906.pdf>, pp. 3-13.
Buckley, A., "Conversion to Fortran 90: A Case Study", ACM, 1994, pp. 308-353.
Cantrill B.M. et al., "ThreadMon: A Tool for Monitoring Multithreaded Program Performance," System Sciences, 1997, Proceedings of the Thirtieth Hawaii Int'l Conference of Wailea, HI, USA Jan. 7-10, 1997, pp. 253-265.
Conradi et al., "Version models for software configuration management," ACM Computing Surveys, vol. 30, No. 2, Jun. 1998, pp. 232-282.
Cooper, Keith D., et al., "An Experiment with Inline Substitution," Software Practice and Experience, vol. 21, No. 6; Jun. 1991, pp. 581-601.
Grundy, J.C., et al., "Supporting Flexible Consistency Management Via Discrete Change Description Propagation", Software Practice & Experience, John Wiley & Sons Ltd. Chichester, GB, vol. 26, No. 9 XP000655597.
Haggander et al., "Optimizing Dynamic Memory Management in a Multithreaded Application Executing on a Multiprocessor", International Conference on Parallel Processing, Minneapolis, MN, Aug. 10-14, 1998, pp. 262-269.
Holland, Angela, et al., "A Compiler for Selective Procedure Inlining," Proceedings of the Annual Southeast Conference, 1993, pp. 207-212.
IBM Technical Disclosure Bulletin, "Internal Performance Measurement Counters," IBM Corp., vol. 34, No. 4A, Sep. 1991, pp. 51-52 (the whole document).
IBM Technical Disclosure Bulletin, "Simultaneous Viewing of Performance Monitor Data Independent of Counters," IBM Corp., vol. 39, No. 10, Oct. 1996, pp. 181-183.
Karavanic K. L. et al., "Integrated Visualization of Parallel Program Performance Data," vol. 23, No. 1, Apr. 1, 1997, pp. 181-198.
Kevin Dowd and Charles R. Severance, "High Performance Computing," Second Edition, Chapter 10, Shared Memory Multiprocessors, Aug. 1998, pp. 216-218.
Larson et al., "Memory Allocation for Long-Running Server Applications," ISMM 1998, International Symposium on Memory Management, Vancouver, BC, Canada, Oct. 17-19, 1998, vol. 34, No. 3, pp. 176-185.
Metcalf, Michael, "convert.f90", CERN, Geneva 1991, 1997 pp. 1-27, ftp://ftp>numerical.rl.ac.uk/pub/MandR/convert.f90.
Nathan P. Kropp, Philip J. Koopman, Daniel P. Siewiorek, "Automated Robustness Testing of Off-the-Shelf Software Components," Institute for Complex Engineered Systems, Carnegie Mellon University, Pittsburgh, PA, pps. 230-239.
Ogasawara et al, "A study of exception handling and its dynamic optimization in Java", ACM OOPSLA, pp 83-95, 2001. *
Poul-Henning Kamp, "Malloc(3) in Modern Virtual Memory Environments," XP-002283869, FreeBSD.org on-line document, Revised Fri. Apr. 5, 12:50:07 1996, pp. 1-7.
Purtilo, J, et al., "Module Reuse by Interface Adaption", Software-Practice and Experience, 1991, pp. 539-556.
Suganuma et al, "A region based compilation techniques for a java just in time compiler", ACM PLDI, pp 312-323, Jun./2003. *
Sun Microsystems Computer Company, "Prism 5.0 Reference Manual," Revision A., Nov. 1997.
Valvano, "Debugging Strategies," Chapter 6, pp. 6.1-6.10, Real Time Debugging, Online Manual, Jun. 7, 1999, Retrieved from the Internet: <URL:http://ece.utexas.edu/ävalvano/EE360P/PDF/Ch6.pdf>.
Wenmei et al, "Inline function expansion for computing C Programs", ACM pp 246257, 1989. *
Zagha et al., "Performance Analysis Using the MIPS R10000 Performance Counters", SC96 Technical Papers, Online, <URL:http://www.supercomp.org/sc96/proceedings/SC96PROC/ZAGHA/INDEX.HTM>, Nov. 1996, pp. 1-22.

Cited By (35)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7739667B2 (en) * 1998-12-23 2010-06-15 Cray Inc. Parallelism performance analysis based on execution trace information
US20060101416A1 (en) * 1998-12-23 2006-05-11 Callahan Charles D Ii Parallelism performance analysis based on execution trace information
US20030188187A1 (en) * 2002-03-25 2003-10-02 Nec Corporation Obfuscated source program, source program conversion method and apparatus, and source conversion program
US20040250234A1 (en) * 2003-06-09 2004-12-09 Sun Microsystems, Inc. Systems and methods for software performance tuning
US20050021655A1 (en) * 2003-06-09 2005-01-27 Sun Microsystems, Inc. System for efficiently acquiring and sharing runtime statistics
US20040250235A1 (en) * 2003-06-09 2004-12-09 Sun Microsystems, Inc. Methods and apparatus for enhanced statistical performance
US7406686B2 (en) * 2003-06-09 2008-07-29 Sun Microsystems, Inc. Systems and methods for software performance tuning
US20050071826A1 (en) * 2003-09-30 2005-03-31 International Business Machines Corporation Determining how many class-type checks to inline
US7266813B2 (en) * 2003-09-30 2007-09-04 International Business Machines Corporation Determining how many class-type checks to inline
US20070010975A1 (en) * 2004-06-05 2007-01-11 International Business Machines Corporation Probabilistic regression suites for functional verification
US7729891B2 (en) * 2004-06-05 2010-06-01 International Business Machines Corporation Probabilistic regression suites for functional verification
US8266606B2 (en) * 2004-09-09 2012-09-11 International Business Machines Corporation Self-optimizable code for optimizing execution of tasks and allocation of memory in a data processing system
US20080222637A1 (en) * 2004-09-09 2008-09-11 Marc Alan Dickenson Self-Optimizable Code
US8762974B1 (en) * 2005-06-30 2014-06-24 The Mathworks, Inc. Context-sensitive compiler directives
US20070234307A1 (en) * 2006-03-06 2007-10-04 Chi-Keung Luk Methods and apparatus to inline conditional software instrumentation
US7818730B1 (en) * 2006-06-30 2010-10-19 The Math Works, Inc. Automatic minimal build dependency determination and building an executable with source code
US20090254878A1 (en) * 2008-04-04 2009-10-08 Intuit Inc. Executable code generated from common source code
US9454390B2 (en) * 2008-04-04 2016-09-27 Intuit Inc. Executable code generated from common source code
US20100204809A1 (en) * 2009-02-09 2010-08-12 Siemens Ag Method for Operating an Automation System, Corresponding Computer Program and System or Device that Operates According to the Method
US8701097B2 (en) 2010-11-05 2014-04-15 International Business Machines Corporation Partial inlining with software based restart
US9405517B2 (en) 2012-07-02 2016-08-02 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US9424014B2 (en) 2012-07-02 2016-08-23 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US9417858B2 (en) 2012-07-02 2016-08-16 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US9411567B2 (en) 2012-07-02 2016-08-09 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US9158517B2 (en) * 2012-07-02 2015-10-13 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US9164743B2 (en) * 2012-07-02 2015-10-20 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US9250879B2 (en) 2012-07-02 2016-02-02 International Business Machines Corporation Strength reduction compiler optimizations
US9256411B2 (en) 2012-07-02 2016-02-09 International Business Machines Corporation Strength reduction compiler optimizations
US20140007062A1 (en) * 2012-07-02 2014-01-02 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US20140007064A1 (en) * 2012-07-02 2014-01-02 International Business Machines Corporation Strength reduction compiler optimizations for operations with unknown strides
US8856763B2 (en) 2012-11-07 2014-10-07 International Business Machines Corporation Compiler optimization based on collectivity analysis
US8839216B2 (en) * 2012-11-07 2014-09-16 International Business Machines Corporation Compiler optimization based on collectivity analysis
US20140130025A1 (en) * 2012-11-07 2014-05-08 International Business Machines Corporation Compiler optimization based on collectivity analysis
US9304748B2 (en) 2013-08-07 2016-04-05 Qualcomm Incorporated Method for controlling inlining in a code generator
US9430196B2 (en) * 2014-10-16 2016-08-30 Cisco Technology, Inc. Message inlining

Also Published As

Publication number Publication date Type
WO2002010909A2 (en) 2002-02-07 application
WO2002010909A3 (en) 2005-02-24 application

Similar Documents

Publication Publication Date Title
Krall Efficient JavaVM just-in-time compilation
Holzle et al. Adaptive optimization for SELF: reconciling high performance with exploratory programming
US6708325B2 (en) Method for compiling high level programming languages into embedded microprocessor with multiple reconfigurable logic
US6243864B1 (en) Compiler for optimizing memory instruction sequences by marking instructions not having multiple memory address paths
US5999737A (en) Link time optimization via dead code elimination, code motion, code partitioning, code grouping, loop analysis with code motion, loop invariant analysis and active variable to register analysis
US6072952A (en) Method and apparatus for coalescing variables
US6289507B1 (en) Optimization apparatus and computer-readable storage medium storing optimization program
US6484313B1 (en) Compiling and persisting of intermediate language code
US6938249B2 (en) Compiler apparatus and method for optimizing loops in a computer program
US5375242A (en) Compiler architecture for cross-module optimization
US5812855A (en) System and method for constaint propagation cloning for unknown edges in IPA
US6170083B1 (en) Method for performing dynamic optimization of computer code
US6275981B1 (en) Method and system for correlating profile data dynamically generated from an optimized executable program with source code statements
US5537620A (en) Redundant load elimination on optimizing compilers
US7146607B2 (en) Method and system for transparent dynamic optimization in a multiprocessing environment
Li Array privatization for parallel execution of loops
US5966537A (en) Method and apparatus for dynamically optimizing an executable computer program using input data
US4961141A (en) Generating efficient code for a computer with dissimilar register spaces
US6128775A (en) Method, system, and computer program product for performing register promotion via load and store placement optimization within an optimizing compiler
US5581762A (en) Compiling apparatus having a function to analyze overlaps of memory addresses of two or more data expressions and a compiling method
US6233733B1 (en) Method for generating a Java bytecode data flow graph
US6223340B1 (en) Method for directly inlining virtual calls without on-stack replacement
US6044221A (en) Optimizing code based on resource sensitive hoisting and sinking
US6301706B1 (en) Compiler method and apparatus for elimination of redundant speculative computations from innermost loops
US6631518B1 (en) Generating and utilizing organized profile information

Legal Events

Date Code Title Description
AS Assignment

Owner name: SUN MICROSYSTEMS, INC., CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:BOUCHER, MICHAEL;REEL/FRAME:010972/0160

Effective date: 20000720

FPAY Fee payment

Year of fee payment: 4

FPAY Fee payment

Year of fee payment: 8

AS Assignment

Owner name: ORACLE AMERICA, INC., CALIFORNIA

Free format text: MERGER AND CHANGE OF NAME;ASSIGNORS:ORACLE USA, INC.;SUN MICROSYSTEMS, INC.;ORACLE AMERICA, INC.;REEL/FRAME:037280/0188

Effective date: 20100212

FPAY Fee payment

Year of fee payment: 12