Abstract: Improved techniques for representation of objects in a Java™ programming environment are disclosed. The techniques are highly suitable for representation of Java™ objects inside virtual machines, especially those that operate with limited resources (e.g., embedded systems). A cluster of Java™ object representations is disclosed. Each of the Java™ object representations provide a reference to a Java™ object and a reference to the class associated with the Java™ object. Accordingly, a two-tier representation is provided which allows efficient implementation of applications which need to access information regarding both Java™ objects and classes. As a result, quick access to information regarding Java™ objects can be achieved.

Abstract: Improved techniques for loading class files into virtual computing machines are disclosed. These techniques provide a mechanism that will generally improve the efficiency of virtual machines by selectively loading information into a virtual machine. As will be appreciated, this allows a better use of the resources of the virtual machine. This is especially effective in virtual machines that operate with limited memory resources (e.g., embedded systems). In one embodiment, class files suitable for loading into a virtual machine are initially loaded into a memory portion (e.g., heap memory). Then, information that is needed to be loaded into the virtual machine is selected. Finally, only the selected information is loaded into the virtual machine.

Abstract: Techniques for handling exceptions raised during the execution of Java computer programs are disclosed. The techniques can be used by a Java virtual machine to efficiently handle exceptions. A method descriptor is implemented in a Java method frame which is stored in the Java execution stack. The method descriptor provides one or more references to exception handlers associated with the Java method. The references can be used to quickly identify and invoke the appropriate exception handler. This can be achieved without having to use a native language execution stack. As a result, the overhead associated with several returns from native functions (routines or methods) can be avoided since the information needed to invoke the appropriate exception handler can be obtained efficiently from the Java execution stack. Accordingly, the performance of Java virtual machines, especially those operating with limited resources, can be significantly enhanced.

Abstract: Improved frameworks for loading and execution of portable, platform independent programming instructions within a virtual machine are described. The improved frameworks provides a mechanism that will generally improve the runtime performance of virtual machines by eliminating the need to always traverse a constant pool at runtime to execute a Java™ instruction. In addition, specific data structures that are suitable for use within a virtual machine and methods for creating such data structures are described. Accordingly, an enhanced Java™ bytecode representation having a pair of Java™ bytecode streams is disclosed. The enhanced Java™ bytecode has a Java™ code stream suitable for storing various Java™ commands as bytecodes within a code stream. A Java™ data stream of the enhanced Java™ bytecode representation is used to store the data parameters associated with the Java™ commands in the code stream. Actual parameter values, or references to actual parameter values can be provided in the data stream.

Abstract: Improved techniques for representation of Java string objects are disclosed. The techniques can be implemented to create Java string objects as arrays of one-byte characters when it is appropriate. To create Java string objects, an enhanced constructor can be provided in a Java library that is available to application programs (or programmers). In addition, enhanced Java methods can also be provided in the Java library. An array representation flag can optionally be allocated in the Java string object representation. The array representation flag can indicate whether the Java string object is allocated as an array of one-byte or an array of two-byte characters. Alternatively, the element type of the array can be referenced by using one or more references to determine whether the Java string object has been allocated as an array of one-byte or as an array of two-byte characters.

Abstract: Techniques for generation of Java™ macro instructions suitable for use in Java™ computing environments are disclosed. As such, the techniques can be implemented in a Java™ virtual machine to efficiently execute Java™ instructions. As will be appreciated, a Java™ macro instruction can be substituted for two or more Java™ Bytecode instructions. This, in turn, reduces the number of Java™ instructions that are executed by the interpreter. As a result, the performance of virtual machines, especially those operating with limited resources, is improved. A Java™ macro instruction can be generated for conventional Java™ instruction sequences or sequences of Java™ instruction that are provided in a reduced set of instruction. In any case, sequences that are frequently encountered can be replaced by a Java™ macro instruction. These sequences are typically encountered when Java™ objects are instantiated, during programming loops, and when a local variables are assigned a value.

