Method and apparatus for loading a Java application program

• US 6,272,674 B1
• Filed: 12/14/1998
• Issued: 08/07/2001
• Est. Priority Date: 12/14/1998
• Status: Expired due to Term

• Current Assignee: RPX Clearinghouse LLC (RPX Corporation)
• Original Assignee: Nortel Networks Limited (Nortel Networks Corporation)
• Inventors: Holiday, Jr., Matthew R.
• Primary Examiner(s): Powell, Mark
• Assistant Examiner(s): Chavis, John Q.
• Application Number:
  US09/211,209
• Time in Patent Office: 967 Days
• Field of Search: 717/1, 717/8
• US Class Current: 717/174
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• CPC Class Codes: G06F 9/45504 Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators

Abstract

An apparatus and method for loading software into a Java virtual machine (“JVM”) in a manner suited for real-time server applications. The software to be loaded is organized by Java package and class so that an application may be loaded in units of packages. Each package, and each class within a package, is loaded into the JVM in an order such that no package or class is loaded before the packages or classes upon which it depends. All software for an application is loaded into the JVM, and any compilation, optimization, or initialization takes place, prior to execution of the application program, so that no delays are incurred during such execution. Software loaded into the JVM, as well as attributes of that software, are identified. Versions of packages are compared when loading the packages to ensure compatibility. An “image” of loaded software is created, which image may be reused by the JVM in order to restart an application rapidly following a failure. A loader environment within the JVM contains information about all loaded applications, packages, and classes, their attributes, and their interrelationships.

Claims

1. A method for loading a Java application program onto a Java Virtual Machine (“

JVM”

), comprising the steps of;

(a) identifying package files required for operation of the application program, each of which package files comprises at least one class file;

(b) determining a package load order in which each respective package file may be loaded before any package file is loaded that depends on the respective package file;

(c) determining a class load order in which each respective class file within each package file may be loaded before any class file is loaded that depends on the respective class file; and

(d) loading into the JVM the package files in the package load order, and the class files within each package file in the class load order.

2. The method of claim 1 wherein the step of determining a package load order further comprises recursively calculating the transitive closure of dependencies of the package files.

3. The method of claim 1 wherein the step of determining a class load order further comprises recursively calculating the transitive closure of dependencies of the class files.

4. The method of claim 1 wherein the application program contains a key class, and the step of determining a package load order further comprises identifying all class files required by the key class, and recursively identifying the requirements of each of the class files, until no new class files are known to be required.

5. The method of claim 1 wherein the application program contains a key class, and the step of determining a class load order further comprises identifying all class files required by the key class, and recursively identifying the requirements of each of the class files, until no new class files are known to be required.

6. The method of claim 1 wherein the step of loading further comprises, for each respective package file, the steps of determining whether the respective package file has previously been loaded;

and upon a determination that the respective package file has not been loaded, loading the respective package file.

7. The method of claim 1, wherein the step of loading further comprises the step of compiling all loaded class files.

8. The method of claim 1, wherein the step of loading further comprises the step of optimizing all loaded class files.

9. The method of claim 1, wherein the step of loading further comprises the steps of initializing all loaded class files.

10. The method of claim 1, wherein the step of loading includes comparing versions of loaded package files with requirements of the package files to be loaded, to determine version compatibility between package files.

11. The method of claim 1 wherein the JVM includes a loader environment, and the step of loading package files into the JVM further comprises loading each package file into the loader environment of the JVM.

12. The method of claim 1 wherein the JVM includes a loader environment, and step of loading of package files into the JVM further comprises loading each package file into the loader environment of the JVM;

and storing in non-volatile memory or other media the contents of a loader environment, such that the contents may be retrieved by a fresh invocation of the JVM in order to execute the program without individually reloading each application, package file, and class file.

13. The method of claim 1 further comprising the step of generating with respect to each package file a package load file identifying in the class load order the class files contained within the respective package file.

14. The method of claim 1 further comprising the steps of generating an application control file identifying the package files in the package load order, and reading the application control file into the JVM;

and the step of loading further comprises loading each package file into the JVM in the package load order stored in the application control file, wherein the loading of each respective package file further comprises loading each class file of the respective package file into the JVM in the class load order.

15. A method for loading a Java application program to a Java Virtual Machine (“

JVM”

) residing on a computer, the Java application program including a plurality of package files, each of which package files includes a plurality of class files, the method comprising;

determining a class load order in which each respective class file within each package file may be loaded before any class file is loaded that depends on the respective class file;

determining a package load order in which each respective package file may be loaded before any package file is loaded that depends on the respective package file;

storing the package load order in an application control file attached to the application program;

reading the application control file into the JVM; and

loading each package file into the JVM in the package load order stored in the application control file, wherein the loading of each respective package file further comprises loading each class file of the respective package file into the JVM in the class load order.

16. The method of claim 15 wherein the step loading each respective package file further comprises compiling the respective package file.

17. The method of claim 15 wherein the step loading each respective package file further comprises initializing the respective package file.

18. The method of claim 15 wherein the step of loading each respective package file further comprises optimizing the respective package file.

19. The method of claim 15 wherein the step of determining a class load order further comprises recursively calculating the transitive closure of the dependencies of the application program.

20. The method of claim 15 wherein the step of determining a package load order further comprises recursively calculating the transitive closure of the dependencies of the application program.

21. The method of claim 15 wherein the JVM includes a loader environment, and step of loading each package file into the JVM further comprises loading each package file into the loader environment of the JVM.

22. The method of claim 15 wherein the JVM includes a loader environment containing information about software objects loaded on the computer through the JVM, and step of loading each package file into the JVM further comprises loading each package file into the loader environment of the JVM.

23. A Java Virtual Machine (“

JVM”

) operable on a computer and having a loader environment containing information about software objects which may be loaded onto the computer through the JVM, the loader environment comprising;

an application data structure defined on an electronic memory of the computer, the application data structure being configured for receiving at least one application program;

at least one package data structure defined on the electronic memory of the computer for identifying each respective package of the application data structure in such an order that, when the packages are loaded, no respective package is loaded before the packages upon which the respective package depends are loaded; and

at least one class data structure defined on the electronic memory of the computer for identifying each Java respective class data structure of the package data structure in such an order that, when the class data structures are loaded, no respective class data structures is loaded before the class data structures upon which the respective class data structure depends are loaded.

24. The JVM of claim 23 wherein the application data structure, the package data structure, and the class data structure include data structures which define relationships between application programs, package files, and class data structures.

25. The JVM of claim 23 wherein the application data structure further comprises attributes belonging to applications loaded onto the JVM, the package data structure further comprises attributes belonging to packages loaded onto the JVM package data structure, and the class data structure further comprises attributes belonging to class data structures loaded onto the JVM.

26. The JVM of claim 23 further comprising a program running in the JVM configured for inspecting the application data structures, the package data structures, and the class data structures in the JVM.

27. The JVM of claim 23 further comprising an interface between the JVM and an external program through which the external program may inspect the application data structures, the package data structures, and the class data structures in the JVM.