Class file archives with reduced data volume

• US 20030033310A1
• Filed: 07/12/2001
• Published: 02/13/2003
• Est. Priority Date: 07/12/2001
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Factor, Michael, Teperman, Avi, Greenwood, Matt
• Granted Patent: US 6,732,108 B2
• Time in Patent Office: Days
• US Class Current: 707/100
• CPC Class Codes: G06F 9/445 Program loading or initiating bootstrapping G06F9/4401; security arrangements for program loading or initiating G06F21/57
• CPC Class Codes: Y10S 707/99931 Database or file accessing
• CPC Class Codes: Y10S 707/99937 Sorting

Abstract

A method for packaging program resources includes collecting a set of the program resources that comprises a plurality of object files, which contain data structures having entries that are constants and methods that reference the entries. The data structures in at least some of the object files are combined into a common data pool, in which semantically-identical entries in different ones of the files are represented by a single consolidated entry, irrespective of whether the entries in the different files are syntactically identical. The set of the program resources is packaged together with the common data pool in a combined output file.

Claims

1. A method for packaging program resources, comprising:

collecting a set of the program resources that comprises a plurality of object files, which contain data structures having entries that are constants and methods that reference the entries;

combining the data structures in at least some of the object files into a common data pool, in which semantically-identical entries in different ones of the files are represented by a single consolidated entry, irrespective of whether the entries in the different files are syntactically identical; and

packaging the set of the program resources together with the common data pool in a combined output file.

2. A method according to claim 1, wherein the object files comprise class files, and wherein the class files comprise respective constant pools containing the data structures.

3. A method according to claim 2, wherein combining the data structures comprises consolidating substantially all of the data structures in the constant pools of all of the object files into the common pool, and removing substantially all of the data structures from all of the object files before packaging the object files in the combined output file.

4. A method according to claim 1, wherein the object files comprise executable code, and wherein combining the data structures comprises scanning the code to identify the entries in the different files that are semantically identical.

5. A method according to claim 4, wherein scanning the code comprises finding first and second ones of the entries in the different files that reference a common element in one of the files in the set, while the first and second entries themselves are different, first and second constants.

6. A method according to claim 1, wherein combining the data structures comprises modifying the references to the semantically-identical entries so as to refer to the consolidated entry in the common data pool.

7. A method according to claim 1, wherein packaging the set of the program resources comprises adding a program mechanism to the set which, when read by a computer receiving the packaged set of program resources, causes the computer to reconstruct the data structures in the object files from the common data pool.

8. A method according to claim 1, wherein packaging the set of the program resources comprises compressing the resources in the output file.

9. A method for generating an archive file, comprising:

assembling a set of program resources that comprise a plurality of class files containing methods and respective constant pools;

combining the constant pools of the class files into a global constant pool, in which semantically-identical entries in the constant pools of different ones of the class files are represented by a single consolidated entry, irrespective of whether the entries in the different class files are syntactically identical; and

packaging the set of the program resources together with the common data pool in the archive file.

10. A method according to claim 9, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

11. A method according to claim 10, wherein packaging the set of the program resources comprises creating the JAR file in such a manner that a standard Java Virtual Machine can, substantially without modification, open the JAR file and invoke the methods in the class files that are packaged therein.

12. A method according to claim 9, wherein combining the constant pools comprises consolidating substantially all of the constant pools of all of the class files into the global constant pool.

13. A method according to claim 12, wherein consolidating substantially all of the constant pools comprises creating the global constant pool in one of the class files, and removing the constant pools from all of the other class files before packaging the class files in the archive file.

14. A method according to claim 13, wherein assembling the set of program resources comprises collecting the program resources needed to run an applet, and wherein creating the global constant pool in one of the class files comprises specifying the one of the class files that is first invoked among the class files in order to run the applet, and creating the global constant pool in the specified class file.

