Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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® programming language methods are processed within the context a modified framework.

Abstract: 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.

Abstract: An apparatus and method provide a cache for analyzed program information when no class file can be identified. If a class file can be identified, the analyzed program information is attached to the class file. If no class file can be identified, the analyzed program information is stored in a cache separate from any class file. When loading a class, the apparatus and method of the invention check to see if there is an identifiable class file for the class. If so, the class file is checked to see if there is analyzed program information attached to the class file. 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.

Abstract: 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.

Abstract: Counting the number of set bits in an n-bit data word in a data processing system. The process involves generating at least p1 intermediate n-bit words, where 1<p1<n, by masking and shifting the data word such that each intermediate word has n/p1p1-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/p1p1-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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.