International Business Machines Corporation

Graham Alan Chapman

Daniel J Heidinga

Oluwatobi Ajila

Trent Gray-Donald

Karl Michael Taylor

Michael H Dawson

Peter Wiebe Burka

Hui Qing Shi

San Hong Li

Sharon Wang

Frank Eliot Levine

Vijay Sundaresan

Scott Thomas Jones

Andrew Russell Low

Graeme Johnson

Andrew James Craik

Charles Robert Gracie

Milena Milenkovic

John Duimovich

Francis J D Bogsanyi

Gavin Rolleston

Hang Shao

Maciek Klimkowski

Peter Douglas Bain

Mike Stephen Fulton

Peter Duncan Shipton

Ajith Ramanath

Patrick James Mueller

Nicholas James Coughlin

Aruna Kalagnanam

Kishor V Patil

Siwei Lu

Avinash Koradhanyamath

Bjoern Vaardal

Ryan Andrew Sciampancone

James I Gartley

James Ian Andrew Gartley

Dan Heidinga

Anderson Klegues Fraga

Hybrid virtual thread context switching in virtual machines is provided. For virtual threads scheduled to run on a VM, it is determined whether a virtual thread requires a stack. If a stack is required, it is determined whether low memory has space to allocate a stack. If there is space, a stack in low memory is allocated. If not, unused stacks are copied from low to high memory. If the virtual thread does not require a stack, it is determined whether the virtual thread stack is in low memory. If it is not, it is copied from high memory if there is enough space in low memory. If there is not enough space, unused stacks are copied from low memory to high memory. If the stack is in low memory, the method performs a stack switch and schedules the virtual on a carrier thread of the VM.

Hybrid virtual thread context switching mechanism

A computer-implemented method for bytecode class verification includes: encountering a class requiring verification of its bytecode during a run of an application; determining whether class relationship data for the class exists in a shared classes cache; in response to a determination that the class relationship data for the class does not exist in the shared classes cache: performing a linear bytecode walk of the bytecode to identify relationship data for the class and verify that the bytecode is well-formed; and storing the identified relationship data as the class relationship data for the class in the shared classes cache; in response to a determination that the class relationship data for the class does exist in the shared classes cache: retrieving the class relationship data for the class from the shared classes cache; and processing the class relationship data.

Bytecode verification using class relationship caching

An embodiment includes executing a code interpretation engine such that the interpretation engine interprets a first portion of a source code that includes a first comparison between a first pair of operands. The embodiment also includes performing, in memory, a first bitwise comparison between a block Aand a block Bof the first portion of the source code. The embodiment also speeds up execution of the first portion of the source code responsive to the first bitwise comparison producing a negative result. The embodiment speeds up the first portion by omitting at least one of (i) a second bitwise comparison between a block Aand a block B, and (ii) a field-wise comparison between a block Aand a block B

Performance optimization of class instance comparisons

During verification of a bytecode, when a second class remains to be loaded for verification in an MRE, a verifier in the MRE is prevented from loading the second class, where the bytecode includes a relationship between a first class and the second class. The relationship is recorded and the verifier is caused to omit a loading operation on the second class. An execution is started of an application encoded in the bytecode. The second class is caused to be loaded and verified prior to a use of the second class during the execution.

Deferred bytecode class verification in managed runtime environments

A method of maintaining correctness of pointers from a managed heap to off-heap memory includes storing in a cache a first heap object in a managed heap that holds at least one off-heap pointer pointing to a first off-heap data structure and creating a weak reference node linked to the first heap object such that the first heap object is not kept alive by the weak reference node during garbage collection. Further disclosed are systems for maintaining correctness of pointers from a managed heap to off-heap memory.

Maintaining correctness of pointers from a managed heap to off-heap memory

A computer-implemented method includes: selecting, by a computer device, a set of fields in a program which are marked as final fields to be treated as constants; adding, by the computer device, detection logic to the program, the detection logic including a process that detects writes to the final fields to be treated as constants; compiling, by the computer device, the program into compiled code; executing, by the computer device, the compiled code; detecting, by the computer device, a write to a first one of the final fields to be treated as constants; and transitioning, by the computer device, execution of the compiled code from the compiled code to an interpreter for processing by compensation code that operates on the first one of the final fields to be treated as constants.

Compile-time folding of assumed constant values

Aspects of the present invention provide devices that count for an application thread levels of critical sections of program code, and in response to a program exception in the application thread that is deferrable and a non-zero count of the levels of critical sections, execute a remainder of program code within the critical sections of program code.

Programming language runtime deferred exception handling

In an approach for removing tenant initialization check per tenant for compiled code, a processor receives a request to create a tenant. A processor creates the tenant. A processor marks a current thread of the tenant as not eligible to run just-in-time (JIT) code, wherein the marking indicates that when a method is invoked, a non-JIT version of the method is executed. A processor executes initialization of a first class from an optimization list, wherein the optimization list is a configurable list of classes to be initialized prior to running JIT code. A processor determines that class initialization has been executed for all classes on the optimization list. A processor adjusts the marking to indicate that the current thread is eligible to run JIT code and that the tenant may run JIT code that assumes, without checking, that classes on the optimization list are initialized.

Per tenant initialization check removal

Embodiments of the present invention disclose a method, system, and computer program product for a JNI object access system. A computer receives a JNI reference and obtains the pointer data and call site of the referenced object. The computer determines whether a record of the object and call site exist and, if not, the respective records are created. The computer applies a heuristic analysis of the object and call site in which it determines whether the object is larger than a threshold size, whether the object is part of a particular region of the heap, whether the call site is associated with a read-only or a read-write function, and whether the object or call site has caused more non-moving garbage collections than a threshold number. Based on the heuristic, the computer either copies the object data or pins the object and any non-moving garbage collections are recorded.

JNI object access

A method for obtaining accurate call path information in a mixed-mode environment where interpreted methods and non-interpreted methods can call one another is disclosed. In one embodiment, such a method includes generating an event and recording it in a buffer when an interpreted method calls an interpreted method. The method also generates an event and records it in the buffer when an interpreted method calls a non-interpreted method. The method further generates an event and records it in the buffer when a non-interpreted method calls an interpreted method. The method refrains from generating an event when a non-interpreted method calls a non-interpreted method. A corresponding apparatus and computer program product are also disclosed.

Efficient interpreter profiling to obtain accurate call-path information

Growing community of inventors

Ottawa, Canada

Graham Alan Chapman