International Business Machines Corporation

Oluwatobi Ajila

Daniel J Heidinga

Graham Alan Chapman

Michael H Dawson

Hui Qing Shi

San Hong Li

Sharon Wang

Angela Lin

Kenneth Blair Kent

Hang Shao

Eric Aubanel

Bing Yang

Siwei Lu

Andrew James Craik

Babneet Singh

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

Multiple level stack caching is provided. A user level thread of a multithreaded application is unmounted from a carrier thread of an operating system. An analysis of a level 1 cache corresponding to the carrier thread in memory is performed to determine whether the level 1 cache is full. An analysis of a level 2 cache in memory is performed to determine whether the level 2 cache is full in response to determining that the level 1 cache corresponding to the carrier thread in memory is full. A user level thread stack corresponding to the user level thread is stored in the level 2 cache in memory in response to determining that the level 2 cache in memory is not full.

Multiple level caching of user level thread stacks for user level threads

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

A snapshot handler is registered with an event monitoring subsystem of a process virtual machine, the registering specifying a trigger event of the snapshot handler, wherein the trigger event comprises execution of a specified portion of an application executing in the process virtual machine, the trigger event specified externally from a source code of the application. Responsive to the event monitoring subsystem detecting an occurrence of the trigger event, the snapshot handler is executed, storing data of an execution state of the process virtual machine at a time of occurrence of the trigger event.

Performing an application snapshot using process virtual machine resources

Resolving segmented constant pools in a virtual machine managed runtime. An embodiment includes allocating, using one or more processors of a computing device, for each specialization created in a class of specializations, a constant pool (CP) cache, assigning an owner to each segment of constant pools, maintaining, in a memory of the computing device, a list of specializations in the class, and copying, upon determining that a CP segment entry visible to the specialization is resolved in the owner, the entry to a specializations cache of the memory. An embodiment includes assigning a new specialized CP segment as an owner of that CP segment and adding a new entry associated with the new specialization to a template class owners table, retrieving, based on looking for entry at runtime, a slot pointed to in the owners table and resolving the CP entry in the constant pool cache of the owner.

Resolution of segmented constant pools

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

Aspects provide multi-tier data synchronization based on a concurrent linked monitor list. A computer processor associates each of different data regions of a packed data object with different mutual exclusion monitor nodes of a linked list, the data regions defined by a data offset location within memory data and a length of the data region from the offset. In response to determining that a first data region of the packed data object is on-heap memory, the processor associates the first data region with a container representative of the linked list sorted in ascending order of the respective offset values, and a hash code of the container; and in response to determining that a second data region of the packed data object is off-heap memory, stores container information for the second data region in the linked list and resorts the linked-list nodes of container information in ascending order of offset values.

Multi-tier data synchronizer based on concurrent linked list

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.

Growing community of inventors

Ottawa, Canada

Oluwatobi Ajila