Abstract: A method and apparatus for pre-processing and packaging class files. Embodiments remove duplicate information elements from a set of class files to reduce the size of individual class files and to prevent redundant resolution of the information elements. Memory allocation requirements are determined in advance for the set of classes as a whole to reduce the complexity of memory allocation when the set of classes are loaded. The class files are stored in a single package for efficient storage, transfer and processing as a unit. In an embodiment, a pre-processor examines each class file in a set of class files to locate duplicate information in the form of redundant constants contained in a constant pool. The duplicate constant is placed in a separate shared table, and all occurrences of the constant are removed from the respective constant pools of the individual class files.

Abstract: A method and apparatus for pre-processing and packaging class files. Embodiments remove duplicate information elements from a set of class files to reduce the size of individual class files and to prevent redundant resolution of the information elements. Memory allocation requirements are determined in advance for the set of classes as a whole to reduce the complexity of memory allocation when the set of classes are loaded. The class files are stored in a single package for efficient storage, transfer and processing as a unit. In an embodiment, a pre-processor examines each class file in a set of class files to locate duplicate information in the form of redundant constants contained in a constant pool. The duplicate constant is placed in a separate shared table, and all occurrences of the constant are removed from the respective constant pools of the individual class files.

Abstract: A task executing at a server receives a request to package program code for remote execution on a client, and determines the software components that already reside at the client. The task uses this information to formulate a set of instructions to another task that creates the package. The created package is transmitted to the client, and program execution begins.

Abstract: A linkage editor executing at a server receives instructions for packaging software components that are required for program execution at a client. The linkage editor generates an output file by iteratively analyzing the program for references to other software components and extracting those components from their parent classes. The linkage editor sends the completed output file to an interface task, which transmits it to the client.

Abstract: Methods and apparatus for enabling the association between a monitor and an object to be maintained when a garbage collection occurs during a wait action performed with respect to the object are disclosed. According to one aspect of the present invention, a method for acquiring access to an object in a multi-threaded, object-based system includes associating a monitor with the object, and setting a pointer from a thread, which is arranged to execute on the object, to the object. The method also includes setting a reference substantially directly from the thread to the monitor. In one embodiment, setting the reference includes setting a boolean reference count. In another embodiment, setting the reference enables a garbage collector to determine whether the monitor is suitable for reclamation during a garbage collection process.

Abstract: Methods, apparatus and computer program products are disclosed for a method of invoking a native method in a Java virtual machine (“JVM” ). A special-purpose fast interface, executing in conjunction with an interpreter loop, for native methods reduces C stack recursion in the JVM. The interface performs as an extension to the interpreter loop component in the JVM in that a native method, invoked via the special-purpose interface, is able to modify the interpreter loop state if necessary. This is done without adding new bytecode instructions. A method of executing a native method in a Java virtual machine is described. The JVM first determines whether a native method is to be handled by a special native interface or one of multiple other native interfaces. If it is determined that the method is to be handled by the special native interface, the method is invoked and passed arguments enabling it to access the state of the JVM. The method is then executed.

Abstract: The present invention provides a mechanism for enabling memory allocation operations to be deterministic. According to the invention, determinism is achieved by first pre-allocating a contiguous memory space, and then using that memory space to perform subsequent memory allocation operations. Because the subsequent memory allocation operations are performed using memory space that has already been allocated, it is ensured that the allocation operations will not trigger a garbage collection operation. Also, because the pre-allocated memory space is contiguous, there will be no fragmentation concerns. Thus, the present invention eliminates the two major causes of non-constant allocation times. By doing so, the present invention makes it possible to achieve determinism in a dynamic memory allocation system.

Abstract: Methods and apparatus for enabling inconsistent or unsafe threads to efficiently reach a consistent or safe state when a requesting thread requests a consistent state are disclosed. According to one aspect of the present invention, a method for requesting a consistent state in a multi-threaded computing environment using a first thread includes acquiring a consistent state lock using the first thread, and identifying substantially all threads in the environment that are inconsistent. The state of the inconsistent threads is altered to a consistent state, and the first thread is notified when the states of the previously inconsistent threads have been altered to be consistent. Once the first thread is notified, the first thread releases the consistent state lock. In one embodiment, the method also includes performing a garbage collection after releasing the consistent state lock using the first thread.

Abstract: A linkage editor executing at a server receives instructions for packaging software components that are required for program execution at a client. The linkage editor generates an output file by iteratively analyzing the program for references to other software components and extracting those components from their parent classes. The linkage editor sends the completed output file to an interface task, which transmits it to the client.

Abstract: A linkage editor executing at a server receives instructions for packaging software components that are required for program execution at a client. The linkage editor generates an output file by iteratively analyzing the program for references to other software components and extracting those components from their parent classes. The linkage editor sends the completed output file to an interface task, which transmits it to the client.

Abstract: Methods, systems, and software for efficiently creating virtual file systems including object files which contain data are described. In one aspect of the invention, a method for creating a virtual file system includes retrieving a data file from a file system. A snapshot of the data file is created and converted into an object data file. The converted object data file is linked to at least one other object file. The data file can be concatenated with at least one other data file to create the snapshot. A set of assembly instructions for creating an object file from the snapshot is generated. The assembly instructions include instructions to reserve space within the object file for data contained in the data file. The assembly instructions are converted into an object file and the snapshot of the data file is copied into the reserved space.

Abstract: A method and apparatus for pre-processing and packaging class files. Embodiments remove duplicate information elements from a set of class files to reduce the size of individual class files and to prevent redundant resolution of the information elements. Memory allocation requirements are determined in advance for the set of classes as a whole to reduce the complexity of memory allocation when the set of classes are loaded. The class files are stored in a single package for efficient storage, transfer and processing as a unit. In an embodiment, a pre-processor examines each class file in a set of class files to locate duplicate information in the form of redundant constants contained in a constant pool. The duplicate constant is placed in a separate shared table, and all occurrences of the constant are removed from the respective constant pools of the individual class files.

Abstract: A method, apparatus, and software for efficiently allocating discontiguous stack space without requiring compiler changes are described. In one aspect, a method is provided for executing a compiled function that is located in a first computer memory stack chunk such that additional memory is allocated efficiently if a determination is made that such additional memory is necessary for execution of the compiled function. In one embodiment, the method includes calling a stack checking function that includes the compiled function. A determination is made if additional memory is required for executing the compiled function. If no additional memory is required, then the compiled function is called and executed. However, if additional memory is necessary, then additional memory is allocated that is discontiguous with the original memory stack.