International Business Machines Corporation

Daniel Rodman Hicks

William Jon Schmidt

James Albert Kryka

Marc Noel Blais

John Matthew Santosuosso

Gary Ross Ricard

Elliot Karl Kolodner

Andrew Johnson

Laurence Edward England

Robert Ralph Roediger

John Clarence Endicott

Robert John Donovan

Jeffrey A Grantz

John J Vriezen

Robert Milton Smith

Robert Carl Seemann

Ralph O Conder

William N Tindall

David John Lambert

William Peter Carney

George Lausman

Frank Edward Benson

Dynamic compilation logic collects execution statistics into a persistent store as a computer program is executed so the execution statistics may be used by the dynamic compilation logic in subsequent executions of the computer program. By saving execution statistics in a persistent store, the dynamic compilation logic can use the execution statistics from previous executions to know which portions of the computer program to immediately compile when the execution of the computer program begins, and how to best compile and optimize certain portions of the computer program. In the preferred embodiments, the persistent store is an attachment to an object oriented class file.

Dynamic compiler apparatus and method that stores and uses persistent execution statistics

An apparatus and method provide a cache for analyzed program information when no class file can be identified. When loading a class, if there is an identifiable class file for the class, the class file is checked to determine if analyzed program information is attached. If so, the analyzed program information can be directly used without the overhead of analyzing the program information again. If there is no identifiable class file for the class, a cache is checked to see if there is an entry in the cache corresponding to the class. If there is no entry in the cache corresponding to the class, the program information is analyzed and saved in a cache entry for future use. If there is an entry in the cache corresponding to the class, the analyzed program information is retrieved and used, thereby saving the time required to repeatedly analyze the program information.

Apparatus and method for caching analyzed program information

An object oriented mechanism and method allow allocating Java objects on a method's invocation stack in a partial compilation environment under certain conditions. Only the classes that are visible are taken into account when performing escape analysis in accordance with the preferred embodiments. In a first aspect of the invention, conservative assumptions are made to assure that objects are only allocated on an invocation stack when this can be proven safe by examining only those classes in the compilation unit. In a second aspect of the invention, the concept of visible classes is extended to include other classes that may be found from a user-defined classpath that matches the anticipated run-time classpath used to find classes during program execution. When stack allocation decisions for a method depends on such classes that are outside the compilation unit, two versions of run time code for that method are created. One version allocates all objects from the heap, whereas the other allocates some or all objects on the invocation stack. For each class outside the compilation unit that was examined when making stack allocation decisions for a method, information about the requisite class is stored with the method. At run time, the class loader verifies that the run time version of each requisite class matches all stored information about that class. If all information matches for all requisite classes, the version of the method using stack allocation is safe to use at run time. Otherwise, the method using heap allocation must be used.

Object oriented apparatus and method for allocating objects on an invocation stack in a partial compilation environment

A computer system, a computer product and a method in which static storage within an environment comprising a plurality of compilation modules is managed such that compiled cloned copies of called externally resolved (with respect to a compilation unit) items are preferentially executed in favor of the corresponding externally resolved item based on a favorable comparison of version information of version information prior to execution. In one embodiment, JAVA&reg; programming language methods are processed within the context a modified framework.

Achieving tight binding for dynamically loaded software modules via intermodule copying

A computer system, program product, and method utilize alternate program code associated with an executable file using a file attribute so that the alternate program code may be retrieved and executed in lieu of the primary program code stored in the file. As one example, for a platform-independent executable file such as a Java class file, a file attribute of the file may be analyzed to determine if native program code for a particular platform is associated with the file. If so, the native program code may be retrieved and executed directly without the additional overhead associated with interpreting the platform-independent program code in the file. If, on the other hand, the native program code is not detected, the native program code may be generated and associated with the file using a file attribute such that the native program code is detected in subsequent attempts to retrieve and execute the file.

Computer system, program product and method utilizing executable file with alternate program code attached as a file attribute

Counting the number of set bits in an n-bit data word in a data processing system. The process involves generating at least p intermediate n-bit words, where 1<p <n, by masking and shifting the data word such that each intermediate word has n/p p -bit fields and n of the fields of the intermediate words represent the values of respective bits of the data word. The intermediate words are then summed to generate an n-bit derivative word having n/p p -bit fields whereby each field of the derivative word represents the sum of a respective group of bits of the data word. The fields of the derivative word can then be summed in various ways by performing shift, add and mask operations on the derivative word. The resulting sum value represents the number of set bits in the data word.

