Sun Microsystems, Inc.

Google Inc.

Lars Bak

Urs H&ouml;lzle

Robert Griesemer

Srdjan Mitrovic

Kasper Verdich Lund

Urs Holzle

Urs Hölzle

Timothy G Lindholm

Steffen Grarup

Kasper V Lund

Benedict A Gomes

Sheng Liang

David P Stoutamire

Hong Zhang

Mads Sig Ager

Jacob R Andersen

A capability for limited customization that utilizes existing virtual dispatch table technology and allows selective customization is provided. Such a capability combines the usage of virtual dispatch tables with both customized and non-customized code to reduce, or even eliminate over-customization. Further, such a capability may employ a runtime system that decides what methods to customize based on several factors including, but not limited to the size of a class hierarchy, the amount of available space for compiled code, and the amount of available time for compilation.

Optimizing object oriented programs using limited customization

One embodiment of the present invention provides a system that supports efficient access to object properties in a dynamic object-oriented programming language. During operation, the system receives a request to access a property for an object associated with a given map object. The system then determines a hash value using the given map object and a signature for the property, and uses the hash value to retrieve a code stub from a cache. Next, the system executes this code stub, which includes instructions that facilitate accessing the property, to access a memory field associated with the property.

Supporting efficient access to object properties in a dynamic object-oriented programming language

One embodiment of the present invention provides a system that uses map objects to access object properties for a program written in a dynamic object-oriented programming language, thereby facilitating property access for languages that allow additional properties to be defined for objects at runtime. During operation, the system receives an object of an object type. This object is associated with a memory region and a given map object (from a set of map objects associated with the given object type) that describes how properties of the object are mapped to fields in the memory region. When receiving a request to access a property of the object, the system determines whether the given map object includes a field mapping for the property. If so, the system accesses a field in the memory region associated with the property using the field mapping.

Using map objects to access object properties in a dynamic object-oriented programming language

One embodiment of the present invention provides a system that reduces memory usage by encoding two values in a single field. During operation, the system receives a string. After determining the length of the string, the system allocates a first set of bits in the single field to store the length of the string, where the size of this first set of bits depends upon the determined length of the string. The system then stores the length of the string in the first set of bits. Subsequently, the system computes a hash code for the string. The system then allocates a second set of bits from the remaining unallocated bits in the single field to store this hash code, and stores the hash code in this second set of bits. Thereafter, the system can access the string length value from the single field and can also use the entire single field as a hash value for the string.

Method and apparatus for reducing memory usage by encoding two values in a single field

Systems and methods for implementing an execution stack which stores frames for functions written in multiple programming languages are provided. The frames for functions written in different programming languages may be interleaved on the same execution stack. A data block on the execution stack may be utilized to traverse the execution stack around a frame by storing a stack pointer and frame pointer to a previous frame. Additionally, exceptions may be propagated, with conversion if necessary, through frames on the execution stack that are written in different programming languages.

Mixed execution stack and exception handling

One embodiment of the present invention provides a system for type tagging values in a compiled activation frame in a lazy manner to facilitate garbage collection. This system operates in a mixed-mode environment that supports both interpretation of byte codes and execution of compiled native code. Upon receiving an invocation of a method, the system creates an activation frame for the method on the execution stack. If the method is executing in interpreted mode, the interpreter maintains a tag for each value in the activation frame during execution. The tag indicates whether the value is a reference type or a primitive type. However, if the method is executing in compiled mode, the system allocates space for tags for each value in the activation frame, but does not fill in the tags during execution. This allows the tags to be filled in at a future time when needed.

Method and apparatus for facilitating lazy type tagging for compiled activations

Systems and methods for implementing message dispatch for an object-oriented program are provided. Receiver type information is collected at a site of a method that dispatches messages to receiver objects. The receiver type information is saved for subsequent execution of the program. By saving the receiver type information, the program may be more efficient as it is not necessary to collect the receiver type information again. Additionally, inlining information may be saved with the receiver type information.

Inline database for receiver types in object-oriented systems