15. A method according to claim 9, wherein the class files comprise byte code, and wherein combining the constant pools comprises scanning the byte code to identify the entries in the constant pools of the different files that are semantically identical.

16. A method according to claim 9, wherein packaging the set of the program resources comprises adding a program mechanism to the set which, when read by a computer receiving the packaged set of program resources, causes the computer to reconstruct the constant pools of the class files from the global constant pool.

17. A method according to claim 9, and comprising compressing the archive file.

18. A method for packaging program resources, comprising:

collecting a set of class files containing methods and constant pools, which comprise data structures having entries that are constants;

consolidating the constant pools of the class files into a single, common pool, comprising substantially all of the data structures in all of the class files in the set; and

packaging the set of the class files, together with the common pool in a combined output file.

19. A method according to claim 18, wherein consolidating the constant pools comprises removing the constant pools from the class files after consolidating the constant pools in the common pool, so that the class files no longer contain the constant pools.

20. A method according to claim 19, wherein consolidating the constant pools comprises placing the common pool in one of the class files.

21. A method according to claim 18, wherein packaging the set of the class files comprises adding a program mechanism to the set which, when read by a computer receiving the packaged set of class files, causes the computer to reconstruct the constant pools in the class files from the common pool.

22. A method according to claim 18, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

23. A method according to claim 22, wherein packaging the set of the class files comprises creating the JAR file in such a manner that a standard Java Virtual Machine can, substantially without modification, open the JAR file and invoke the methods in the class files that are packaged therein.

24. A method for packaging program resources, comprising:

assembling a set of the program resources that comprises a plurality of class files containing methods and constant pools, which comprise data structures having entries that are constants;

consolidating at least a portion of the constant pools of the class files into a single, common pool;

adding to the set of resources a program mechanism which, when read by a computer receiving the class files with the single, common pool, causes the computer to reconstruct the constant pools in the class files from the common pool; and

packaging the set of the program resources, including the common pool and the program mechanism, in a combined output file.

25. A method according to claim 24, wherein assembling the set of program resources comprises collecting the program resources needed to run an application, and wherein adding the program mechanism comprises providing the mechanism so that the computer will reconstruct the constant pools during a process of installation of the application on the computer.

26. A method according to claim 24, wherein assembling the set of program resources comprises collecting the program resources needed to run an applet, and wherein adding the program mechanism comprises providing the mechanism so that the computer will reconstruct the constant pools during a process of initializing the applet.

27. A method according to claim 26, wherein adding the mechanism comprises adding the mechanism to one of the classes that is first to be loaded by the computer when it runs the applet.

28. A method according to claim 27, wherein adding the mechanism comprises providing an initialization method in the class that is the first to be loaded, such that the initialization method engenders reconstruction of the constant pools.

29. A method according to claim 28, wherein providing the initialization method comprises adding a wrapper class containing the initialization method to the program resources needed to run the applet, and configuring the set of the program resources so that the wrapper class is the first to be loaded.

30. A method according to claim 24, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

31. A method according to claim 30, wherein adding the mechanism comprises providing the mechanism in the JAR file in such a manner as to enable a standard Java Virtual Machine, substantially without modification, to open the JAR file and invoke the methods in the class files that are packaged therein.

32. Apparatus for packaging program resources, comprising an archive processor, which is arranged to collect a set of the program resources that comprises a plurality of object files, which contain data structures having entries that are constants and methods that reference the entries, to combine the data structures in at least some of the object files into a common data pool, in which semantically-identical entries in different ones of the files are represented by a single consolidated entry, irrespective of whether the entries in the different files are syntactically identical, and to package the set of the program resources together with the common data pool in a combined output file.

33. Apparatus according to claim 32, wherein the object files comprise class files, and wherein the class files comprise respective constant pools containing the data structures.

34. Apparatus according to claim 33, wherein the processor is arranged to consolidate substantially all of the data structures in the constant pools of all of the object files into the common pool, and to remove substantially all of the data structures from all of the object files before packaging the object files in the combined output file.

