International Business Machines Corporation

Mark Graham Stoodley

Vijay Sundaresan

Kevin Alexander Stoodley

Nikola Grcevski

Martin Ohmacht

Raul Esteban Silvera

Kai-Ting Amy Wang

Daniel J Heidinga

Andrew James Craik

Derek Bruce Inglis

Marcel Mitran

Reid T Copeland

Michael S Fulton

Mike Stephen Fulton

Marius Pirvu

Joran S C Siu

Zhong Liang Wang

Patrick George Gallop

Ashutosh Mehra

Kishor V Patil

Ning Thomas Wong

Improving execution of application program instructions by receiving code having a security classification, determining that the code is untrusted according to the security classification and inserting instructions for a cache flush associated with executing the code.

Controlling processor instruction execution

An embodiment includes requesting, by a compiler responsive to execution of a first code segment, a first profile dataset associated with the first code segment. The embodiment also includes executing, responsive to receiving an indication that the first profile dataset is not available, a querying process that searches other code segments based on specified criteria relating to an attribute of the first code segment. The embodiment also includes receiving a search result from the querying process, where the search result includes a second code segment. The embodiment also includes generating an extrapolated profile dataset based at least in part on the second code segment. The embodiment stores the extrapolated profile dataset in memory associated with the first code segment, and the compiler performs an optimization process on the first code segment using the extrapolated profile dataset.

Deriving profile data for compiler optimization

A method list is built for a currently executing application within a process virtual machine at a snapshot point, the method list comprising a set of methods capable of being executed by the currently executing application after the snapshot point, the snapshot point comprising an execution state of the currently executing application when a snapshot process is triggered. Profiling data of the currently executing application, collected prior to reaching the snapshot point, is committed, to a designated storage location. Using the profiling data and a just-in-time compiler of the process virtual machine, a method in the method list is compiled. Snapshot data comprising data of the execution state of the currently executing application at the snapshot point, including a result of the compiling, is stored.

Compilation strategy for a sharable application snapshot

Updating a native class pointer in persisted compiled code for use in an execution environment other than the one in which the native class pointer was created. This is done by using an identifier, stored with the persisted compiled code, of the class first loaded by the class loader that also loaded the class to which the native class pointer refers. A table is maintained in the execution environment mapping class identifiers to class loaders, and the stored identifier is used to consult this table to find a candidate class loader from those in the current execution environment that can provide the correct updated pointer.

Correlating class loader objects across execution environments

A method for rolling back speculative threads in symmetric-multiprocessing (SMP) environments is disclosed. In one embodiment, such a method includes detecting an aborted thread at runtime and determining whether the aborted thread is an oldest aborted thread. In the event the aborted thread is the oldest aborted thread, the method sets a high-priority request for allocation to an absolute thread number associated with the oldest aborted thread. The method further detects that the high-priority request is set and, in response, modifies a local allocation token of the oldest aborted thread. The modification prompts the oldest aborted thread to retry a work unit associated with its absolute thread number. The oldest aborted thread subsequently initiates the retry of a successor thread by updating the successor thread's local allocation token. A corresponding apparatus and computer program product are also disclosed.

Efficient rollback and retry of conflicted speculative threads using distributed tokens

A method, apparatus, and/or computer program product performs selective speculative class-based optimization through the use of a type propagation analysis of class. Responsive to a determination that the type of class is not a fixed type, a determination is made as to whether the class is sub-classed. Responsive to a determination the class is not sub-classed, a virtual synthetic property method is created. The virtual synthetic property method is accommodated in an enhanced java virtual machine using a stack frame type. The stack frame type has associated metadata for throwing an exception and an invisibility property. The virtual synthetic property method, along with a virtual guard, is inlined, and a slow path is created. The slow path handles executions of the virtual synthetic property method when sub-classes of the class, which override an implementation of the virtual synthetic property method, are loaded in the future.

Selective speculative class-based optimization

Embodiments of the present invention address deficiencies of the art in respect to load time resolutions and provide a method, system and computer program product for load time resolution of AOT compiled class references in a dynamic binding executing environment. In one embodiment of the invention, a method of resolving class references in AOT compiled code can be provided. The method can include updating AOT code at loading time for already resolved class references in the AOT code, and executing the updated AOT code to resolve remaining unresolved class references in the updated AOT code.

Load time resolution for dynamic binding languages

Embodiments relate to a computer implemented process, system and program product for identification of a root method for a thread. In one aspect of the embodiment the process includes instrumenting code to form instrumented code and creating stack sample data. It also includes creating method stack sample data in a case that the stack sample data exceeds a stack sample data threshold. It also includes, determining whether a root method is identified, the determining based on using the method stack sample data; and reporting any root method identified for a respective thread.

Programmatic identification of root method

A code region forming part of a computer program is modified during execution of the computer program by a plurality of threads. In one aspect, identical modification instructions are provided to each thread for modifying a site in the code region having a desirable idempotent atomic modification, and the modification instructions direct each thread to make the desirable idempotent atomic modification. In another aspect, a thread is selected to modify the code region, each thread other than the selected thread is directed to execute an alternative execution path that generates output identical to the output of the code region after the code region has been modified, and, responsive to directing each thread other than the selected thread, the selected thread is directed to modify the code region.

Growing community of inventors

Markham, Canada

Mark Graham Stoodley