Abstract: Improved frameworks for loading and execution of portable, platform independent programming instructions within a virtual machine are disclosed. The improved frameworks provide a mechanism that will generally improve the runtime performance of virtual machines by eliminating the need to always traverse a constant pool at runtime to execute a Java instruction. In effect, the described system contemplates doing some extra work during the loading of a class into a virtual machine by obtaining the information from the constant pool during loading and representing that information in a form that can be used more efficiently at runtime. Accordingly, methods for creating data structures suitable for use by a virtual machine to execute load constant commands, as well as methods for execution of Java load constant instructions are disclosed.

Abstract: Techniques for customization of Java runtime environments are disclosed. The techniques can be used to provide Java runtime environments that are specifically tailored for various Java applications. Accordingly, for a particular Java application, an optimized runtime environment can be created. One or more optional attributes which represent the desired runtime customizations are generated. As will be appreciated, the optional attributes can be generated in the attribute table in the class file. The optional attributes can then be parsed and appropriate features can be loaded into the virtual machine. In this way, Java runtime environments can be customized based on a particular Java application requirement. Moreover, customizations can be automated using a runtime performance manager that interacts with various other components that operate to first generate and then load optional attributes into the Java runtime environment.

Abstract: Improved techniques for representation of Java data types in Java computing environments are disclosed. A word consisting of four bytes is used to represent primitive and non-primitive Java data types. As will be appreciated, the Java data type representations can be used by a Java virtual machine to efficiently represent various Java data types encountered in Java computing environments. As a result, various components that can represent Java data types (e.g., signatures of Java methods) can efficiently be constructed.

Abstract: The present invention pertains to techniques for creating and maintaining objects in object-oriented environments. The techniques are especially well suited for Java programming environments. In accordance with one aspect of the invention, specialized Java heaps are disclosed. In contrast to conventional heaps, the specialized Java heap is designated for storing Java objects with similar traits in the same memory portion. As such, objects with similar traits can be allocated and maintained in a designated memory portion. Another aspect of the invention provides methods for allocating objects in the heap memory. These methods can be used to create and associate objects with similar traits in a specialized heap. As will be appreciated, objects can be created and maintained more efficiently in this manner. As a result, the performance of virtual machines, especially those operating with relatively limited resources (e.g., embedded systems), is improved.

Abstract: Techniques for implementing virtual machine instructions suitable for execution in virtual machines are disclosed. The operations performed by conventional instructions can be performed by relatively fewer inventive virtual machine instructions. Furthermore, the virtual machine instructions can be used to perform operations that cannot readily be performed by conventional Java Bytecode instructions. Thus, a more elegant, yet robust, virtual machine instruction set can be implemented.

Abstract: A method for mapping of logical memory regions (usually referred to as pages) of application addressable contiguous memory space to non-contiguous pages of the physical memory is provided. Each thread in an application is allocated a substantially larger amount of virtual memory, than will typically be used by the thread. Initially only the page at the top of the stack is mapped to a physical page. Later, as the stack expands, more pages of virtual memory are mapped to physical pages, up to the limit of the allocated amount. At the end opposite to the top of the stack, the page is marked as inaccessible, to allow reporting of a stack overflow condition.

Abstract: Improved techniques for invocations of native methods in Java computing environments are disclosed. The techniques can be implemented in Java computing environments to facilitate efficient use of methods (functions or subroutines) written in programming languages other than Java (e.g., C, C++, etc.). As such, the techniques are highly suitable for use by virtual machines operating with relatively less memory and/or computing power (e.g., embedded systems). A lightweight native method invocation interface can be implemented to provide direct access to Java parameters on the execution stack. In addition, the lightweight native method invocation can include macro instructions that operate efficiently to convert the Java parameters into native parameters. Thus, the lightweight native method invocation can significantly reduce the overhead associated with conventional Java native method invocation techniques.

