Oracle International Corporation

Oracle America, Inc.

Sun Microsystems, Inc.

Other

Google Inc.

Naturalbridge, Inc.

David R Chase

Guy Lewis Steele, Jr

Victor M Luchangco

Nils Gura

Guy L Steele

Karl B Naden

Justin R Hilburn

Yosef Lev

Richard Lewis Hudson

Seth T Proctor

Jan-Willem Maessen

David A Jurgens

Eric E Allen

Eric Allen

Austin Thomas Kona Clements

Mark Patrick Mitchell

Samuel C Kendall

Russell Stensby Cox

F Kenneth Zadeck

A lookup circuit evaluates hash functions that map keys to addresses in lookup tables. The circuit may include multiple hash function sub-circuits, each of which applies a respective hash function to an input key value, producing a hash value. Each hash function sub-circuit may multiply bit vectors representing key values by a sparse bit matrix and may add a constant bit vector to the results. The hash function sub-circuits may be constructed using odd-parity circuits that accept as inputs subsets of the bits of the bit vectors representing the key values. The sparse bit matrices may be chosen or generated so that there are at least twice as many 0-bits per row as 1-bits or there is an upper bound on the number of 1-bits per row. Using sparse bit matrices in the hash function sub-circuits may allow the lookup circuit to perform lookup operations with very low latency.

Systems and methods for implementing low-latency lookup circuits using sparse hash functions

A lookup circuit evaluates hash functions that map keys to addresses in lookup tables. The circuit includes multiple hash function sub-circuits, each of which applies a respective hash function to an input key, producing a hash value. Candidate pairs of hash functions to be implemented by the hash function sub-circuits may be generated and tested for suitability in hashing a particular collection of keys. The suitability testing may include computing hash value bit vectors by applying each hash function in a candidate pair to a given key, and determining (using a modified union-find type operation that organizes objects in each set as a directed graph whose root points to itself) whether the resulting hash value bit vectors belong to the same set. The union-find type operation may include a limited distance-from-root test, path compression, or exception handling for special cases, but not a rank test.

Systems and methods for generating bit matrices for hash functions using fast filtering

A present disclosure provides a garbage collector capable of freeing memory reachable only by a terminated thread immediately upon thread exit without scanning the heap or blocking other threads. A heap, including a plurality of spans, is walked, for example when the heap reaches a predetermined size. Reachable objects are marked in a mark bitmap. A mutator sweeps the mark bitmap without clearing mark bits, and newly allocated objects are not marked. When the thread terminates, sweep pointers in each of the spans owned by the terminated thread are reset. Moreover, a write barrier that makes a first unpublished object reachable from a second published object, also publishes the first object and all objects reachable from the first object.

Performant memory manager for cloud applications

Hardware circuitry may evaluate minimal perfect hash functions mapping keys to addresses in lookup tables. The circuitry may include primary hash function sub-circuits that apply linear hash functions to input key values (using carry-free arithmetic) to produce primary hash values. Each sub-circuit may multiply bit vectors representing key values by a bit matrix and add a constant bit vector to the result. The circuitry may include a secondary hash function sub-circuit that generates secondary hash values by aggregating values associated with multiple primary hash values using signed, unsigned, or modular integer addition, or bit-wise XOR operations. Secondary hash values may be usable to access data values in the lookup table that are associated with particular input key values. The circuitry may determine the validity of input keys and may alter the configuration or contents of the lookup tables. The hash function sub-circuits may include programmable hash tables.

Systems and methods for implementing dynamically configurable perfect hash tables

A lookup circuit evaluates hash functions that map keys to addresses in lookup tables. The circuit may include multiple hash function sub-circuits, each of which applies a respective hash function to an input key value, producing a hash value. Each hash function sub-circuit (which may include a programmable hash table) may multiply bit vectors representing key values by a bit matrix and add a constant bit vector to the results. Each hash value may be used to access a location in a lookup table in memory to obtain its contents (e.g., a key and associated data). The circuit may include a selection sub-circuit that selects the data of one of the identified locations as an output of the lookup circuit (e.g., one whose key matches the input key). The circuit may modify obtained data prior to its selection and may output a signal indicating the validity of input keys.

Systems and methods for implementing low-latency lookup circuits using multiple hash functions

