Oracle International Corporation

Chris Hegarty

Alexander R Buckley

Alan Bateman

Mark B Reinhold

Paul Sandoz

Daniel Jean-Michel Fuchs

Maurizio Cimadamore

Stuart Warren Marks

Pavel Rappo

Julia Katharina Boes

Brian Goetz

Michael Conor McMahon

Sean James Coffey

Techniques for configuring test operations on a per-module basis are disclosed. A system receives a command for configuring, on a per-module basis, test operations recited in a set of module code corresponding to a particular module of a plurality of modules in a module system. The module system specifies accessibility of each module in the plurality of modules to other modules in the plurality of modules. The system stores configuration information based on the command and configures a test operation included in an element of the particular module based on the stored configuration information. Configuring the test operation includes one of: (a) enabling the test operation without affecting other code recited in-line with the test operation in the element of the particular module; or (b) disabling the test operation without affecting other code recited in-line with the test operation in the element of the particular module.

Configuring test operations on a per-module basis

Techniques for deserializing stream objects are disclosed. The system may receive data representing a stream object. The data can include an object descriptor, a class descriptor, and stream field values corresponding to the stream object. The system may select a particular deserialization process, from among a plurality of deserialization processes. The selection may be based at least in part on the object descriptor and the class descriptor. The system can deserialize the data representing the stream object using the selected deserialization process, yielding one or more deserialized objects.

Deserialization of stream objects using multiple deserialization algorithms

Techniques for serializing objects stored in system memory are disclosed. The system may receive data representing an object stored in system memory. The system may select a particular serialization process, from among a plurality of serialization processes, for serializing the received data. The particular serialization process may be selected based at least in part on the received data. The system may serialize the data representing the object in system memory using the selected serialization process. Serializing the data may yield one or more stream objects.

Serialization of objects using multiple serialization algorithms

Techniques for inferring code deprecation from module deprecation are disclosed. A system detects a reference to a type. The system determines that a particular module, in a plurality of modules in a module system, exposes the referenced type. The system determines that the particular module is associated with a deprecation status. Responsive to determining that the particular module is associated with the deprecation status, the system presents information indicating that the reference references a deprecated module.

Inferring code deprecation from module deprecation

A data-instantiator method handle is configured to instantiate a target class based on a structured data object. One type of data-instantiator method handles is a Structured Data Object Processor method handle (SDOP_mh). The runtime environment invokes a SDOP_mh to create a target object based on a name-index map and an index-value map. The SDOP_mh is adapted, directly or indirectly, from a direct method handle that references a constructor of the target class. In an embodiment, the constructor referenced by the direct method handle is a canonical constructor. In an embodiment, the SDOP_mh is a runtime-computed constant in a runtime constant pool.

Object creation from structured data using indirect constructor invocation

A data-instantiator method handle is configured to create a target object based on a stream object. One type of data-instantiator method handles is a Stream Object Processor method handle (SOP_mh). A SOP_mh is a runtime-computed constant in a runtime constant pool. A runtime environment resolves the SOP_mh lazily responsive to a request to access the SOP_mh. The runtime environment invokes the SOP_mh to create a target object based on a stream object. By virtue of being a constant in the runtime constant pool, the SOP_mh is a candidate for optimization by a dynamic compiler in the runtime environment. The dynamic compiler may elect to constant fold the value of the SOP_mh and inline any code or executable logic that the SOP_mh refers to.

Deserialization of stream objects using constant-foldable method handles

Techniques are included for providing a parallel pseudo infinite timeline monotonic clock that may be used to determine time and durations. A system clock is used to obtain an original time instant that anchors the pseudo infinite timeline to be parallel to a timeline of the system clock. The monotonic clock obtains time ticks from a monotonic tick supplier. The monotonic time ticks are used to determine times and durations, rather than relying on time instants obtained from the system clock. The use of a sliding window anchored at various times allows the parallel timeline to be almost infinite in implementation, rather than wrapping once a maximum value is reached. In addition, the accuracy of computations of time and duration are impervious to changes to the system clock, due to the use of the monotonic time ticks instead of obtaining multiple time instants from the system clock.

Parallel pseudo infinite monotonic timeline clock

An explicit type for a construct is not necessarily specified by a set of code. Where an explicit type is not specified for a particular construct, a compiler performs type inference for the particular construct. If the compiler infers a denotable type is associated with the construct, the compiler proceeds to perform quality checking for the particular construct by evaluating quality conditions with respect to the inferred denotable type. However, if the compiler determines that a non-denotable type is associated with the construct, then the compiler selects a target type determination process based on an attribute of the inferred non-denotable type associated with the particular construct. The compiler determines one or more target types using the selected target type determination process. The compiler performs quality checking for the particular construct by evaluating quality conditions with respect to the target types.

Quality checking inferred types in a set of code

Systems and methods are provided based on tightly coupled RS flows to provide bi-directional asynchronous stream processing with non-blocking back pressure. Signal, data, and error processing may be performed and routing of signals, data, and error information between multiple RS flows may be performed according to detected conditions.

Bi-directional asynchronous I/O abstraction based upon pair of tightly coupled reactive streams flows

Techniques for identifying permitted illegal access operations in a module system are disclosed. An operation, expressed in a first module, that attempts to access a module element of a second module is identified. Based on a module declaration associated with the second module, the module element is determined inaccessible to the first module. Additionally or alternatively, based on an access modifier associated with the module element, the module element is determined inaccessible to the operation. The operation is determined as an illegal access operation. The illegal access operation is permitted to access the module element. A warning corresponding to the illegal access operation is generated.

Identifying permitted illegal access operations in a module system

Access to a module element within a first module by a second module is prohibited if the module element within the first module has not been exposed to the second module. If a particular module element within a first module has been exposed to a second module, then access to the particular module element by the second module may or may not be allowed depending on: (a) whether the particular module element has been declared with a public or non-public access modifier, (b) whether a second exposed module element, which includes the particular module element, has been declared with a public or non-public access modifier, (c) a level of access associated with the operation that attempts to access the particular module element of the first module, and/or (d) whether an accessibility override configuration is set for accessing the particular module element.

Restrictive access control for modular reflection

Permissive access control for modular reflection

A serial form of a serializable exposed first module element of a module in a module system is analyzed. An unexposed and/or inaccessible second module element expressed in the serial form is identified as a potential error condition. A corrective execution is executed and/or a warning is presented.

Modular serialization

A compiler, IDE or other code analyzer may determine whether an instance variable declaration assignment is redundant. The code analyzer may also take action based on that determination. A code analyzer may be able to determine with certainty that a particular instance variable initialization or assignment is definitely redundant. The code analyzer may cause a compiler to automatically elide the redundant assignment from compiled source code. The code analyzer may be able to determine with certainty that a particular assignment is definitely not redundant. Additionally, a code analyzer may not be able to determine with certainty whether an instance variable assignment is definitely redundant or definitely not redundant. Additionally, the code analyzer may report a warning or other informative message indicating the redundancy property of the assignment, thus alerting the programming to a (possibly) redundant assignment.

Growing community of inventors

Dublin, Ireland

Chris Hegarty