35. Apparatus according to claim 32, wherein the object files comprise executable code, and wherein the processor is arranged to scan the code so as to identify the entries in the different files that are semantically identical.

36. Apparatus according to claim 35, wherein the processor is arranged to identify semantically-identical entries by finding first and second ones of the entries in the different files that reference a common element in one of the files in the set, while the first and second entries themselves are different, first and second constants.

37. Apparatus according to claim 32, wherein the processor is arranged to modify the references to the semantically-identical entries so as to refer to the consolidated entry in the common data pool.

38. Apparatus according to claim 32, wherein the processor is arranged to add a program mechanism to the set which, when read by a computer receiving the packaged set of program resources, causes the computer to reconstruct the data structures in the object files from the common data pool.

39. Apparatus according to claim 32, wherein the processor is arranged to compress the resources in the output file.

40. Apparatus for generating an archive file, comprising an archive processor, which is arranged to assemble a set of program resources that comprise a plurality of class files containing methods and respective constant pools, to combine the constant pools of the class files into a global constant pool, in which semantically-identical entries in the constant pools of different ones of the class files are represented by a single consolidated entry, irrespective of whether the entries in the different class files are syntactically identical, and to package the set of the program resources together with the common data pool in the archive file.

41. Apparatus according to claim 40, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

42. Apparatus according to claim 41, wherein the processor is arranged to create the JAR file in such a manner that a standard Java Virtual Machine can, substantially without modification, open the JAR file and invoke the methods in the class files that are packaged therein.

43. Apparatus according to claim 40, wherein the processor is arranged to consolidate substantially all of the constant pools of all of the class files into the global constant pool.

44. Apparatus according to claim 43, wherein the processor is arranged to create the global constant pool in one of the class files, and to remove the constant pools from all of the other class files before packaging the class files in the archive file.

45. Apparatus according to claim 44, wherein the set of program resources comprises the program resources needed to run an applet, and wherein the processor is arranged to create the global constant pool in the one of the class files that is first invoked among the class files in order to run the applet.

46. Apparatus according to claim 40, wherein the class files comprise byte code, and wherein the processor is arranged to scan the byte code to identify the entries in the constant pools of the different files that are semantically identical.

47. Apparatus according to claim 40, wherein the processor is arranged to add a program mechanism to the set which, when read by a computer receiving the packaged set of program resources, causes the computer to reconstruct the constant pools of the class files from the global constant pool.

48. Apparatus according to claim 40, wherein the processor is arranged to compress the archive file.

49. Apparatus for packaging program resources, comprising an archive processor, which is arranged to assemble a set of class files containing methods and constant pools, which comprise data structures having entries that are constants, to consolidate the constant pools of the class files into a single, common pool, comprising substantially all of the data structures in all of the class files in the set, and to package the set of the class files, together with the common pool in a combined output file.

50. Apparatus according to claim 49, wherein the processor is arranged to remove the constant pools from the class files after consolidating the constant pools in the common pool, so that the class files no longer contain the constant pools.

51. Apparatus according to claim 50, wherein the processor is arranged to place the common pool in one of the class files.

52. Apparatus according to claim 49, wherein the processor is arranged to add a program mechanism to the set which, when read by a computer receiving the packaged set of class files, causes the computer to reconstruct the constant pools in the class files from the common pool.

53. Apparatus according to claim 49, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

54. Apparatus according to claim 53, wherein the processor is arranged to create the JAR file in such a manner that a standard Java Virtual Machine can, substantially without modification, open the JAR file and invoke the methods in the class files that are packaged therein.

55. Apparatus for packaging program resources, comprising an archive processor, which is arranged to assemble a set of the program resources that comprises a plurality of class files containing methods and constant pools, which comprise data structures having entries that are constants, to consolidate at least a portion of the constant pools of the class files into a single, common pool, to add to the set of resources a program mechanism which, when read by a computer receiving the class files with the single, common pool, causes the computer to reconstruct the constant pools in the class files from the common pool, and to package the set of the program resources, including the common pool and the program mechanism, in a combined output file.