A lookup circuit evaluates hash functions that map keys to addresses in lookup tables. The circuit includes multiple hash function sub-circuits, each of which applies a respective hash function to an input key, producing a hash value. Candidate pairs of hash functions to be implemented by the hash function sub-circuits (or hash function bit matrices thereof) may be generated and tested for suitability in hashing a particular collection of keys. Each hash function bit matrix may be generated according to heuristics chosen to improve the likelihood that it will be suitable for use in a pair, and may be tested against previously generated hash function bit matrices contained in one or more pools (each of which may contain matrices generated using different heuristics) to identify suitable pairs. The hash function bit matrices may be represented in the pools in a tabulated form, which may reduce the suitability testing time.

Systems and methods for rapidly generating suitable pairs of hash functions

The disclosed embodiments provide a system that facilitates the development and execution of a software program. During runtime of the software program, the system obtains a function call associated with an overloaded function and a generic type hierarchy. Next, the system determines an applicability of an implementation of the overloaded function to the function call. Finally, the system selects the implementation for invocation by the function call based on the determined applicability and a partial order of implementations for the overloaded function.

Dispatch predicate for overloaded functions using type intervals

The disclosed embodiments provide a system that facilitates the development and execution of a software program. During runtime of the software program, the system delays type inference on a generic type parameter of an implementation of an overloaded function, wherein the generic type parameter is associated with a type interval containing an unbounded lower limit and one or more self-typed constraints. Upon detecting a type query for a dynamic type of the generic type parameter, the system compares a queried type from the type query with a set of inference choices for the generic type parameter. If the queried type matches an inference choice from the set of inference choices, the system uses the inference choice to perform type inference on the generic type parameter.

Deferred type inference of generic type parameters in function calls to overloaded functions

The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system obtains a type interval for a generic type parameter of an implementation of an overloaded function. Next, the system selects an inference direction for the generic type parameter based on a variance of the generic type parameter, wherein the inference direction is an upward inference direction or a downward inference direction. Finally, the system uses the type interval and the inference direction to perform type inference on the generic type parameter.

Type inference of generic type parameters in overloaded functions using type intervals and inference directions

The disclosed embodiments provide a system that facilitates the development and execution of a software program. During runtime of the software program, the system obtains a function call associated with an overloaded function and a generic type hierarchy that lacks contravariance. Next, the system determines an applicability of an implementation of the overloaded function to the function call. Finally, the system selects the implementation for invocation by the function call based on the determined applicability and a partial order of implementations for the overloaded function.

Fast dispatch predicate for overloaded functions with generic type hierarchies that lack contravariance

One embodiment of the present invention provides a system that uses versioned pointers to facilitate reusing memory without having to reclaim the objects solely through garbage collection. The system operates by first receiving a request to allocate an object. Next, the system obtains the object from a pool of free objects, and sets an allocated/free flag in the object to indicate that the object is allocated. The system also increments a version number in the object, and also encodes the version number into a pointer for the object. The system then returns the pointer, which includes the encoded version number. In this way, subsequent accesses to the object through the pointer can compare the version number encoded in the pointer with the version number in the object to determine whether the object has been reused since the pointer was generated.

Using versioned pointers to facilitate reusing memory with a reduced need to reclaim objects through garbage collection

A system provides a task scheduler to define a priority queue with at least one window and a queue-window key. Each window is an ordered collection of tasks in a task pool of the priority queue and is identified by the queue-window key. The task scheduler sets a task-window key equal to a user-window key when the user-window key is greater than the minimum queue-window key. The task scheduler can further set the task-window key equal to the minimum queue-window key when the user-window key is less than the minimum queue-window key. A maximum task limit per user for each window and a priority increment for the user-window key are further applied to ensure fair scheduling.

Methods and apparatus for window-based fair priority scheduling

One embodiment of the present invention provides a system that uses versioned pointers to facilitate reusing memory without having to reclaim the objects solely through garbage collection. The system operates by first receiving a request to allocate an object. Next, the system obtains the object from a pool of free objects, and sets an allocated/free flag within the object to indicate that the object is allocated. The system also increments a version number within the object, and also encodes the version number into a pointer for the object. The system then returns the pointer, which includes the encoded version number. In this way, subsequent accesses to the object through the pointer can compare the version number encoded in the pointer with the version number within the object to determine whether the object has been reused since the pointer was generated.

In general, in one aspect, the invention relates to a method for integrating dimensional analysis in a program comprising defining a specific dimension class within the program, wherein the specific dimension class is an instance of the dimension meta-class, defining an instantiation of a unit class within the program, wherein the instantiation of the unit class comprises the specific dimension class as a type parameter associated with the instantiation of the unit class, defining a method within the program using the instantiation of the unit class and the specific dimension class, and compiling the program to generate an executable code corresponding to the program, wherein the program is written in an object-oriented language.

Growing community of inventors

Belmont, MA, United States of America

David R Chase