US20040168163A1 - System and method for shortening class loading process in Java program - Google Patents

System and method for shortening class loading process in Java program Download PDF

Info

Publication number
US20040168163A1
US20040168163A1 US10/773,292 US77329204A US2004168163A1 US 20040168163 A1 US20040168163 A1 US 20040168163A1 US 77329204 A US77329204 A US 77329204A US 2004168163 A1 US2004168163 A1 US 2004168163A1
Authority
US
United States
Prior art keywords
runtime data
unit
memory unit
java program
runtime
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US10/773,292
Inventor
Ji-young Choi
Hyo-jung Song
Jung-Gyu Park
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Samsung Electronics Co Ltd
Original Assignee
Samsung Electronics Co Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Samsung Electronics Co Ltd filed Critical Samsung Electronics Co Ltd
Assigned to SAMSUNG ELECTRONICS CO., LTD. reassignment SAMSUNG ELECTRONICS CO., LTD. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: CHOI, JI-YOUNG, PARK, JUNG-GYU, SONG, HYO-JUNG
Publication of US20040168163A1 publication Critical patent/US20040168163A1/en
Abandoned legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/445—Program loading or initiating
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs

Definitions

  • the present invention relates to a system and method for shortening the class loading process in a Java program. More particularly, the present invention relates to a system and method for shortening the class loading process in a Java program, wherein runtime data generated upon performing the class loading process in the Java program are stored in the form of images and the stored runtime data are retrieved and executed upon future execution of the Java program, thereby shortening the class loading time.
  • Java programs e.g., games, messengers, etc.
  • Java programs e.g., games, messengers, etc.
  • a class loading process should be first performed in a Java virtual machine (JVM). Further, in order to complete the class loading process, the processes including loading, linking, initialization and the like should be performed. Furthermore, the linking process includes the processes of verification, preparation, resolution, etc. Therefore, there is a problem in that a lot of time is spent in performing the class loading process.
  • JVM Java virtual machine
  • the verification process among the class loading process can be performed only when the Java program is initially executed.
  • the current class loading process is designed such that the verification process is performed whenever the Java program is executed.
  • the conventional class loading process has problems in that in a system such as a mobile terminal with a low-performance CPU and a low-capacity battery, system response time is increased and the battery is rapidly exhausted.
  • An object of the present invention is to provide a system and method for shortening the class loading process in a Java program, wherein runtime data generated upon performing the class loading process in the Java program are stored in the form of images and the stored runtime data are retrieved and executed upon future execution of the Java program, thereby shortening the class loading time.
  • Another object of the present invention is to provide a system and method for shortening the class loading process in a Java program, wherein the processing speed of the Java program is improved in equipment with a low-performance CPU and/or a low-capacity battery, thereby reducing response time to a user and conserving battery power.
  • a system for shortening the class loading process in a Java program comprising a class loader unit for loading Java program class files from an auxiliary memory, performing linking and initialization processes and generating runtime data; a first memory unit for maintaining the runtime data generated by the class loader unit in an accessible state; a second memory unit for storing the runtime data, which have been loaded into the first memory unit in an accessible state, in the form of images; a runtime data search unit for loading the runtime data, which have been stored in the second memory unit in the form of images, into the first memory unit upon the request of the class loader unit; and an execution unit for executing the runtime data that have been loaded into the first memory unit in an accessible state.
  • FIG. 1 is a block diagram schematically showing a system for shortening the class loading process in a Java program according to the present invention
  • FIG. 2 is a flowchart schematically illustrating a method for shortening the class loading process in a Java program according to the present invention.
  • FIG. 3 is a flowchart specifically illustrating a process of generating runtime data shown in FIG. 2.
  • FIG. 1 is a block diagram schematically showing a system for shortening the class loading process in a Java program.
  • the system comprises a class loader unit 100 , a first memory unit 200 , a runtime data search unit 300 , a second memory unit 400 , an execution unit 500 , and a garbage collector unit 600 .
  • the class loader unit 100 loads Java program class files from an auxiliary memory, performs linking and initialization processes, and then generates runtime data.
  • the loading process means a process of loading the class files, located in the auxiliary memory unit, into a Java virtual machine.
  • the linking process means a process of causing the loaded class files to be processed into a state where they can be executed by the Java virtual machine, and includes the processes of verification, preparation, resolution, etc.
  • the runtime data are loaded into the first memory unit 200 and used for executing the Java program.
  • the runtime data can be understood as a constant pool, method table, field table, etc.
  • the first memory unit 200 maintains the runtime data generated by the class loader unit 100 in an accessible state. That is, the runtime data generated by the class loader unit 100 are stored in predetermined memory areas so that the execution unit 500 to be described later can access the stored runtime data.
  • the second memory unit 400 stores the runtime data, which have been loaded into the first memory unit 200 in an accessible state, in the form of images.
  • the runtime data search unit 300 loads the runtime data stored in the second memory unit 400 into the first memory unit 200 upon the request of the class loader unit 100 . Further, the runtime data search unit 300 stores the runtime data, which have been generated by the class loader unit 100 , in the second memory unit 400 in the form of images. In addition, the runtime data search unit 300 manages the runtime data, which have been stored in the second memory unit 400 in the form of images, by using the least recently used (LRU) method.
  • LRU least recently used
  • the execution unit 500 executes the runtime data loaded into the first memory unit 200 in an accessible state.
  • the garbage collector unit 600 collects memory areas not used in the first memory unit 200 to allow the unused areas to be used again, thereby securing more usable areas in the first memory unit 200 .
  • FIG. 2 is a flowchart schematically illustrating a method for shortening the class loading process in a Java program according to the present invention.
  • the class loader unit 100 requests the runtime data search unit 300 to search runtime data necessary for the execution of a Java program (S 100 ), and then, the runtime data search unit 300 searches whether the runtime data exist in the second memory unit 400 (S 110 ).
  • the search unit 500 executes the runtime data transmitted to the first memory unit 200 (S 160 ).
  • the runtime data stored in the second memory unit 400 can be image files, i.e. files in which the runtime data generated upon execution of the previous Java program are stored in the form of images.
  • the runtime data that have been previously generated and stored in the second memory unit 400 are simply loaded into and executed in the first memory unit 200 .
  • the class loader unit 100 generates runtime data necessary for execution of the Java program (S 130 ).
  • the Java program class files are loaded from the auxiliary memory (S 132 ), and the runtime data are generated by performing the linking and initialization processes for the loaded class files (S 134 to S 138 ).
  • the loading process means a process of loading the class files, located in the auxiliary memory, into the Java virtual machine; and the class file linking process means a process of causing the loaded class files to be processed into a state where they can be executed by the Java virtual machine.
  • the linking process includes the verification process of verifying whether the loaded class file contains correct class formats, the preparation process of allocating the memory areas, and the resolution process of converting the class files into executable ones.
  • the class files are initialized and the runtime data are generated.
  • the runtime data search unit 300 stores the generated runtime data in the second memory unit 400 in the form of images (S 140 ). At this time, the runtime data search unit 300 manages the image data stored in the second memory unit 400 according to the LRU method. That is, since there are limitations in storage areas of the second memory unit 400 , the LRU method is employed to manage the stored data.
  • the runtime data search unit 300 transmits the runtime data stored in the form of images to the first memory unit 200 (S 150 ), and the execution unit 500 executes the runtime image data transmitted to the first memory unit 200 (S 160 ).
  • the garbage collector unit 600 collects space unused in the first memory unit 200 and allows the collected space to be used again, thereby securing more space in the first memory unit 200 .
  • step S 140 may be performed after step S 160 . That is, when the runtime data are generated (S 130 ), the generated runtime data are transmitted to the first memory unit 200 (S 150 ) and the transmitted runtime data are executed (S 160 ). Then, after the execution of the Java program is completed, the runtime data may be stored in the second memory unit 400 .
  • the runtime data generated upon performing the class loading process in the Java program are stored in the form of images and the stored runtime data are retrieved and executed upon future execution of the Java program, whereby the Java program can be executed without performing the complicated class loading process.
  • class loading time can be shortened upon the execution of a Java program.
  • the processing speed of Java programs is improved in equipment with a low-performance CPU and/or a low-capacity battery, thereby reducing response time to a user and conserving battery power.

