International Business Machines Corporation

Nikola Grcevski

Mark Graham Stoodley

Vijay Sundaresan

Kevin Alexander Stoodley

Peter Wiebe Burka

Derek Bruce Inglis

David Kevin Siegwart

Ryan Andrew Sciampacone

Mike Stephen Fulton

Daryl James Maier

Marius Pirvu

Timothy P Ellison

Zhong Liang Wang

Charles Brian Hall

Automatic memory management with a generational copy collector garbage collection algorithm running on parallel threads to perform simultaneous and independent copying and scanning. An object is scanned. It is determined whether an object referenced within the slot of the object being scanned may be copied to the same generation as the scanned object. A mark may be made to indicate that the referenced object may be copied to a different generation than the scanned object. The mark defers the copying of the referenced object.

Defer separating children in parallel copying garbage collection

Methods and systems for generating a hashcode for a hash table are provided to improve the hash table performance. A particular method includes receiving an input of a key; applying a hash function to the key to generate an incoming hashcode of the key; encoding a key type into the incoming hashcode to generate a first hashcode; and storing the first hashcode. A particular method includes encoding the key type into at least one bit of a bucket index portion of the incoming hashcode.

Methods and systems for improving hash table performance

Systems, methods, and computer products for just-in-time compilation for virtual machine environments for fast applications start-up and maximal run-time performance. Exemplary embodiments include a just in time compilation method for a virtual machine environment coupled to a memory, including identifying a program structure for compilation, creating a low optimization compiled version of the program structure that is relocatable in the memory, storing into a persistent cache the low optimization compiled version of the program structure that is relocatable and relocating the low optimization compiled version of the program structure into a virtual machine address space in the memory, wherein relocating the low optimization compiled version of the program structure includes transforming the low optimization compiled version to a compiled version with fixed addresses in the memory that can be executed.

Systems, methods, and computer products for just-in-time compilation for virtual machine environments for fast application startup and maximal run-time performance

A computer implemented method, apparatus, and computer program product for copy-on-write optimization of immutable objects. An immutable object is marked as read-only to form a read-only object. The read-only object is formed to delay copying of the immutable object until a runtime determination is made that a write to the immutable object will be made. In response to an attempt to write to the read-only object, an internal value of the read-only object is copied to read-and-write storage using runtime information to form a writable copy of the read-only object. A set of references for the read-only object is updated to point to the writable copy of the read-only object. Delaying copying of the immutable object optimizes a copy-on-write of the immutable object.

Copy-on-write optimization of immutable objects for objects oriented languages

An improved system and computer programming product for acquisition and release of locks within a software program is disclosed. In an exemplary embodiment, a lock within a loop is transformed by relocating acquisition and release instructions from within the loop to positions outside the loop. This may significantly decrease unnecessarily lock acquisition and release during execution of the software program. In order to avoid contention problems which may arise from acquiring and keeping a lock on an object over a relatively long period of time, a contention test may be inserted into the loop. Such a contention test may temporarily release the lock if another thread in the software program requires access to the locked object.

Transforming locks in software loops

A method for lock reservation using cooperative multithreading is provided. The method includes analyzing code containing async points to support cooperative multithreading. The method also includes identifying a class of code as a candidate for reservation via determining locking properties within the code as a function of locations of async points within the code, and generating reserving code that reserves the shared object when code performing the reservation is considered hot code. The method further includes performing runtime monitoring of reservation performance to detect a contention level for the shared object, and removing the reservation when the runtime monitoring determines that a low level of contention exists. A method for lightweight single reader reserved locks is also provided, including identifying a candidate for reservation containing a read-only locking sequence, conditionally marling the sequence, and generating code using an artificial dependency to control execution order of out-of-line code.

Lock reservation using cooperative multithreading and lightweight single reader reserved locks

A way to use multiple-reader locks for those paths where no writes occur is provided. Only if one of the writing paths executes will a full writer lock be acquired. Two copies of the critical section comprising a reading version and a writing version are created. The default execution leads to the reader version, which only acquires a reader-lock. The reader version of the code executes prior to execution of the writer lock only version, otherwise bypassing the writer lock only version. If the execution leads to a path in which a write would occur, the reader only version branches to the beginning of the writer version. The writer version is identical to the original code and obtains a full writer lock. If execution in the reader lock does not lead to a path that writes, then only the reader lock is acquired.

Code optimization when using multiple reader locks and a non-reader lock

A computer-implementable method, system and computer-usable medium. One or more objects among a plurality of objects can be processed utilizing a data-processing apparatus/system. One or more lock reservations can be applied among a group of lock reservations over a multiple sequential lock operations with respect the particular object. Thereafter, the lock reservation can be cancelled with respect to the last monitor exit operation in order to eliminate lock operations where traditional lock coarsening cannot be applied.

Speculative computation lock coarsening through the use of localized lock reservation

Under the present invention, a locking primitive associated with a shared data object is automatically transformed to allow multiple read-only locks if certain conditions are met. To this extent, when a read-only lock on a shared data object is desired, a thread identifier of an object header lock word (hereinafter 'lock word') associated with the shared data object is examined to determine if a read-write lock on the shared data object already exists. If not, then the thread identifier is set to a predetermined value indicative of read-only locks, and a thread count in the lock word is incremented. If another thread attempts a read-only lock, the thread identifier will be examined for the predetermined value. If it is present, the thread count will be incremented again, and a second read-only lock will be simultaneously established.

Computer-implemented method, system and program product for establishing multiple read-only locks on a shared data object

A method, system and computer program product for collecting profiling information during runtime of a multithreaded program. According to the method, a plurality of instructions of the program for execution in an application thread are first received; a plurality of variable size profiling records are then stored in a buffer assigned exclusively to the application thread during execution of the plurality of instructions; and the plurality of profiling records in the buffer are then processed. The program may be written in Java bytecode for execution in a Java virtual machine with the processing of profiling buffers performed by a component of a JIT compiler for insertion into a repository in internal JIT format, e.g. a hash table, for later optimization processing.

Per thread buffering for storing profiling data

Techniques for causing a compiler to organize code pertaining to data that is not constant, but that is unlikely to change except in relatively infrequent situations, in an improved manner. A class containing data that may have more than one value, but which will have a particular value in the typical case, is now split into two parts, a first class which uses the more-likely data value as a constant, and a second class (designed as a subclass of the first class) that uses the data value as a variable capable of having either the more-likely value or other, less-likely values. The compiler generates assembly code comprising instructions pertaining to the more-likely data value, and also generates assembly code capable of processing the less-likely data values. This latter code, however, is initially unreachable. The compiler-generated assembly code will be programmatically patched, at run time, if any of the less-likely data values occur, thereby dynamically making the code reachable. Once the initially-unreachable code becomes reachable, it will be used thereafter (regardless of the setting of the data value).

Transforming code to expose glacial constants to a compiler

An improved method and system for acquisition and release of locks within a software program is disclosed. In an exemplary embodiment, a lock within a loop is transformed by relocating acquisition and release instructions from within the loop to positions outside the loop. This may significantly decrease unnecessarily lock acquisition and release during execution of the software program. In order to avoid contention problems which may arise from acquiring and keeping a lock on an object over a relatively long period of time, a contention test may be inserted into the loop. Such a contention test may temporarily release the lock if another thread in the software program requires access to the locked object.

Growing community of inventors

Toronto, Canada

Nikola Grcevski