International Business Machines Corporation

Derek Bruce Inglis

Vijay Sundaresan

Kevin Alexander Stoodley

Nikola Grcevski

Kiyokuni Kawachiya

Michiaki Tatsubori

Tamiya Onodera

Mark Graham Stoodley

Ali Ijaz Sheikh

Trent Gray-Donald

Marius Pirvu

Aruna A Kalagananam

Marcel Mitran

Peter Wiebe Burka

Michael S Karasick

Patrick R Doyle

Harold Leon Ossher

Mike Stephen Fulton

Vincent Joseph Kruskal

Patrick George Gallop

David Joseph Streeter

Dina Tal

Ian Hugh Carmichael

James I A Gartley

A method and system for code generation and inlining. The method includes: scanning a code, where the code includes a method; determining whether the method includes a branch if the method is too large in size to be inlined, where the branch is based on runtime types of argument; profiling runtime types of actual arguments at a call site in the method if the method includes the branch; generating a polymorphic inline cache (PIC) code from a plurality of arguments, where the plurality of arguments are based on a result of the profiling step; generating a specialized method for a frequently appearing combination of the runtime types of argument and arguments that can be invoked from the PIC code; and inlining body of the specialized method into the call site if the specialized method has a body size within a permissible range.

Method and system for code generation and inlining

A technique for comprehensively acquiring calling-context information at a low cost. Call site IDs are held for each thread as a call history and used as context information. At the time of calling a method, the call history existing in a current frame is shifted left, and stacked in a new frame, with the call site ID of the call site put in the lower bits. At the time of returning from the method, the value of the original call history is returned by returning the frame. At the time of performing a virtual call, call history information is recorded into a call position profile table used to identify a method to be inlined at the time of performing JIT compiling, in addition to determined jump destination information and the number of calls.

Profiler for executing computer program

A compiler and method of optimizing code by partial inlining of a subset of blocks of called blocks of code into calling blocks of code. A restart of the called blocks of code is provided for the case where non-inlined blocks of code are reached at run time. Blocks selected for partial inlining may include global side effects depending on the computer program environment. Global side effects in the selected blocks of code leading to a restart are sanitized in order to defer changes to the global state of the computer program.

Partial inlining with software based restart

Systems and methods of passing arguments between client and server contexts may provide for detecting an in-process call between a client and a server, wherein the client and the server share a common virtual machine instance. An object copy from a source object of the in-process call to a destination object can be conducted based on an internal class structure of the virtual machine instance. The object copy procedure may be repeated for a plurality of source objects of the in-process call.

Deep copying objects in a collocated environment

A mechanism is provided for operating a computing system, in which an inner virtual machine translates first instructions, which are supported by the inner virtual machine, into second instructions, which are supported by an outer virtual machine. The mechanism encodes, in the inner virtual machine, third instructions into the second instructions into which the first instructions are translated, the third instructions including hints for facilitating an execution of the second instructions, and, in an event the hints are supported by the outer virtual machine, initiating the execution of the second instructions while utilizing the hints by the outer virtual machine to achieve an increased efficiency of the execution of the second instructions.

Providing code improvements for nested virtual machines

A computer implemented method for performing inlining in a just-in-time compiler. Compilation of a first code of a program is begun. The first code is one of an interruptible code and a non-interruptible code. A try region is established around a second code of the program to form a wrapped second code. The try region is a boundary between interruptible and non-interruptible code such that a third code that modifies an observable state of the program cannot be moved across the boundary. The second code is, relative to the first code, the other of the interruptible code and the non-interruptible code. The wrapped second code is inlined with the first code during compilation. Compilation of the first code is completed to form a resultant code. The resultant code is stored.

Just-in-time compiler support for interruptible code

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

Under the present invention, program code is examined (statically or dynamically) for characteristics indicative of a potential to generate multiple threads. If none are found, single threaded optimization(s) such as desynchronization, optimization of globals, etc., can be implemented. In addition, if the program code is later revealed to have the potential to generate multiple threads, the single threaded optimization(s) can be corrected to avoid incorrect execution.

System and program product for implementing single threaded optimizations in a potentially multi-threaded environment

A computer implemented method, computer usable program code, and a data processing system for selecting a candidate implementation of a virtual overridden method for inlining into a calling method. A determination as to which implementation of a virtual overridden method to inline is made based on its relative 'hotness' compared to the other implementations of the same method. The relative hotness can be inferred from the invocation count and sampling count that the virtual machine and the just-in-time compiler already collect for other purposes, that is, without collecting and storing of call-edge profiling information. When a method is being compiled and it is identified that the method contains a call to an overridden method, a candidate for inlining from among the implementations of the overridden method is selected based on relative hotness values. The candidate implementation of the overridden method is then inlined, with a guard, into the calling method.

Speculative inlining of overridden methods without using profiling information

A mechanism is provided for optimizing computer program execution during class loading phase. As a code method of the program is received for compiling prior to execution, a check is performed whether program execution is in class loading phase. Program execution is in class loading phase where the class loading rate exceeds a pre-determined level during a pre-determined interval. If the program is in class loading phase, then compiling is reduced by lowering frequency of just-in-time (JIT) compilation, lowering optimization level of just-in-time compilation, or a combination of the two. The code method may also be passed to an interpreter to be interpreted.

Optimizing software program execution during class loading phase

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

A method for compiler optimization particularly well suited to object-oriented language that permit dynamic class loading. The method permits the compiler optimization of code associated with a potentially polymorphic object that is a call parameter to a virtual procedure where the procedure is a candidate for devirtualization through inlining. The method includes steps for guarded devirtualizing of the procedure, insertion of code to ensure privatization of the object before the procedure is executed, creation of a guard assumptions associated with the object and application of known optimization techniques to the code associated with the object.

Growing community of inventors

Markham, Canada

Derek Bruce Inglis