Sun Microsystems, Inc.

Oracle America, Inc.

Frank N Yellin

James A Gosling

Ioi Kim Lam

Arthur A Van Hoff

Richard D Tuck

William N Joy

Oleg A Pliss

Charles E McManis

Yin Zin Mark Lam

Dean R Long

One embodiment of the present invention provides a system that facilitates managing compiled program methods in a unified heap. The system partitions the unified heap into a first area and a second area. This allows the system to store objects other than compiled program methods and temporary compiler data structures in the first area, and to store compiled program methods and temporary compiler data structures in the second area.

Method and apparatus for managing compiled methods in a unified heap

A Java virtual machine includes a just in time (JIT) Java compiler. The JIT compiler includes at least one optimizer. Each of the at least one optimizer includes logic for recognizing a pattern in a received Java byte code, logic for optimizing the recognized pattern to produce optimized native code and logic for outputting optimized native code. A method of producing optimized native code is also provided.

Optimizing branch condition expressions in a JIT compiler

A method of managing a memory heap includes allocating a first portion of the memory heap to a young section. The first portion having a faster access time than at least one of a second portion and a third portion of the memory heap. The second portion being allocated to a tenured section and the third portion including an unused section. The method also includes filling the young section with objects from an application and deleting any objects in the young section that are no longer referenced. Any referenced objects are shifted. A memory system is also described herein.

System and method to increase memory allocation efficiency

A method for reducing a size of an image of a class file is provided. In this method, a first stack map that is associated with a first bytecode of a method and a second stack map that is associated with a second bytecode of the method are provided. Next, an operation of the second bytecode is applied to determine an effect on the first stack map. The effected first stack map defines a resulting stack map. The resulting stack map is then compared with the second stack map. If the resulting stack map matches the second stack map, the second stack map is removed from the class file. The removal of the second stack map operates to reduce the size of the image of the class file.

Methods and systems for reducing a program size

A program interpreter for computer programs written in a bytecode language, which uses a restricted set of data type specific bytecodes. The interpreter, prior to executing any bytecode program, executes a bytecode program verifier procedure that verifies the integrity of a specified program by identifying any bytecode instruction that would process data of the wrong type for such a bytecode and any bytecode instruction sequences in the specified program that would cause underflow or overflow of the operand stack. If the program verifier finds any instructions that violate predefined stack usage and data type usage restrictions, execution of the program by the interpreter is prevented. After pre-processing of the program by the verifier, if no program faults were found, the interpreter executes the program without performing operand stack overflow and underflow checks and without performing data type checks on operands stored in operand stack. As a result, program execution speed is greatly improved.

Bytecode program interpreter apparatus and method with pre-verification of data type restrictions and object initialization

An authoring system prepares a specified set of classes for preloading in client devices lacking a virtual memory manager. The authoring system converts the specified set of classes into a plurality of resource modules, a subset of the resource modules each including items that have pointers to items in other ones of the resource modules. The authoring system generates a load module, for loading into the client devices, that includes the plurality of resource modules, an interpreter and a startup procedure. The interpreter is for executing, on the client devices, programs in a predefined computer language. The specified set of classes includes methods in the predefined computer language. The startup procedure is for execution by the client devices when loading the interpreter for execution. The startup procedure replaces pointers in the resource modules with updated pointers in accordance with actual memory locations of the resource modules in any particular one of the client devices. The resource modules include a class table resource module, a method table resource module, a field table resource module, a constant pool resource module and a string resource module. The class data structure includes pointers to items in the method table, field table and constant pool resource modules, the field table resource module includes pointers to items in the string resource module, and the constant pool resource module includes pointers to items in the field table resource module and items in the string resource module.

System and method for preloading classes in a data processing device that does not have a virtual memory manager

Bytecode program interpreter apparatus and method with pre-verification of a data type restrictions and object initialization

A distributed computer system has a program compiling computer and a program executing computer. The program compiling computer is operated by a compiling party and includes a compiler that, when the digital signature of the originating party of an architecture neutral program has been verified, (A) compiles the architecture neutral program code of the architecture neutral program into architecture specific program code in the architecture specific language identified by the compile to information in the architecture neutral program, and (B) appends to the architecture specific program code a digital signature of the compiling party to generate an architecture specific program. The program executing computer is operated by an executing party and includes an architecture specific program executer that executes the architecture specific program code of the architecture specific program when the digital signature of the originating party of the architecture neutral program has been verified, the digital signature of the compiling party of the architecture specific program has been verified, and the compiling party has been determined to be a member of a defined set of trusted compiling parties.

