International Business Machines Corporation

Bilha Mendelson

William Jon Schmidt

Vita Bortnikov

Inbal Shavit-Lottem

Robert Ralph Roediger

Mark Novick

Nimrod Megiddo

Steven R Kunkel

Mark Robert Funk

Nitzan Peleg

Jan Civlin

Marina Biberstein

Mikko Herman Lipasti

Sara Porat

Itai Nahshon

David Bernstein

David John Lambert

Robert Ralph Roedinger

Gadi Haber

Larry Koved

A computer implemented method, apparatus, and computer program product for generating an optimization insensitive behavior profile. In one embodiment, a source identifier is assigned to each instruction in an original control flow graph representing a program code prior to optimization. The identifiers identify a basic block associated with the instruction or a group of basic blocks. A source identifier in the set of source identifiers is assigned to instructions in an optimized control flow graph representing the program code after optimizing the program code. The instructions in the optimized control flow graph are mapped to the original control flow graph using the set of source identifiers to form a mapping transformation. Behavior profile data associated with the optimized program code is moved to basic blocks in the original control flow graph using the mapping transformation to form the optimization insensitive behavior profile.

Detecting change in program behavior for adaptive code optimization

A system and method for detecting the mutability of fields and classes in an arbitrary program component written in an object oriented programming language is disclosed. A variable is considered to be mutable if a new value is stored into it, as well as if any of its reachable variables are mutable. The system and method uses a static analysis algorithm which can be applied to any software component rather than whole programs. The analysis classifies fields and classes as either mutable or immutable. In order to facilitate open-world analysis, the algorithm identifies situations that expose variables to potential modification by code outside the component, as well as situations where variables are modified by the analyzed code. An implementation of the analysis is presented which focuses on detecting mutability of class variables, so as to avoid isolation problems. The implementation incorporates intra- and inter-procedural data-flow analyses and is shown to be highly scalable. Experimental results demonstrate the effectiveness of the algorithms.

Mutability analysis in Java

A program product and method of compiling a computer program to optimize performance of a computer program. First, after initialization, a profiling run is done on computer code which may include program code blocks and program data. Execution of each computer program step is monitored and each occurrence of each individual code unit is logged, e.g. each instruction block or block of data. Frequently occurring code units are identified periodically as hot blocks. An initial snapshot of hot blocks is logged, e.g., when identified hot blocks exceed an initial block number. Profiling continues until the profiling run is complete, updating identified hot blocks and logging a new current snapshot whenever a current set of identified hot blocks contains a selected percentage of different hot blocks. Snapshots are selected as representative to different program modes. The program is optimized according to program modes.

Restructuring of executable computer code and large data sets

Disclosed is a system and method for a profiling system wherein profile data is stored in a separable hierarchical fashion such that profile data for each compiled procedure in a computer program can be readily identified and utilized. In particular, each source module has a corresponding profile data file and each procedure has a corresponding procedure profile area. The system and method also includes a mechanism for verifying the existence and validity of profile information, and a mechanism for handling invalid profile information.

Generating and utilizing organized profile information

The data cache management mechanism of the present invention is created by an optimizing compiler. The optimizing compiler intelligently places non-blocking preload instructions into the instruction stream of the computer system so as to minimize both the frequency and detrimental effect of cache misses. The non-blocking preload instructions are placed into the instruction stream based on the existence of predictor constructs that foretell what information the processor will need and when it will need it. As a result, cache misses are either avoided entirely or reduced in severity.

Intelligent cache management mechanism

A method for effecting a direct jump in an executable program module to a target address displaced from a source address by a specified distance that is greater than a maximum permitted range. During program linkage the direct jump is split into at least two component direct jumps each no greater than the maximum permitted range, thus allowing the direct jump to be achieved by jumping sequentially from the source address to the target address via each of the component direct jumps. A storage medium for storing data representative of the executable program module contains at least one trampoline for performing the component direct jumps.

Method and storage medium for building very large executable programs

An apparatus and method reorder portions of a computer program in a way that achieves both enhanced performance and maintainability of the computer program. A global call graph is initially constructed that includes profile data. From the information in the global call graph, an intramodular call graph is generated for each module. Reordering techniques are used to reorder the procedures in each module according to the profile data in each intramodular call graph. An intermodular call graph is generated from the information in the global call graph. Reordering techniques are used to reorder the modules in the computer program. By reordering procedures within modules, then reordering the modules, enhanced performance is achieved without reordering procedures across module boundaries. Respecting module boundaries enhances the maintainability of the computer program by allowing a module to be replaced without adversely affecting the other modules while still providing many of the advantages of global procedure reordering.

Method and apparatus for modular reordering of portions of a computer

An apparatus and several methods provide for a more optimized computer program that will have a faster execution time than was possible using the prior art reordering technique that adds to a trace until it finds no more predecessors or successors to add. The apparatus and methods disclosed herein use a variety of methods to reorder the program portions in a more intelligent manner that will improve its run-time performance. Each of these methods involves constructing traces in the control flow graph of the computer program. In a first embodiment, a basic block is only added to a trace if it is not negligible within predetermined limits. This negligibility test results in traces that are not extended for infrequently executed basic blocks. In a second embodiment, a basic block is only added to a trace if it is a perfect partner with the last basic block added to the trace. The concept of a 'perfect partner' helps to match basic blocks together in a trace that have the greatest affinity for each other. In a third embodiment, a basic block is only added to a trace if it satisfies 'should follow' flags and predetermined negligibility criteria. The 'should follow' flags and negligibility criteria provide a complex criteria for adding basic blocks to a trace, criteria that create more efficient code in some specific circumstances.

Growing community of inventors

Haifa, Israel

Bilha Mendelson