Counting set bits in data words

A method and computer program product are provided for implementing redundant lock avoidance in a virtual call sequence in a computer-system. A first copy of each target method with synchronization enabled and a second copy of each the target method without synchronization enabled are provided. For each virtual call to an object in the virtual call sequence, reaching definition analysis for an object pointer to the object is performed. For each reaching definition of the pointer, it is determined whether each reaching definition represents a pointer to an object known to be locked. Responsive to identifying the pointer to the object not known to be locked, the first copy of the synchronized method with synchronization enabled is selected. Responsive to identifying the pointer to the object known to be locked, the second copy of the synchronized method without synchronization enabled is selected.

Method and computer program product for implementing redundant lock avoidance

A computer implemented method and computer program compiler product are provided for implementing method calls in a computer system. Virtual method calls are identified in an intermediate instruction stream representation. Responsive to an identified virtual method call, profile data for the identified call site are read. A most frequently called procedure for the identified call site is compared with a first threshold value. Responsive to the most frequently called procedure being called less than the first threshold value, the virtual method call is maintained in a revised instruction stream representation. Responsive to the most frequently called procedure being called greater than or equal to the first threshold value, a guarded call to the most frequently called procedure is inserted at the identified call site in the revised instruction stream representation. In accordance with features of the invention, checking whether one object type accounts for more than a second threshold value of the calls to the most frequently called procedure at the identified call site is performed. Responsive to one object type accounting for more than or equal to the second threshold value, a type guard and a call to the most frequently called procedure are inserted at the identified call site in the revised instruction stream representation. Responsive to one object type accounting for less than the second threshold value, an address guard and a call to the most frequently called procedure are inserted at the identified call site in the revised instruction stream representation.

Method and computer program product for implementing method calls in a computer system

Apparatus and a method are provided for defining visibility boundaries in compiled code of an optimizing compiler used with a digital computer for converting a source program to an object code. The source program is received and a first intermediate representation of the source program is generated. A pseudo operation representing a predetermined event is inserted in the first intermediate representation. Sequential operations of the first intermediate representation including the inserted pseudo operations are processed for defining an internal data structure of the source program. A visibility boundary for a selected variable is identified responsive to identifying a pseudo operation in the first intermediate representation.

Optimizing apparatus and method for defining visibility boundaries in

A computer system, program product, and method of managing weak references with a concurrent mark sweep collector inhibit access, while processing weak references, to only those weak references whose referenced objects have not yet been determined to be strongly-reachable (i.e., reachable other than through a weak reference) during a current collection cycle. As such, access to specific weak references during processing thereof by a concurrent mark sweep collector is selectively inhibited to ensure synchronization for all weak references without necessarily stopping the execution of all program threads that attempt to access such weak references while executing in a computer system, thereby minimizing the processing overhead of managing weak references and improving system performance.

Computer system, program product and method of managing weak references

The solution employed by the present invention keeps information about individual exception instances in data structures which are independent of the local storage of the system-level exception management routines. This eliminates confusion and ambiguity because the entire exception handling mechanism can be described and specified in terms of the manipulation of these data structures, independent of the call/return flow of the system-level exception management routines.

Message based exception handler

A condition handling method and means capable of handling programs written in a plurality computer programming languages is created by a set of routines which implement the Common Condition Handling (CCH) function. These routines have entry points which are declared as external or entry variables which enables application programs to link to them. The compilers and application programs can then interact with the condition handling process by calling or branching to the entry points in the common condition handling code when the program is executing. Language specific condition handling routines and user condition handlers are invoked using a last-in-first-out (LIFO) queue to associate the handlers with the current stack frame. Any handler may respond to the CCH with one of three types of requests: Resume, Percolate, and Promote. A separate means is provided for registering Exit Handlers and to move the resume cursor.

Condition handling in a multi-language computer program

A method of encoding data records comprised of null or variable length fields of data bytes such that the sortabilty of the resulting string of data is permitted via simple byte comparisons. The first field is examined to determine if it is a null field. A null field is a field containing no data. It should sort out before a field containing any data, even all zeros. If a null field is detected, it is represented in the encoded string of data by a null field indicator. If the field is not a null field, the bytes in the field are examined. Zero value bytes are encoded based on the number of consecutive zero value bytes while non-zero bytes remain unchanged. An end of field indicator designates the end of each field in the resulting string of encoded data.

Growing community of inventors

Byron, MN, United States of America

Daniel Rodman Hicks