56. Apparatus according to claim 55, wherein the set of program resources comprises the program resources needed to run an application, and wherein the processor is arranged to provide the mechanism so that the computer will reconstruct the constant pools during a process of installation of the application on the computer.

57. Apparatus according to claim 55, wherein the set of program resources comprises the program resources needed to run an applet, and wherein the processor is arranged to provide the mechanism so that the computer will reconstruct the constant pools during a process of running the applet.

58. Apparatus according to claim 57, wherein the processor is arranged to add the mechanism to one of the classes that is first to be loaded by the computer when it runs the applet.

59. Apparatus according to claim 58, wherein the mechanism comprises an initialization method in the class that is the first to be loaded, such that the initialization method engenders reconstruction of the constant pools.

60. Apparatus according to claim 59, wherein the processor is arranged to add a wrapper class containing the initialization method to the program resources needed to run the applet, and to configure the set of the program resources so that the wrapper class is the first to be loaded.

61. Apparatus according to claim 55, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

62. Apparatus according to claim 61, wherein the mechanism is provided in the JAR file in such a manner as to enable a standard Java Virtual Machine, substantially without modification, to open the JAR file and invoke the methods in the class files that are packaged therein.

63. A computer program product for packaging program resources, the product comprising a computer-readable medium in which program instructions are stored, which instructions, when read by a computer, cause the computer to collect a set of the program resources that comprises a plurality of object files, which contain data structures having entries that are constants and methods that reference the entries, to combine the data structures in at least some of the object files into a common data pool, in which semantically-identical entries in different ones of the files are represented by a single consolidated entry, irrespective of whether the entries in the different files are syntactically identical, and to package the set of the program resources together with the common data pool in a combined output file.

64. A product according to claim 63, wherein the object files comprise class files, and wherein the class files comprise respective constant pools containing the data structures.

65. A product according to claim 64, wherein the instructions cause the computer to consolidate substantially all of the data structures in the constant pools of all of the object files into the common pool, and to remove substantially all of the data structures from all of the object files before packaging the object files in the combined output file.

66. A product according to claim 63, wherein the object files comprise executable code, and wherein the instructions cause the computer to scan the code so as to identify the entries in the different files that are semantically identical.

67. A product according to claim 66, wherein the instructions cause the computer to identify semantically-identical entries by finding first and second ones of the entries in the different files that reference a common element in one of the files in the set, while the first and second entries themselves are different, first and second constants.

68. A product according to claim 63, wherein the instructions cause the computer to modify the references to the semantically-identical entries so as to refer to the consolidated entry in the common data pool.

69. A product according to claim 63, wherein the instructions cause the computer to add a program mechanism to the set which, when read by a client computer receiving the packaged set of program resources, causes the client computer to reconstruct the data structures in the object files from the common data pool.

70. A product according to claim 63, wherein the instructions cause the computer to compress the resources in the output file.

71. A computer program product for generating an archive file, the product comprising a computer-readable medium in which program instructions are stored, which instructions, when read by a computer, cause the computer to assemble a set of program resources that comprise a plurality of class files containing methods and respective constant pools, to combine the constant pools of the class files into a global constant pool, in which semantically-identical entries in the constant pools of different ones of the class files are represented by a single consolidated entry, irrespective of whether the entries in the different class files are syntactically identical, and to package the set of the program resources together with the common data pool in the archive file.

72. A product according to claim 71, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

73. A product according to claim 72, wherein the instructions cause the computer to create the JAR file in such a manner that a standard Java Virtual Machine can, substantially without modification, open the JAR file and invoke the methods in the class files that are packaged therein.