Abstract

A system for shortening the class loading process in a Java program according to the present invention includes a class loader unit for loading Java program class files from an auxiliary memory, performing linking and initialization processes and generating runtime data; a first memory unit for maintaining the runtime data generated by the class loader unit in an accessible state; a second memory unit for storing the runtime data, which have been loaded into the first memory unit in an accessible state, in the form of images; a runtime data search unit for loading the runtime data, which have been stored in the second memory unit in the form of images, into the first memory unit upon the request of the class loader unit; and an execution unit for executing the runtime data that have been loaded into the first memory unit in an accessible state.

Description

    BACKGROUND OF THE INVENTION
  • This application claims the priority of Korean Patent Application No. 10-2003-0007728 filed on Feb. 7, 2003, in the Korean Intellectual Property Office, the disclosure of which is incorporated herein by reference. [0001]
  • 1. Field of Invention [0002]
  • The present invention relates to a system and method for shortening the class loading process in a Java program. More particularly, the present invention relates to a system and method for shortening the class loading process in a Java program, wherein runtime data generated upon performing the class loading process in the Java program are stored in the form of images and the stored runtime data are retrieved and executed upon future execution of the Java program, thereby shortening the class loading time. [0003]
  • 2. Description of the Prior Art [0004]
  • Recently, the size of Java programs (e.g., games, messengers, etc.) operating in mobile terminals has become larger as the use of mobile terminals gradually increased. [0005]
  • However, in order to execute a Java program, a class loading process should be first performed in a Java virtual machine (JVM). Further, in order to complete the class loading process, the processes including loading, linking, initialization and the like should be performed. Furthermore, the linking process includes the processes of verification, preparation, resolution, etc. Therefore, there is a problem in that a lot of time is spent in performing the class loading process. [0006]
  • In particular, as for the same byte codes, the verification process among the class loading process can be performed only when the Java program is initially executed. However, the current class loading process is designed such that the verification process is performed whenever the Java program is executed. Thus, the conventional class loading process has problems in that in a system such as a mobile terminal with a low-performance CPU and a low-capacity battery, system response time is increased and the battery is rapidly exhausted. [0007]
  • Further, as the size of a Java program becomes larger, time spent in loading the program is generally increased. In such a case, accordingly, the aforementioned problems related to system response time and battery life become even more severe. [0008]
    • SUMMARY OF THE INVENTION
  • The present invention is conceived to solve the aforementioned problems. An object of the present invention is to provide a system and method for shortening the class loading process in a Java program, wherein runtime data generated upon performing the class loading process in the Java program are stored in the form of images and the stored runtime data are retrieved and executed upon future execution of the Java program, thereby shortening the class loading time. [0009]
  • Another object of the present invention is to provide a system and method for shortening the class loading process in a Java program, wherein the processing speed of the Java program is improved in equipment with a low-performance CPU and/or a low-capacity battery, thereby reducing response time to a user and conserving battery power. [0010]
  • According to an aspect of the present invention for achieving the objects, there is provided a system for shortening the class loading process in a Java program, comprising a class loader unit for loading Java program class files from an auxiliary memory, performing linking and initialization processes and generating runtime data; a first memory unit for maintaining the runtime data generated by the class loader unit in an accessible state; a second memory unit for storing the runtime data, which have been loaded into the first memory unit in an accessible state, in the form of images; a runtime data search unit for loading the runtime data, which have been stored in the second memory unit in the form of images, into the first memory unit upon the request of the class loader unit; and an execution unit for executing the runtime data that have been loaded into the first memory unit in an accessible state.[0011]
    • BRIEF DESCRIPTION OF THE DRAWINGS
  • The above and other objects and features of the present invention will become apparent from the following description of preferred embodiments given in conjunction with the accompanying drawings, in which: [0012]
  • FIG. 1 is a block diagram schematically showing a system for shortening the class loading process in a Java program according to the present invention; [0013]
  • FIG. 2 is a flowchart schematically illustrating a method for shortening the class loading process in a Java program according to the present invention; and [0014]
  • FIG. 3 is a flowchart specifically illustrating a process of generating runtime data shown in FIG. 2.[0015]
    • DETAILED DESCRIPTION OF THE INVENTION
  • Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. [0016]
  • FIG. 1 is a block diagram schematically showing a system for shortening the class loading process in a Java program. The system comprises a [0017] class loader unit 100, a first memory unit 200, a runtime data search unit 300, a second memory unit 400, an execution unit 500, and a garbage collector unit 600.
  • The [0018] class loader unit 100 loads Java program class files from an auxiliary memory, performs linking and initialization processes, and then generates runtime data. Here, the loading process means a process of loading the class files, located in the auxiliary memory unit, into a Java virtual machine. Further, the linking process means a process of causing the loaded class files to be processed into a state where they can be executed by the Java virtual machine, and includes the processes of verification, preparation, resolution, etc. The runtime data are loaded into the first memory unit 200 and used for executing the Java program. The runtime data can be understood as a constant pool, method table, field table, etc.
  • The [0019] first memory unit 200 maintains the runtime data generated by the class loader unit 100 in an accessible state. That is, the runtime data generated by the class loader unit 100 are stored in predetermined memory areas so that the execution unit 500 to be described later can access the stored runtime data.
  • The [0020] second memory unit 400 stores the runtime data, which have been loaded into the first memory unit 200 in an accessible state, in the form of images.
  • The runtime data search unit [0021] 300 loads the runtime data stored in the second memory unit 400 into the first memory unit 200 upon the request of the class loader unit 100. Further, the runtime data search unit 300 stores the runtime data, which have been generated by the class loader unit 100, in the second memory unit 400 in the form of images. In addition, the runtime data search unit 300 manages the runtime data, which have been stored in the second memory unit 400 in the form of images, by using the least recently used (LRU) method. Here, according to the LRU method, rarely used data among the stored data are checked and then deleted in order of rarity of use thereof.
  • The [0022] execution unit 500 executes the runtime data loaded into the first memory unit 200 in an accessible state.
  • The [0023] garbage collector unit 600 collects memory areas not used in the first memory unit 200 to allow the unused areas to be used again, thereby securing more usable areas in the first memory unit 200.
  • FIG. 2 is a flowchart schematically illustrating a method for shortening the class loading process in a Java program according to the present invention. [0024]
  • First, the [0025] class loader unit 100 requests the runtime data search unit 300 to search runtime data necessary for the execution of a Java program (S100), and then, the runtime data search unit 300 searches whether the runtime data exist in the second memory unit 400 (S110).
  • If the relevant runtime data are found in the second memory unit [0026] 400 (S120), the searched runtime data are transmitted to the first memory unit 200 (S125). Then, the execution unit 500 executes the runtime data transmitted to the first memory unit 200 (S160). Here, the runtime data stored in the second memory unit 400 can be image files, i.e. files in which the runtime data generated upon execution of the previous Java program are stored in the form of images.
  • Meanwhile, according to the present invention, the runtime data that have been previously generated and stored in the [0027] second memory unit 400 are simply loaded into and executed in the first memory unit 200. Thus, it is not necessary to generate the runtime data whenever executing the Java program, thereby eliminating a complicated loading process needed for generating the runtime data. Accordingly, class loading time can be reduced.
  • Furthermore, if there are no relevant runtime data as a result of the search of the [0028] second memory unit 400 by the runtime data search unit 300, the class loader unit 100 generates runtime data necessary for execution of the Java program (S130).
  • A process of generating runtime data will be discussed with reference to FIG. 3. First, the Java program class files are loaded from the auxiliary memory (S[0029] 132), and the runtime data are generated by performing the linking and initialization processes for the loaded class files (S134 to S138). Here, the loading process means a process of loading the class files, located in the auxiliary memory, into the Java virtual machine; and the class file linking process means a process of causing the loaded class files to be processed into a state where they can be executed by the Java virtual machine. More specifically, the linking process includes the verification process of verifying whether the loaded class file contains correct class formats, the preparation process of allocating the memory areas, and the resolution process of converting the class files into executable ones.
  • After performing the linking process, the class files are initialized and the runtime data are generated. The runtime data search unit [0030] 300 stores the generated runtime data in the second memory unit 400 in the form of images (S140). At this time, the runtime data search unit 300 manages the image data stored in the second memory unit 400 according to the LRU method. That is, since there are limitations in storage areas of the second memory unit 400, the LRU method is employed to manage the stored data.
  • Thereafter, the runtime data search unit [0031] 300 transmits the runtime data stored in the form of images to the first memory unit 200 (S150), and the execution unit 500 executes the runtime image data transmitted to the first memory unit 200 (S160). Here, if the first memory unit 200 lacks space for data loading, the garbage collector unit 600 collects space unused in the first memory unit 200 and allows the collected space to be used again, thereby securing more space in the first memory unit 200.
  • Alternatively, step S[0032] 140 may be performed after step S160. That is, when the runtime data are generated (S130), the generated runtime data are transmitted to the first memory unit 200 (S150) and the transmitted runtime data are executed (S160). Then, after the execution of the Java program is completed, the runtime data may be stored in the second memory unit 400.
  • According to the present invention, the runtime data generated upon performing the class loading process in the Java program are stored in the form of images and the stored runtime data are retrieved and executed upon future execution of the Java program, whereby the Java program can be executed without performing the complicated class loading process. Thus, there is an advantage in that class loading time can be shortened upon the execution of a Java program. [0033]
  • Further, the processing speed of Java programs is improved in equipment with a low-performance CPU and/or a low-capacity battery, thereby reducing response time to a user and conserving battery power. [0034]
  • Although the present invention has been described in connection with the exemplary embodiments thereof shown in the accompanying drawings, they are mere examples of the present invention. It can also be understood by those skilled in the art that various changes and modifications thereof can be made thereto without departing from the scope and spirit of the present invention defined by the claims. Therefore, simple changes to the embodiments of the present invention fall within the scope of the present invention. [0035]