System and method for generating trusted, architecture specific,

The disclosed system represents an improvement over conventional systems for initializing static arrays by reducing the amount of code executed by the virtual machine to statically initialize an array. To realize this reduction, when consolidating class files, the preloader identifies all &lt;clinit&gt; methods and play executes these methods to determine the static initialization performed by them. The preloader then creates an expression indicating the static initialization performed by the &lt;clinit&gt; method and stores this expression in the .mclass file, replacing the &lt;clinit&gt; method. As such, the code of the &lt;clinit&gt; method, containing many instructions, is replaced by a single expression instructing the virtual machine to perform static initialization, thus saving a significant amount of memory. The virtual machine is modified to recognize this expression and perform the appropriate static initialization of an array.

Method and system for performing static initialization

Bytecode program interpreter apparatus and method with pre-verification

A method of cross-compiling computer programs includes the step of extracting constants from an inheriting computer program written in a first computer language. The extracted constants refer to a generating computer program written in a second computer language. A new program in the second computer language is then created using the constants. The new program is then compiled for a target computer to ascertain compiled constant values. The compiled constant values are then substituted into the inheriting computer program to produce a final inheriting computer program.

Apparatus and method for cross-compiling source code

A secure program interpreter performs a special check the first time it executes a method call to determine if the sole purpose of the called method is to access the value of private variable, modify the value of a private variable, or return a constant value. If this is the case, the interpreter's internal representation of the method being executed is modified so as to directly access the private variable of the called method, or to directly access the stored constant of the called method. The modified method representation uses special 'privileged' load and store instructions, not available in normal source code programs, that access private variables and constants outside the method being executed without causing a security violation to be flagged. When the modified portion of the method is executed, the private variable or constant is accessed directly by the executed method using a privileged load or store instruction, the use of which avoids the flagging of a security violation by the program interpreter. When execution of the program is completed, the modified internal representation of the method is flushed, such that when the program is executed again the interpreter generates a new working representation of the aforementioned method.

System and method for runtime optimization of private variable function

A program compiler identifies each symbol in a source program that references another program. For each identified symbol, the compiler determines whether the symbol is a reference to a remotely located file or to a locally stored file. If the identified symbol is a reference to a remotely located file, it constructs a file location identifier, such as a URL, for the identified symbol, performs a file location identifier based fetch of the remotely locate file, and ads at least a portion of the fetched file to a set of program code to be compiled if the fetch is successfully performed. If the identified symbol is a reference to a locally stored file, it performs a file fetch for the locally stored file, adding at least a portion of the fetched file to the set of program code to be compiled if the file fetch is successfully performed. If the fetch is unsuccessful, compilation of the source program is aborted. When a client computer attempts to initiate execution of a specified program, the program executed determines a source update date associated with a source program associated with the specified program and also determines if a compiled version of the source program is present on the client computer. If a compiled version of the source program is present, the program executer determines a last compile date for the compiled version and compares the last compile date with the last source update date. If a compiled version of the source program does not exist on the client computer or if the source update date is later than the last compile date, the source program is automatically compiled to generate a new compiled version.

Compiler system and method for resolving symbolic references to

A compiler requires normal exceptions that are throwable by a method to be either explicitly declared or else 'caught' by appropriate exception handlers in the method to be compiled. This ensures that all normal exceptions thrown will be handled by a programmer specified exception handler. The compiler inspects all instructions in a specified method that throw exceptions and all instructions that invoke other methods, and determines whether each type of exception throwable by those instructions and invocable methods is (A) a serious exception (i.e., not a normal exception), (B) is caught by an enclosing exception handler, or (C) is explicitly declared in the method header of the specified method. If any throwable exception cannot be so categorized, that means the throwable exception is a normal exception that is not caught by an enclosing exception and is not explicitly declared in the method header, which means that the method to be compiled is not well formed. As a result, the compiler rejects the specified method, aborting compilation and generating an appropriate error message. The compiler determines the set of throwable exceptions in part by inspecting the methods that are invocable by the specified method for declarations of throwable exceptions. When initiating execution of the specified method, the program execution system inspects the method's declaration of throwable exceptions and blocks execution of the specified method unless exception handlers have been established for handling all the exceptions, if any, included in the declaration.

Growing community of inventors

Redwood City, CA, United States of America

Frank N Yellin