System and method for performing selective dynamic compilation using run-time information

A method for automatically conditionally specializing source code for a computer program to generate machine-executable instructions that comprise statically-compiled code portions and specialized code portions, said specialized code portions including dynamically-compiled instructions that are generated at run time when the machine-executable instructions are executed by a processor, comprising the steps of:

• (a) identifying one or more program points in the source code for implementing the specialized code portions;
• (b) annotating the source code in proximity to said one or more program points by entering at least one conditional statement at each program point;
• and
• (c) processing each conditional statement so as to direct the generation of a corresponding specialized code portion based on evaluation of the conditional statement.

A method for automatically positioning cache lookups within a specialized computer program, said specialized computer program including a plurality of procedures and comprising statically-compiled code portions and dynamically-compiled code portions, each dynamically compiled code portion being generated at run time when the specialized computer program is executed by a processor, comprising the steps of:

• (a) identifying ranges within the dynamically-compiled code portions that include code potentially reusable during execution of the specialized computer program, each range corresponding to a run-time constant and spanning program points between which said run-time constant is in use;
• (b) coalescing the ranges identified by forming intersections between ranges that span common program points;
• and
• (c) placing the cache lookups within the ranges that have been coalesced.

A method for automatically enabling on-demand specialization to be produced across arbitrary control flow edges in a computer program comprising source code processed to generate machine-executable instructions, said machine instructions comprising statically-compiled code portions and specialized code portions, said specialized code portions including dynamically-compiled instructions that are generated at run time when the machine instructions are executed by a processor, comprising the steps of:

• (a) generating a control flow graph of the computer program, the control flow graph comprising pairs of blocks of code and edges, wherein each pair of blocks includes a source block connected by an edge to a destination block, and wherein the edge contains no source code;
• (b) generating a specialized source block based on any variables expected to be constant during the run-time execution of said source block;
• and
• (c) replacing an edge that connects the specialized source block to a destination block with code that generates a stub immediately after the specialized source block, the stub, when executed, gathering values for variables that comprise a context of specialization for the destination block, and invoking a routine to create a specialized destination block with respect to the context.

A system for automatically processing a computer program comprising source code to generate machine-executable instructions, said machine-executable instructions including statically-compiled code portions and specialized code portions, said specialized code portions including dynamically-compiled instructions that are generated at run time when the machine-executable instructions are executed, comprising:

• (a) a memory in which a plurality of machine instructions are stored;
• and
• (b) a processor, coupled to the memory and responsive to the machine instructions, the machine instructions, when executed by the processor, causing the processor to:
• (i) enable a user to annotate the source code with program statements corresponding to predefined policies, which are stored in the memory, said policies having associated values that define directions for generating said specialized code portions and for integrating said specialized code portions with said statically-compiled code portions, the program statements being introduced in the source code so as to operate on associated run-time constant variables;
• (ii) bind the associated values to variables;
• and
• (iii) process the source code to generate the statically-compiled code portions and to create run-time specializers, said run-time specializers comprising extensions that dynamically compile the specialized code portions when said specialized code portions are requested to be executed at run time, based on the values bound to the variables.