Sun Microsystems, Inc.

Urs H&ouml;lzle

Lars Bak

Robert Griesemer

Srdjan Mitrovic

Steffen Grarup

David Griswold

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 dynamically deoptimizing a frame in a control stack during 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. According to one aspect of the present invention, a computer-implemented method for deoptimizing a compiled method includes creating a data structure. The data structure, which is separate from the control stack, is arranged to store information relating to the compiled method. A reference indicator, such as a pointer, is created to associate the data structure with the frame. The method, which is compiled to a first state of optimization, is then deoptimized to a second state of optimization, and the method in the first state of optimization may be discarded, thereby deoptimizing the frame. When control returns to the deoptimized frame, a migration routine creates at least one new stack frame, and execution may continue using the method in the second state of optimization.

Method and apparatus for dynamically deoptimizing compiled activations

Methods and apparatus for efficiently enabling an alternate return address associated with a function call to essentially be stored such that the alternate return address may be readily accessed are disclosed. According to one aspect of the present invention, a method for enabling a return address associated with a function called by a routine to be efficiently stored includes calling the function from within the routine while the routine is executing. In general, the function is external to the routine. The function, once called, begins executing. Eventually, the function returns to the routine. Specifically, the function returns to a location in the routine that is identified by an expected return point, or normal return address. The instruction in the routine that corresponds to the expected return point is a dummy instruction that executes with a low computational overhead but does not affect program execution. When the called function is to return to an alternate return point, it obtains the address by reading data embedded in the dummy instruction.

Method apparatus for implementing multiple return sites

Methods and apparatus for the efficient allocation of shared memory in a multi-threaded computer system are disclosed. In accordance with one embodiment of the present invention, a computer-implemented method for allocating memory shared by multiple threads in a multi-threaded computing system includes partitioning the shared memory into a plurality of blocks, and grouping the multiple threads into at least a first group and a second group. A selected block is allocated to a selected thread which may attempt to allocate an object in the selected block. The allocation of the selected block to the selected thread is based at least partially upon whether the selected thread is a part of the first group or the second group. In one embodiment, grouping the multiple threads into the first group and the second group includes identifying a particular thread and determining whether the particular thread is a fast allocating thread. In such an embodiment, when the particular thread is fast allocating, the particular thread is grouped into the first group.

Method and apparatus for memory allocation in a multi-threaded virtual machine

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

Systems and methods for implementing site specific message dispatch in an object-oriented environment are provided. Receiver type information may be saved at a message dispatch site in order to provide site specific message dispatch. By allowing message dispatch to vary at different call sites, object-oriented systems may be more efficient and flexible.

Site specific message dispatch in object-oriented systems

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

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

Methods and apparatus for dynamically determining whether portions of code should be interpreted or compiled in order to optimize a software application during run-time are disclosed. According to one aspect of the present invention, computer-implemented method for run-time processing of a computer program which includes byte-codes arranged as a plurality of methods includes invoking a first method selected from the plurality of methods. Invoking the first selected method involves interpreting the first selected method. An invocation tracker which is arranged to track the number of invocations of the first selected method is updated, and a determination is made regarding when the invocation tracker indicates that the number of invocations of the first selected method exceeds a threshold value. The first selected method is compiled when it is determined that the invocation tracker indicates that the number of invocations of the first selected method exceeds a threshold value. This threshold value is periodically adjusted to keep the compilation and the interpretation overheads within acceptable ranges.

Growing community of inventors

Goleta, CA, United States of America

Urs Hölzle

Growing community of inventors

Goleta, CA, United States of America

Urs H&ouml;lzle

Urs Hölzle