Abstract: Techniques for executing synchronized Java methods are disclosed. As such, the techniques can be implemented in a Java virtual machine to efficiently execute Java instructions. As will be appreciated, monitors (e.g., locks) associated with Java objects for which the synchronized method are being performed are accessed quickly. In other words, the monitors can be quickly released without having to repeat several time-consuming operations which have to be performed in conventional systems. This, in turn, reduces the number of operations that need to be performed to execute synchronized Java methods. As a result, the performance of virtual machines, especially those operating with limited resources, is improved.

Abstract: One embodiment of the present invention provides a system that facilitates debugging a platform-independent virtual machine. The system operates by providing an agent on the platform-independent virtual machine, which provides a set of functions for accessing variables in the platform-independent virtual machine. The platform-independent virtual machine is adapted to call the set of functions within the agent. Next, the agent examines the current state of the variables in the platform-independent virtual machine. The agent communicates the current state of the variables to a host machine. An operator of the host machine can then analyze the current state of the variables.

Abstract: Improved frameworks for implementing class files that are particularly useful in virtual machine based computing systems will be described. In one aspect of the invention, each method within a class file is associated with a corresponding “reference cell.” The reference cells typically include sufficient information to facilitate the invocation of the corresponding method. By way of example, each reference cell may include a class pointer field, a method name field, a signature field and potentially other fields. In another aspect of the invention, a process for loading class files into a virtual machine based computing system is described. Each method invocation within the class file is translated into an internal invocation that references a reference cell associated with the internal class representation that contains the method.

Abstract: Improved techniques for identifying and tracking references to Java objects are disclosed. The techniques can be used to implement garbage collection facilities for Java programs in a manner that is more efficient, especially for systems with limited resources (e.g., embedded systems). For each execution stack, a reference stack can be designated. The reference stack can be used to store references to Java objects in the same offset as they appear in the corresponding execution stack. References to Java objects can be identified based on the values stored in the reference stack. The reference stack can be traversed to identify the entries that correspond to active Java objects. These entries can then be checked against the corresponding entries in the execution stack to ensure with a greater degree of certainty that the identified entries represent references to active Java objects.

Abstract: Improved techniques for accessing Java class files are disclosed. The techniques provide a mechanism that will generally improve the efficiency of virtual machines by providing a directory for Java class files. The directory can be implemented as an attribute in the attribute portion of the Java class files. Various components of the Java class file can be accessed efficiently by using the directory. In addition, techniques for accessing various components of Java class files using directories are disclosed. The techniques utilize the directory to allow efficient access to the class file. Thus, unlike conventional techniques, there is no need to perform sequential reads in order to locate various components of the Java class file. This allows for better use of resources. As a result, the invention can improve the performance of virtual machines, especially those that operate with limited resources (e.g., embedded systems).

Abstract: Techniques for implementation of Java heaps are disclosed. The techniques can be implemented in a Java virtual machine operating in a Java computing environment. A Java heap potion comprising two or more designated portions is disclosed. Each of the designated heap portions can be designated to store only a particular Java logical component (e.g., Java objects, Java class representation, native components, etc.) A designated heap portion can be implemented as a memory pool. In other words, two or more designated heap portions can collectively represent a memory pool designated for a particular Java logical component. The memory pools allow for dynamic management of the designated heap portions. As a result, the performance of the virtual machines, especially those operating with relatively limited resources is improved.

Abstract: Alternative techniques for representation of Java string objects are needed. The techniques are especially useful for representing Java objects in Java computing environments and can thereby improve the performance of virtual machine, especially those with relatively limited resources (e.g., embedded systems with relatively smaller memory and computing power). The techniques can be implemented to create Java string objects as arrays of one-byte characters when it is appropriate. To create Java string objects an enhanced constructor can be provided in a Java library that is available to application programs (or programmers). In addition, enhanced Java methods can also be provided in the Java library.