Oracle International Corporation

Amazon Technologies, Inc.

Oracle Intemnational Corporation

Maurizio Cimadamore

Brian Goetz

Daniel Smith

James Malcolm Laskey

Jorn Bender Vernee

Alexander R Buckley

Vladimir Vitalyevich Ivanov

John Robert Rose

Jonathan J Gibbons

Michael Haupt

Chris Hegarty

Joseph D Darcy

Paul D Sandoz

Vicente A Romero Zaldivar

Alessandro Raffio

Neil Michael Cowzer

Techniques for managing temporal dependencies between sets of foreign resources are disclosed, including: allocating, in a runtime environment, a segment of foreign memory to a first memory session, the runtime environment being configured to use a garbage collector to manage memory in a heap, and the foreign memory including off-heap memory that is not managed by the garbage collector; opening, in the runtime environment, a second memory session that descends from the first memory session; while the second memory session is open, encountering a request to close the first memory session; responsive to encountering the request to close the first memory session, determining that the first memory session has at least one open descendant memory session; responsive to determining that the first memory session has at least one open descendant memory session, declining the request to close the first memory session.

Managing temporal dependencies between sets of foreign resources

Techniques for transitioning between memory segment views include: instantiating a first memory segment view that confines access to a memory segment to a first thread; receiving a request to transition ownership of the memory segment to a second thread; responsive to receiving the request to transition ownership of the memory segment to the second thread: instantiating a second memory segment view that permits access to the memory segment by the second thread; copying metadata from the first memory segment view to the second memory segment view; terminating the first memory segment view, to prevent access to the memory segment via the first memory segment view.

Transitioning between thread-confined memory segment views and shared memory segment views

Techniques for representing a native function using an executable reference are disclosed. The system receives an instruction to create an executable reference for a native function, including a method type comprising a method signature corresponding to the executable reference, and a function description including (a) a memory layout corresponding to data returned by the function and (b) memory layouts corresponding to parameters required by the function. The system selects an application binary interface (ABI). The system generates code that, for each parameter, of the one or more parameters required by the function, converts the parameter from a value formatted for use by a Java Virtual machine to a value formatted for use in the native function, based on the selected ABI. Responsive to invocation of the executable reference, the generated code and the native function may be executed.

Modeling foreign functions using executable references

Techniques for managing lifecycles of sets of foreign resources are disclosed, including: opening, in a runtime environment configured to use a garbage collector to manage memory in a heap, a memory session; allocating a first subset of a set of foreign memory to a memory segment associated with the memory session, the foreign memory including off-heap memory that is not managed by the garbage collector; encountering, in the runtime environment, an instruction to close the memory session; responsive to encountering the instruction to close the memory session, deallocating the subset of the set of foreign memory.

Managing lifecycles of sets of foreign resources

Techniques for reducing overhead in native function calls are disclosed. The system may receive a method invocation instruction for invoking a particular method. The method invocation instruction includes a function descriptor, a method type, and an application binary interface (ABI) descriptor. The function descriptor includes a memory layout corresponding to any data returned by the function and memory layouts corresponding to each argument for the particular method. The system can select an ABI for processing the particular method based on the received ABI descriptor. The system can further associate each argument with a corresponding particular physical register into which the argument is to be loaded. The particular register is selected based on at least the selected ABI and the function descriptor. The system can cause a virtual machine to move each argument into the corresponding associated physical register.

Optimizing execution of foreign method handles on a virtual machine

A compiler is capable of compiling instructions that do or do not supply specialization information for a generic type. The generic type is compiled into an unspecialized type. If specialization information was supplied, the unspecialized type is adorned with information indicating type restrictions for application programming interface (API) points associated with the unspecialized type, which becomes a specialized type. A runtime environment is capable of executing calls to a same API point that do or do not indicate a specialized type, and is capable of executing calls to a same API point of objects of an unspecialized type or of objects of a specialized type. When the call to an API point indicates a specialized type, and the specialized type matches that of the object (if the API point belongs to an object), then a runtime environment may perform optimized accesses based on type restrictions derived from the specialized type.

Implementing optional specialization when compiling code

Implementing optional specialization when executing code

Techniques for reducing unsafe memory access, particularly when interacting with native libraries, are disclosed. The system may receive a memory address. The system may determine that the received memory address is not associated with an existing memory segment. The system selects a particular memory segment, of a plurality of memory segments. The memory segment may have a length of zero and a size corresponding to a size of a native heap. The system may return a reference to the particular memory segment.

Methods for reducing unsafe memory access when interacting with native libraries

Operations include a compilation process and a runtime process. A compiler compiles code to generate virtual machine instructions. The compiler further generates information referencing respective parameter types of the parameters of a target virtual machine instruction. The compiler stores the information external to and in association with the target virtual machine instruction. The information may be included in another virtual machine instruction that precedes the target virtual machine instruction. A runtime environment processes the target virtual machine instruction based on the information stored external to and in association with the target virtual machine instruction. Parameter types referenced by the external information override parameter types that are (a) referenced by the target virtual machine instruction itself, (b) deduced by the runtime environment and/or (c) stored directly in association with the parameter values.

Extending a virtual machine instruction set architecture

Techniques for transitioning between thread-confined memory segments and shared memory segments are disclosed. The system may instantiate a confined memory segment view. The confined memory segment view confines access to a memory segment to a particular thread. The system may further receive a request to change access permissions for the confined memory segment to allow access by a first set of one or more threads. Responsive to receiving the request to change access permissions for the confined memory segment, the system may instantiate a new memory segment view, wherein the new memory segment view permits access to the memory segment by the first set of one or more threads. The system may also copy metadata from the confined memory segment view to the new memory segment view. The system may de-allocate the memory segment in response to determining that there are no memory segment views associated with the memory segment.

Techniques for accessing off-heap memory are disclosed. The system may receive a memory segment layout definition for a memory segment in a physical memory of a machine. The memory segment layout definition defines a number of elements and a number of sub-elements in each element of the plurality of elements. The system may allocate the particular memory segment in the physical memory and may store a reference to a position of a sub-element. The system may receive a request to access a first sub-element of a particular element of the plurality of elements. Based on the request, the system may identify the memory segment corresponding to the plurality of elements, identify the particular element of the plurality of elements, identify the first sub-element of the plurality of elements based the position of the first sub-element, and execute an Input or Output (IO) operation corresponding to the request.

Techniques for accessing off-heap memory

Operations include (a) identifying bounds corresponding to two or more inference variables corresponding to a nested method invocation context, (b) determining that resolution of a first inference variable can be determined as a function of a resolution of a second inference variable, (c) propagating bounds corresponding to the second inference variable from the nested method invocation context to an outer method invocation context without propagating bounds corresponding to the first inference variable, (d) resolving a constraint set to resolve the second inference variable, and (e) resolving the first inference variable based on the resolution of the second inference variable.

Growing community of inventors

Dublin, Ireland

Maurizio Cimadamore