A system that associates an identifier with an instance defined within an object-oriented programming system. The system generates an identifier for the instance and associates a new near object with the instance, wherein the new near object points to a class specifying behavior for the object. The system stores the identifier in the new near object, and sets a class pointer located within a header of the instance to point to the new near object. In this way, the class pointer indirectly points to the class for the object through the new near object. The system can lock the instance to facilitate exclusive access to the instance by copying a near object associated with the instance to a method activation on the execution stack, and setting the class pointer of the instance to point to the copy of the near object on the execution stack.

Method and apparatus for facilitating compact object headers

One embodiment of the present invention provides a system that dynamically compiles byte codes into native code to facilitate faster execution. This method operates in a mixed-mode system that supports execution of both compiled code and interpreter code. During operation, the system periodically determines if a currently executing thread is executing through the interpreter. If so, the system locates the method being executed by the thread and compiles the byte codes of the method into native code. Subsequent executions of the method utilize the faster-executing native code.

Method and apparatus for dynamically compiling byte codes into native code

Systems and methods for increasing the execution speed of virtual machine instructions for a function are provided. A portion of the virtual machine instructions of the function are compiled into native machine instructions so that the function includes both virtual and native machine instructions. Execution of the native machine instructions may be accomplished by overwriting a virtual machine instruction of the function with a virtual machine instruction that specifies execution of the native machine instructions. Additionally, the original virtual machine instruction may be stored so that the original virtual machine instructions can be regenerated.

Interpreting functions utilizing a hybrid of virtual and native machine instructions

Methods and apparatus for dynamically compiling byte codes associated with methods during idle periods in the execution of a computer program are disclosed. The described methods are particularly suitable for use in computer systems that are arranged to execute both interpreted and compiled byte codes. In some embodiments, methods to be dynamically compiled are referenced in one or more lists. The lists may be prioritized to facilitate the compilation of the highest priority methods first. In one embodiment, a pair of compilation lists are provided with a first one of the compilation lists being created prior to processing the computer program while the other is created during the processing of the computer program.

Method and apparatus for performing byte-code optimization during pauses

One embodiment of the present invention provides a system that gathers code usage information to facilitate removing compiled code that has not been recently used. This method operates in a mixed-mode system that supports execution of both compiled code and interpreter code. During operation, the system gathers usage information for compiled methods within an application while the application is executing. Next, the system identifies compiled methods to be removed based on this usage information, and removes identified compiled methods so that interpreter code is executed for the compiled methods instead of compiled code. In this way, the system frees up the memory space used to store the compiled methods.

Non-intrusive gathering of code usage information to facilitate removing unused compiled code

Methods and apparatus for performing fast subtype checks during program execution are disclosed. According to one aspect of the present invention, a method for determining whether a class associated with an object that is a part of an object-based computing system is a subtype of another type includes obtaining a candidate type from a dynamic storage location that is associated with a class which is associated with the object, and comparing the candidate type against a first type that is potentially the same as the candidate type. A determination is then made as to whether the candidate type is substantially equal to the first type. When the determination is that the candidate type is substantially equal to the first type, an indication that the candidate type is a subtype of the first type is provided. In one embodiment, the candidate type obtained from the dynamic storage location is obtained from a cache element in the class associated with the object.

Method and apparatus for implementing fast subclass and subtype checks

Techniques for performing static binding of dispatched-calls in the presence of dynamic linking and loading are provided. A method for increasing the execution performance of a function at run-time includes compiling the function, which may either be interpreted or previously compiled, and identifying a call within the function to a process. The method also includes adding dependency information to the function. The dependency information is arranged to indicate a status of the function, and contains information pertaining to the class, the name, and the signature associated with the process. In one embodiment, the process is a virtual process, and the method includes analyzing a class structure associated with the function in order to determine when the virtual process is a substantially unique target of the call. In such an embodiment, the virtual process may be inlined into the function when it is determined that the virtual process is the substantially unique target of the call.

Static binding of dynamically-dispatched calls in the presence of dynamic linking and loading

Methods and apparatus for converting a lightweight monitor to a heavyweight monitor are disclosed. According to one aspect of the present invention, a computer-implemented method for converting a lightweight monitor to a heavyweight monitor when an object that is owned by a second thread is unavailable to a first thread includes creating a new heavyweight monitor and setting the ownership of the new heavyweight monitor to the second thread. The first thread then enters the newly created heavyweight monitor without being forced to spin lock until the object is released by the second object.

Growing community of inventors

Palo Alto, CA, United States of America

Lars Bak