74. A product according to claim 71, wherein the instructions cause the computer to consolidate substantially all of the constant pools of all of the class files into the global constant pool.

75. A product according to claim 74, wherein the instructions cause the computer to create the global constant pool in one of the class files, and to remove the constant pools from all of the other class files before packaging the class files in the archive file.

76. A product according to claim 75, wherein the set of program resources comprises the program resources needed to run an applet, and wherein the instructions cause the computer to create the global constant pool in the one of the class files that is first invoked among the class files in order to run the applet.

77. A product according to claim 71, wherein the class files comprise byte code, and wherein the instructions cause the computer to scan the byte code to identify the entries in the constant pools of the different files that are semantically identical.

78. A product according to claim 71, wherein the instructions cause the computer to add a program mechanism to the set which, when read by a client computer receiving the packaged set of program resources, causes the client computer to reconstruct the constant pools of the class files from the global constant pool.

79. A product according to claim 71, wherein the instructions cause the computer to compress the archive file.

80. A computer program product for packaging program resources, the product comprising a computer-readable medium in which program instructions are stored, which instructions, when read by a computer, cause the computer to assemble a set of class files containing methods and constant pools, which comprise data structures having entries that are constants, to consolidate the constant pools of the class files into a single, common pool, comprising substantially all of the data structures in all of the class files in the set, and to package the set of the class files, together with the common pool in a combined output file.

81. A product according to claim 80, wherein the instructions cause the computer to remove the constant pools from the class files after consolidating the constant pools in the common pool, so that the class files no longer contain the constant pools.

82. A product according to claim 81, wherein the instructions cause the computer to place the common pool in one of the class files.

83. A product according to claim 80, wherein the instructions cause the computer to add a program mechanism to the set which, when read by a client computer receiving the packaged set of class files, causes the client computer to reconstruct the constant pools in the class files from the common pool.

84. A product according to claim 80, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

85. A product according to claim 84, wherein the instructions cause the computer to create the JAR file in such a manner that a standard Java Virtual Machine can, substantially without modification, open the JAR file and invoke the methods in the class files that are packaged therein.

86. A computer program product for packaging program resources, the product comprising a computer-readable medium in which program instructions are stored, which instructions, when read by a computer, cause the computer to assemble a set of the program resources that comprises a plurality of class files containing methods and constant pools, which comprise data structures having entries that are constants, to consolidate at least a portion of the constant pools of the class files into a single, common pool, to add to the set of resources a program mechanism which, when read by a client computer receiving the class files with the single, common pool, causes the client computer to reconstruct the constant pools in the class files from the common pool, and to package the set of the program resources, including the common pool and the program mechanism, in a combined output file.

87. A product according to claim 86, wherein the set of program resources comprises the program resources needed to run an application, and wherein the program instructions cause the computer to provide the mechanism so that the client computer will reconstruct the constant pools during a process of installation of the application on the computer.

88. A product according to claim 86, wherein the set of program resources comprises the program resources needed to run an applet, and wherein the instructions cause the computer to provide the mechanism so that the client computer will reconstruct the constant pools during a process of running the applet.

89. A product according to claim 88, wherein the instructions cause the computer to add the mechanism to one of the classes that is first to be loaded by the computer when it runs the applet.

90. A product according to claim 89, wherein the mechanism comprises an initialization method in the class that is the first to be loaded, such that the initialization method engenders reconstruction of the constant pools.

91. A product according to claim 90, wherein the instructions cause the computer to add a wrapper class containing the initialization method to the program resources needed to run the applet, and to configure the set of the program resources so that the wrapper class is the first to be loaded.

92. A product according to claim 86, wherein the class files comprise Java classes, and wherein the archive file comprises a Java Archive (JAR) file.

93. A product according to claim 92, wherein the mechanism is provided in the JAR file in such a manner as to enable a standard Java Virtual Machine, substantially without modification, to open the JAR file and invoke the methods in the class files that are packaged therein.