Claims (11)

What is claimed is:
1. A system for shortening a class loading process in a Java program, comprising:
a class loader unit for loading Java program class files from an auxiliary memory, performing linking and initialization processes and generating runtime data;
a first memory unit for maintaining the runtime data generated by the class loader unit in an accessible state;
a second memory unit for storing the runtime data, which have been loaded into the first memory unit in the accessible state, in a form of images;
a runtime data search unit for loading the runtime data, which have been stored in the second memory unit in the form of images, into the first memory unit upon the request of the class loader unit; and
an execution unit for executing the runtime data that have been loaded into the first memory unit in the accessible state.
2. The system as claimed in claim 1, further comprising a garbage collector unit for collecting space unused in the first memory unit and allowing the unused space to be used again.
3. The system as claimed in claim 1, wherein the runtime data search unit causes the runtime data generated by the class loader unit to be stored in the second memory unit in the form of images.
4. The system as claimed in claim 1 , wherein the runtime data search unit manages the runtime data, which have been stored in the second memory unit in the form of images, by using a least recently used (LRU) method.
5. The system as claimed in claim 3, wherein the runtime data search unit manages the runtime data, which have been stored in the second memory unit in the form of images, by using a least recently used (LRU) method.
6. A method for shortening a class loading process in a Java program, comprising the steps of:
requesting a runtime data search unit to search runtime data necessary for execution of the Java program, by a class loader unit;
searching the requested runtime data for the Java program by the runtime data search unit;
transmitting the searched runtime data to a first memory unit; and
executing the runtime data transmitted to the first memory unit.
7. The method as claimed in claim 6, wherein the searched runtime data are stored in a second memory unit in a form of images.
8. The method as claimed in claim 7, wherein the runtime image data stored in the second memory unit are managed by the runtime data search unit according to a least recently used (LRU) method.
9. The method as claimed in claim 6, further comprising the steps of, if it is determined from search results of the requested runtime data for the Java program that there are no relevant runtime data,
loading Java program class files from an auxiliary memory;
generating runtime data by performing linking and initialization processes of the loaded Java program class files;
storing the generated runtime data in a form of images; and
transmitting the runtime image data to the first memory unit.
10. The method as claimed in claim 9, wherein the step of storing the generated runtime data in the form of images is performed after the step of executing the runtime data transmitted to the first memory unit.
11. The method as claimed in claim 9, wherein the stored runtime image data are managed by the runtime data search unit according to a least recently used (LRU) method.
US10/773,292 2003-02-07 2004-02-09 System and method for shortening class loading process in Java program Abandoned US20040168163A1 (en)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
KR10-2003-0007728 2003-02-07
KR10-2003-0007728A KR100493893B1 (en) 2003-02-07 2003-02-07 System and method of shortening class loading process in java program

