JP2007293730A - Execution method of intermediate code program and information terminal - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To apply start-up speed-up technique by a memory dump of a virtual machine to an arbitrary application to suppress size of a secondary storage device consumption. <P>SOLUTION: In this information processor 101, improper operation in time of rebooting is avoided by an input/output monitoring part 125 monitoring input/output during application execution. Effect of the dump is estimated by an input/output record 130 recording the input/output, a range of dump data is controlled according to the effect to change over a plurality of dump methods such as the dump of all the pieces of data, or the dump or the like of intermediate code for execution. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to an execution technique for a program expressed by an intermediate code, and more particularly, to a technique effective when applied to a method for shortening a program start time using a memory dump of an intermediate code execution program.

  Today, virtual machine technology such as Java (registered trademark) is applied to many embedded devices such as mobile phones. Virtual machine technology has advantages such as solving the diversity problem of hardware platforms, and is effectively used. Among embedded devices, there are many devices that are directly operated by the user, such as mobile phones, PDAs, car navigation systems, and televisions. In such a device, it is necessary to quickly start an application that realizes the function in accordance with a function selection instruction by the user. However, there are actually many applications that take about 10 seconds to start an application. Causes that take a long time to start include lack of computational power of a CPU mounted on an embedded device and heavy use of images for improving the appearance. Furthermore, the virtual machine technology performs security check processing and format change processing for pre-execution preparation at the time of program loading, and these processing have an adverse effect on startup time.

  As one of the solutions, an idea of omitting the processing at the time of program loading has been reported. Patent Document 1 dumps (outputs) executable data to secondary storage after a virtual machine prepares a class file that is a program format of Java (registered trademark) as executable data in a memory. . The next time the class file is executed, the loaded data is omitted by reading the dumped data and using it as it is. Similarly, Patent Document 2 outputs a class file to secondary storage. However, it has been devised to add security information to output data and to share the same class output data among a plurality of applications.

However, the processing that can be shortened by the above-described method is only the load time of the program, and the image load time and the initialization process that is executed after the program is loaded cannot be shortened. As a technique for shortening these processes, there is a method using a memory dump. Non-Patent Document 1 refers to an editor startup acceleration method called Emacs. Emacs is a virtual machine that executes a Lisp program, and is configured to read and execute a Lisp program group that realizes an editor function. In order to save time for starting and executing, the Lisp program group is once read and executed, and when the editor is ready to be executed, the memory image of the entire Lisp processing system is dumped. From the next time, the execution of the editor can be started only by the dump data memory loading process.
JP 2004-240965 A JP-A-2005-250835 Shinichiro Nagano, Yoshiki Hayashi University of Tokyo, Linux Conference 2002, “portable dumper: architecture-independent startup time of Emacs”

  However, even with the above technology, there remains a problem with the startup time of the virtual machine.

  First, the startup time shortening methods shown in Patent Document 1 and Patent Document 2 are limited to reducing only the program load time as described above, and are ineffective for the image load time and calculation time during the startup process. .

  Further, the speed-up method shown in Non-Patent Document 1 explicitly specifies a program to be executed before dumping, and cannot be applied to an arbitrary program. For example, in a Java (registered trademark) application for mobile phones, the activation process and the execution process other than the activation are not clearly separated by the application developer, and therefore it is not possible to appropriately determine the timing to dump.

  In both methods, the data structure to be dumped is determined as either class data or the entire processing system, and the range of dump target data can be flexibly selected according to the amount of dump data and the effect. I can't.

  Therefore, an object of the present invention is to implement an intermediate code program execution technique that can realize a startup acceleration method using a memory dump of a virtual machine for any application and control the range of dump data according to the effect. It is to provide.

  The above and other objects and novel features of the present invention will be apparent from the description of this specification and the accompanying drawings.

  Of the inventions disclosed in the present application, the outline of typical ones will be briefly described as follows.

  The present invention avoids an inappropriate operation at the time of restarting by means of monitoring input / output during application execution. In addition, the effect of dumping is estimated by means of recording input and output, and switching between multiple dumping methods, such as dumping all data and intermediate code for execution, enables fast startup while suppressing the size of the secondary storage device to be consumed. Enjoy the effects of

  Specifically, it is applied to an information terminal such as a mobile phone having a virtual machine that executes an arbitrary application, and means for monitoring the data input / output of the application simultaneously with the execution of the application, and the number and type of input / output and input / output. Means for recording the amount of output data, means for determining the validity and memory dump method of the memory dump from a fixed input / output record, means for dumping all or part of the memory image of the virtual machine executing the application, and Is used for an information terminal capable of executing a virtual machine.

  The computer resources to be recorded include files including image files, network communication paths, input interfaces from users such as key inputs, output interfaces such as screens and sound sources, time detection devices, random number generation devices, and the like.

  Among the inventions disclosed in the present application, effects obtained by typical ones will be briefly described as follows.

  According to the present invention, by recording data input / output using the above-described means, it is possible to appropriately determine the application activation processing range. For example, when the application starts screen output or when a key input from the user is accepted, it can be considered that the activation process has ended. In addition, when the input of the variable file is received, the state of the subsequent program becomes different every time the program is started. Therefore, by determining the area immediately before the input of the variable file as the activation process range, it is possible to accurately determine the activation range that can be omitted. By specifying the activation process range as described above, activation of an arbitrary application can be shortened by a memory dump without impairing the function of the application.

  In addition, if the contents of the data input are limited to the class file, the class file is dumped, and if the input data amount is large, the entire processing system is dumped. The effect of shortening the startup time can be enjoyed while suppressing the consumption size of the secondary storage device.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings. Note that components having the same function are denoted by the same reference symbols throughout the drawings for describing the embodiment, and the repetitive description thereof will be omitted.

  Hereinafter, an embodiment for realizing the present invention will be described with reference to FIGS. 1 to 7 by taking an information processing apparatus as an example of an information terminal such as a mobile phone having a virtual machine.

  FIG. 1 shows an example of the overall configuration of an information processing apparatus according to an embodiment of the present invention.

  The information processing apparatus 101 is connected to the application management server 103, the other server 104, and the like through the network 102, acquires the intermediate code 141 and the image file 142 from the application management server 103, and exchanges information with the other server 104. A service is provided to the user of the information processing apparatus 101.

  The information processing apparatus 101 includes a central processing unit 111, a primary storage device 112, a secondary storage device 113, a key input device 114, a communication device 115, a screen output device 116, and the like. When the information processing apparatus 101 is turned on, the central processing unit 111 loads a program such as the operating system 122 and the intermediate code execution program 121 to the primary storage device 112 and starts executing the program. The secondary storage device 113 has a function of retaining data even when the power is turned off, and retains a program loaded into the primary storage device 112 and data necessary for executing the program. The key input device 114 receives input from the user of the information processing apparatus 101. The communication device 115 has a function of communicating via the network 102. The screen output device 116 has a function of presenting information to the user of the information processing apparatus 101 through screen display.

  Programs such as the intermediate code execution program 121 and the operating system 122 are loaded into the primary storage device 112 and executed. The intermediate code execution program 121 executes a program expressed as a hardware-independent intermediate code. The operating system 122 manages an input / output function of a data area such as the secondary storage device 113 and an external data input / output function through the key input device 114, the communication device 115, the screen output device 116, and the like. In this embodiment, it is assumed that data input / output by the intermediate code execution program is also performed through the operating system 122.

  The intermediate code execution program 121 includes functional units such as an intermediate code load unit 123, an intermediate code execution unit 124, an input / output monitoring unit 125, and a memory dump unit 126, a working memory 127, an execution intermediate code 128, image data 129, It consists of a data part such as an input / output record 130. The intermediate code loading unit 123 reads the intermediate code 141 from the secondary storage device 113, executes conversion processing into a form suitable for execution, safety check processing, and the like, and generates an intermediate code 128 for execution. The intermediate code execution unit 124 interprets and executes the execution intermediate code 128. In the process of interpretation execution, when the intermediate code requests data input / output or resources such as a secondary storage device, the input / output monitoring unit 125 mediates the input / output request to the operating system and inputs the request content. Record in the output record 130. Also, the input / output monitoring unit 125 checks whether the intermediate code program being executed can be dumped according to these input / output requests and the contents of the input / output record 130, and when receiving a resource request that makes dumping impossible. The memory dump unit 126 is requested to perform dump processing before mediating the input / output request to the operating system. The memory dump unit 126 outputs the entire or part of the execution image of the intermediate code execution program 121 to the secondary storage device 113 as it is, and generates an intermediate code execution state dump 145. When the execution of the same program is started again after the execution of the program, the intermediate code execution state dump 145 is loaded into the primary storage device 112, so that the processing can be resumed from the same state as at the time of the memory dump.

  The secondary storage device 113 holds an intermediate code 141, an image file 142, variable data 143, an intermediate code execution program file 144, an intermediate code execution state dump 145, and the like. The intermediate code 141 is a program code obtained by receiving it from the application management server 103 and is executed by the intermediate code execution program 121. If this program is a program involving image display, the image file 142 is read, converted into displayable image data 129, and stored in the primary storage device 112. If the application wants to retain data even after the power is shut off, the data is written in the variable data 143, and the variable data 143 is read again at the time of activation. The intermediate code execution program file 144 is a program binary read on the primary storage device 112 and is executed by the central processing unit 111. Functional units such as the intermediate code loading unit 123, the intermediate code execution unit 124, the input / output monitoring unit 125, and the memory dump unit 126 are included in the intermediate code execution program file 144. The memory 127, the execution intermediate code 128, the image data 129, the input / output record 130, and the like are not included in the intermediate code execution program file 144. The intermediate code execution state dump 145 is a memory image obtained by dumping the intermediate code execution program on the primary storage device 112 as described above.

  FIG. 2 shows a data configuration example of the input / output record 130. At the start of execution of the intermediate code, the contents of the input / output record 130 are empty. When input / output occurs during the execution of intermediate code, one record is added for each input / output. Each record has data such as input / output, resource, time, type, target, and number of bytes. For example, the top record shown in this figure indicates that data input has been received from a file storing the intermediate code 141 when 0.5 seconds have elapsed since the start of program execution. Similarly, the input of the image file 142, the output to the screen output device 116, the input from the variable data 143, and the like are also recorded.

  FIG. 3 shows a first data configuration example of the intermediate code execution state dump 145. In the drawing, an example in which the intermediate code execution state dump 145 has the same data configuration as the intermediate code execution program 121 in the primary storage device 112 is shown. Therefore, it has a structure having all elements from 123 to 130. By restoring this again on the primary storage device 112, the state at the time of dumping can be restored.

  FIG. 4 shows a second data configuration example of the intermediate code execution state dump 145. In the drawing, the intermediate code execution state dump 145 shows an example in which only the execution intermediate code 128 is dumped. In this case, the only recoverable data is the execution intermediate code 128, and other data needs to be reconfigured. Although the effect of high-speed startup is relatively small, there is an advantage that the amount of data dumped is small compared to the example shown in FIG.

  An example of the processing flow in the present embodiment will be described with reference to FIGS. When the intermediate code 141 acquired from the application management server 103 is executed using the information processing apparatus 101, the procedure showing the entire processing flow of FIG.

  Process 501 is a process executed when the acquired intermediate code program is started for the first time. Load intermediate code and start execution while monitoring I / O.

  Process 502: The intermediate code execution program 121 is dumped at an appropriate timing according to the input / output monitoring result.

  Process 503: When the intermediate code program is executed again, the intermediate code execution state dump 145 is loaded into the primary storage device 112 and the execution is started. In order to utilize dump data, it is started at high speed.

  FIG. 6 shows the flow of the initial program start processing 501 in detail.

  Process 601: The intermediate code 141 is loaded by the intermediate code loading unit 123. A security check process, a process of converting the intermediate code into a format suitable for execution, and the like are performed, and the execution intermediate code 128 is generated.

  Process 602: The intermediate code execution unit 124 executes the execution intermediate code 128. In the case of implementation by an interpreter, one intermediate code instruction is acquired, and a transition is made to a routine that executes the instruction, and the process to be executed is repeated. If an instruction involving input / output is to be executed, the process proceeds to process 603.

  Process 603: The input / output to be executed is recorded by the input / output monitoring unit 125.

  Process 604: When the instructed input / output is performed, it is determined whether or not the acceleration by the memory dump cannot be applied. Various criteria can be considered. For example, there are the following judgment guidelines.

  (1) After receiving input of variable data, it is not possible to apply high speed by memory dump. This is because the state of the program is the same every time it is started before the input of variable data, but the state of the program depends on the variable data after the input of variable data.

  (2) Similarly to variable data, when receiving a key input or taking a time as an input, inconsistency occurs in the state, and hence speeding up by a memory dump cannot be applied thereafter.

  (3) When screen output is performed two or more times, the screen contents of the first drawing are erased by the second drawing, and therefore are not drawn at the time of restart. Since the first screen content to be presented to the user at the time of restart cannot be presented, application of high speed by memory dump becomes inappropriate when screen output is performed for the second time and thereafter.

  Of the above, (3) can be determined using the input / output record 130 shown in FIG.

  If the above conditions are met, a memory dump should be performed before the input / output. In that case, the process 501 is ended and the process proceeds to the process 502. Otherwise, the process proceeds to process 605.

  Process 605: Requests the operating system 122 to perform input / output processing. Returning to the process 602, the execution of the intermediate code is continued.

  FIG. 7 shows the flow of the memory dump process 502 in detail.

  Process 701: Referring to the input / output record 130, it is checked whether the data received as input from the file so far does not include an image file and is only an intermediate code. If there is only an intermediate code, the process proceeds to process 703. If the image file is included, the process proceeds to process 702.

  Process 702: The entire memory image of the intermediate code execution program 121 in the primary storage device 112 is dumped to generate an intermediate code execution state dump 145 (FIG. 3).

  Process 703: Only the execution intermediate code 128 is dumped from the memory image of the intermediate code execution program 121 in the primary storage device 112 (FIG. 4).

  The entire memory image is dumped only when a large effect including image data can be expected by the determination as shown in the processing 701. When the image data is not included, the dump range is limited to the execution intermediate code 128. As a result, efficient startup time reduction can be realized using a smaller secondary storage device. In addition to the determination method described above, an implementation method is also conceivable in which a free area of the secondary storage device or the data size of the execution intermediate code 128 is added to the determination condition.

  FIG. 8 shows the flow of the high-speed program start processing 503 in detail.

  Process 801: If the dumped data is only the execution intermediate code 128 in the memory dump process 502, the process proceeds to process 803. If the entire memory image is dumped, the process proceeds to step 802.

  Process 802: The intermediate code execution state dump 145 is loaded into the primary storage device 112.

  Process 803: The intermediate code execution program 121 is loaded into the primary storage device 112, and the execution of the intermediate code program is started.

  Process 804: The intermediate code load unit 123 reads the intermediate code program. However, instead of reading the intermediate code 141, the execution intermediate code 128 dumped in the processing 703 is read. As a result, processing applied to the intermediate code 141 becomes unnecessary, and the activation time is shortened.

  Process 805: The execution of the intermediate code is resumed.

  By creating the individual intermediate code execution state dump 145 for any intermediate code application with the above configuration and procedure, it is possible to shorten the startup time. In particular, when the entire memory image of the intermediate code execution program 121 is dumped, not only the loading of the intermediate code but also the reading time of the image file can be omitted. In addition, since the input / output of data is monitored to determine the dump timing, it is possible to ensure that any application is in the same state every time it is started, and the situation where the user cannot view the drawing result can be avoided.

  Since the method of dumping the entire memory image has a large amount of dump data, the secondary storage device is compressed. In the above-mentioned embodiment, it is possible to enjoy the effect of shortening the startup time while using the secondary storage device efficiently by using it together with the method of dumping only the intermediate code for execution and using it properly according to the situation. Become.

  As mentioned above, the invention made by the present inventor has been specifically described based on the embodiment. However, the present invention is not limited to the embodiment, and various modifications can be made without departing from the scope of the invention. Needless to say.

  The present invention is useful in an embedded device such as a mobile phone that requires high-speed activation of an intermediate code application that uses a lot of images, although it has severe restrictions on computer resources. In addition, when application of intermediate code technology to AV equipment such as a television and a hard disk recorder proceeds, the possibility of applying the present invention is high.

It is a figure which shows the example of whole structure of the information processing apparatus in one embodiment of this invention. FIG. 4 is a diagram showing an example data structure of input / output recording in one embodiment of the present invention. In one embodiment of the present invention, it is a diagram showing a first data configuration example of an intermediate code execution state dump. In one embodiment of this invention, it is a figure which shows the 2nd data structural example of intermediate code execution state dump. It is a figure which shows the whole processing flow in one embodiment of this invention. In one embodiment of the present invention, it is a figure which shows the flow of a first time program starting process in detail. FIG. 5 is a diagram showing in detail a memory dump processing flow in one embodiment of the present invention. FIG. 5 is a diagram showing in detail a flow of high-speed program start processing in an embodiment of the present invention.

Explanation of symbols

  DESCRIPTION OF SYMBOLS 101 ... Information processing apparatus, 102 ... Network, 103 ... Application management server, 104 ... Other server, 111 ... Central processing unit, 112 ... Primary storage device, 113 ... Secondary storage device, 114 ... Key input device, 115 ... Communication device 116 ... Screen output device 121 ... Intermediate code execution program 122 ... Operating system 123 ... Intermediate code loading unit 124 ... Intermediate code execution unit 125 ... Input / output monitoring unit 126 ... Memory dump unit 127 ... Work Memory: 128 ... Intermediate code for execution, 129 ... Image data, 130 ... Input / output recording, 141 ... Intermediate code, 142 ... Image file, 143 ... Variable data, 144 ... Intermediate code execution program file, 145 ... Intermediate code execution state dump.

Claims (7)

A method of executing an intermediate code program that dumps a memory image of an executing intermediate code execution program and reduces the startup time by reloading the memory image.
A method for executing an intermediate code program, characterized in that dump timing is determined using means for monitoring and recording data input / output during execution of the intermediate code program. In the execution method of the intermediate code program according to claim 1,
A method for executing an intermediate code program, comprising: determining whether or not data received as input is data that changes at each execution and determining a dump timing. In the execution method of the intermediate code program according to claim 1,
A method for executing an intermediate code program, characterized by determining whether or not data to be output on a screen overwrites drawing contents and determining a dump timing. A method of executing an intermediate code program that dumps a memory image of an executing intermediate code execution program and reduces the startup time by reloading the memory image.
A method for executing an intermediate code program, characterized in that a range of data to be dumped is determined using means for monitoring and recording data input / output during execution of the intermediate code program. In the execution method of the intermediate code program of Claim 4,
A method for executing an intermediate code program, characterized in that data received as input is classified into an intermediate code program code and other data, and a range of data to be dumped is determined in accordance with each quantity. An information terminal having a virtual machine that executes an application,
Means to monitor application data input / output simultaneously with application execution, means to record the number and type of input / output, and the amount of input / output data And a means for dumping all or part of the memory image of the virtual machine that is executing the application. The information terminal according to claim 6,
Computer resources to be recorded include files including image files, network communication paths, input interfaces from key input users, output interfaces for screens and sound sources, time detection devices, and random number generation devices. Information terminal.

Images