Publications (1)

Publication Number Publication Date
US20040168163A1 true US20040168163A1 (en) 2004-08-26

Family

ID=32866874

Family Applications (1)

Application Number Title Priority Date Filing Date
US10/773,292 Abandoned US20040168163A1 (en) 2003-02-07 2004-02-09 System and method for shortening class loading process in Java program

Country Status (4)

Country Link
US (1) US20040168163A1 (en)
JP (1) JP2004240965A (en)
KR (1) KR100493893B1 (en)
CN (1) CN1300681C (en)

Cited By (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20070061794A1 (en) * 2005-09-13 2007-03-15 Mausolf Jeffry R Method and apparatus for classpath optimization in a Java runtime environment
US20070180442A1 (en) * 2006-02-01 2007-08-02 Hirokazu Oi Execution apparatus and method
CN100465894C (en) * 2007-01-12 2009-03-04 中山大学 Class loading method for starting Java Processor
US20090125919A1 (en) * 2007-10-16 2009-05-14 Microsoft Corporation On-demand loading of types of software code of a program executing on a computing device
CN103257881A (en) * 2013-06-03 2013-08-21 贝壳网际（北京）安全技术有限公司 Plug-in operation method based on browser, browser device and terminal
US8745643B2 (en) 2007-05-09 2014-06-03 Zeroturnaround Ou Method and arrangement for re-loading a class

Families Citing this family (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR100749664B1 (en) * 2005-01-03 2007-08-14 에스케이 텔레콤주식회사 the romizing method of java class file and the executing method of its romized java class file
CN100346303C (en) * 2006-01-17 2007-10-31 浙江大学 Class loading implementation method in Java operation system
KR100777872B1 (en) * 2006-02-23 2007-11-21 엘지전자 주식회사 Method for displaying image of data broadcasting
CN101729753B (en) * 2009-11-06 2011-09-28 深圳市同洲电子股份有限公司 Method and device for loading pictures during java application
CN103473096A (en) * 2013-09-10 2013-12-25 浙江大学城市学院 Method and system for loading java class on virtual machine of android system

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5966702A (en) * 1997-10-31 1999-10-12 Sun Microsystems, Inc. Method and apparatus for pre-processing and packaging class files
US6061520A (en) * 1998-04-07 2000-05-09 Sun Microsystems, Inc. Method and system for performing static initialization
US6349344B1 (en) * 1997-12-16 2002-02-19 Microsoft Corporation Combining multiple java class files into a run-time image
US6584612B1 (en) * 1999-07-15 2003-06-24 International Business Machines Corporation Transparent loading of resources from read-only memory for an application program
US6725241B1 (en) * 1999-03-31 2004-04-20 International Business Machines Corporation Method and apparatus for freeing memory in a data processing system
US7065743B2 (en) * 2002-07-11 2006-06-20 International Business Machines Corporation Apparatus and method for caching analyzed program information

Family Cites Families (12)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPS6154548A (en) * 1984-08-23 1986-03-18 Fujitsu Ltd Control method of non-resident program
JP2772103B2 (en) * 1990-03-28 1998-07-02 株式会社東芝 Computer system startup method
JP3102455B2 (en) * 1993-07-26 2000-10-23 インターナショナル・ビジネス・マシーンズ・コーポレ−ション Information processing system
US5815718A (en) * 1996-05-30 1998-09-29 Sun Microsystems, Inc. Method and system for loading classes in read-only memory
GB2331814B (en) * 1997-11-19 2002-11-13 Ibm Pre-emptive download of software in data processing network
US6513158B1 (en) * 1999-11-15 2003-01-28 Espial Group Inc. Method and apparatus for running multiple java applications simultaneously
JP2002024038A (en) * 2000-07-05 2002-01-25 Toshiba Corp Class file retrieval system and recording medium with class file retrieval program recorded thereon in class file retrieval system
US6508396B1 (en) * 2000-07-18 2003-01-21 C. C. & L Company Limited Table top display devices
JP2002055835A (en) * 2000-08-11 2002-02-20 Omron Corp Program unloading system and storage medium
JP2002258971A (en) * 2001-02-28 2002-09-13 Hitachi Ltd Method for restarting computer system
US7080373B2 (en) * 2001-03-07 2006-07-18 Freescale Semiconductor, Inc. Method and device for creating and using pre-internalized program files
US6964033B2 (en) * 2001-06-20 2005-11-08 Sun Microsystems, Inc. Object band customization of Java runtime environments

Patent Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5966702A (en) * 1997-10-31 1999-10-12 Sun Microsystems, Inc. Method and apparatus for pre-processing and packaging class files
US6349344B1 (en) * 1997-12-16 2002-02-19 Microsoft Corporation Combining multiple java class files into a run-time image
US6061520A (en) * 1998-04-07 2000-05-09 Sun Microsystems, Inc. Method and system for performing static initialization
US6725241B1 (en) * 1999-03-31 2004-04-20 International Business Machines Corporation Method and apparatus for freeing memory in a data processing system
US6584612B1 (en) * 1999-07-15 2003-06-24 International Business Machines Corporation Transparent loading of resources from read-only memory for an application program
US7065743B2 (en) * 2002-07-11 2006-06-20 International Business Machines Corporation Apparatus and method for caching analyzed program information

Cited By (12)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20070061794A1 (en) * 2005-09-13 2007-03-15 Mausolf Jeffry R Method and apparatus for classpath optimization in a Java runtime environment
US20080222624A1 (en) * 2005-09-13 2008-09-11 International Business Machines Corporation Method and Apparatus for Classpath Optimization in a Java Runtime Environment
US8307352B2 (en) 2005-09-13 2012-11-06 International Business Machines Corporation Classpath optimization in a Java runtime environment
US9069582B2 (en) 2005-09-13 2015-06-30 International Business Machines Corporation Classpath optimization in a Java runtime environment
US20070180442A1 (en) * 2006-02-01 2007-08-02 Hirokazu Oi Execution apparatus and method
US8732723B2 (en) 2006-02-01 2014-05-20 Canon Kabushiki Kaisha Execution apparatus and method
CN100465894C (en) * 2007-01-12 2009-03-04 中山大学 Class loading method for starting Java Processor
US8745643B2 (en) 2007-05-09 2014-06-03 Zeroturnaround Ou Method and arrangement for re-loading a class
US20090125919A1 (en) * 2007-10-16 2009-05-14 Microsoft Corporation On-demand loading of types of software code of a program executing on a computing device
US8127284B2 (en) 2007-10-16 2012-02-28 Microsoft Corporation On-demand loading of types of software code of a program executing on a computing device
US8806468B2 (en) 2007-10-16 2014-08-12 Microsoft Corporation On-demand loading of types of software code of a program executing on a computing device
CN103257881A (en) * 2013-06-03 2013-08-21 贝壳网际（北京）安全技术有限公司 Plug-in operation method based on browser, browser device and terminal

Also Published As

Publication number Publication date
KR20040071831A (en) 2004-08-16
KR100493893B1 (en) 2005-06-10
CN1519709A (en) 2004-08-11
JP2004240965A (en) 2004-08-26
CN1300681C (en) 2007-02-14

Similar Documents

Publication Publication Date Title
US20040168162A1 (en) System and method for shortening compiling time of byte codes in java program
JP3945829B2 (en) Processing device for executing virtual machine instructions
US6567905B2 (en) Generational garbage collector with persistent object cache
EP1076290B1 (en) Method for on-demand network application download and execution
CN100365577C (en) Persistent cache apparatus and methods
US20100058007A1 (en) Information processing apparatus and memory management method
US20040168163A1 (en) System and method for shortening class loading process in Java program
JP2004127205A (en) Method and apparatus for storing data in nonvolatile memory
CN103765387A (en) Distributed resource management in a portable computing device
US20070203959A1 (en) Apparatus and method for managing resources using virtual ID in multiple Java application environment
US6681234B2 (en) Method and apparatus for storing long-lived objects in a virtual machine
CN113592209A (en) Model training task management method, device, terminal and storage medium
US6681381B1 (en) Arrangement for executing program code with reduced memory requirements
EP1489518B1 (en) Embedded garbage collection
EP1444572B1 (en) Method and apparatus for facilitating compact object headers
US10936483B2 (en) Hybrid garbage collection
EP1359505B1 (en) A memory management apparatus and method
JP2007094871A (en) Memory management device and memory management method
KR20070009777A (en) System and method for managing object
CN108897639A (en) Document handling method and device
CN116643778B (en) Application program optimization method and electronic equipment
CN113377723B (en) Cache file management method, device and storage medium
US8527484B2 (en) Accessing a data structure
CN110209464B (en) Nano-tube method, storage medium and management platform of virtual machine
CN115934662A (en) File sharing method and device, electronic equipment and storage medium

Legal Events

Date Code Title Description
AS Assignment

Owner name: SAMSUNG ELECTRONICS CO., LTD., KOREA, REPUBLIC OF

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:CHOI, JI-YOUNG;SONG, HYO-JUNG;PARK, JUNG-GYU;REEL/FRAME:014977/0803

Effective date: 20040116

STCB Information on status: application discontinuation

Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION