KR101393152B1 - Apparatus having java virturl machine and selective compile method from java bytecodes to native codes for the apparatus having java virtual machine - Google Patents

Abstract

A method for selectively compiling bytecode into native code in a device on which a Java virtual machine is mounted and a device on which the Java virtual machine is mounted is disclosed. A device equipped with the disclosed Java virtual machine includes a selection unit for selecting one or more basic blocks to be precompiled from among a plurality of basic blocks constituting a Java application before execution of the Java application, Consists of bytecode -; A compiling unit for precompiling the selected one or more basic blocks before execution of the Java application and compiling remaining basic blocks excluding the one or more basic blocks among the plurality of basic blocks into a runtime; And an execution unit that executes the precompiled one or more basic blocks and the remaining basic blocks compiled with the runtime.

Description

TECHNICAL FIELD [0001] The present invention relates to a method for selectively compiling a bytecode into native code in a device on which a Java virtual machine is mounted, and a device on which the Java virtual machine is mounted. [0002] Japanese Patent Application Laid- MACHINE}

Embodiments of the present invention relate to a device equipped with a Java virtual machine capable of improving the satisfaction of a response time to user input by reducing a system overhead incurred when using a Java virtual machine, and a compiling method therefor.

A Java application is distributed to a target system (for example, a mobile device) in the form of an executable file composed of Bytecode, and is executed by a Java Virtual Machine mounted on the target system. The target system executes the Java application by interpreting the received bytecode using the Java virtual machine or by translating (compiling) the native code into a native code, and the compilation is performed in a basic block unit composed of one or more bytecodes .

In this regard, the conventional method of compiling byte code is a method of AOT (Ahead OF Time) for translating the entire bytecode into native code suitable for the target system before execution of the Java application, that is, at the time of installation of the first Java application, Some of the bytecodes retrieved through profiling are translated into native code that matches the target system in real-time (Runtime), but the translated native code is kept in the cache and used in JIT Just In Time) method.

However, in the case of the AOT method, all translated native codes must be stored in the system, and sufficient main memory must be secured, which causes a problem of spatial overhead. In the case of the JIT method, the bytecode to be compiled must be searched (profiled) in real time, and the profiled byte code must be compiled in real time, resulting in a time overhead problem .

In order to solve the problems of the prior art as described above, in the present invention, a system equipped with a Java virtual machine capable of reducing the system overhead incurred in using the Java virtual machine, And a pre-compilation method therefor.

Other objects of the invention will be apparent to those skilled in the art from the following examples.

In order to achieve the above object, according to a preferred embodiment of the present invention, among a plurality of basic blocks constituting a Java application, selection of one or more basic blocks to be pre-compiled before execution of the Java application - the basic block consists of one or more bytecodes; A compiling unit for precompiling the selected one or more basic blocks before execution of the Java application and compiling remaining basic blocks excluding the one or more basic blocks among the plurality of basic blocks into a runtime; And an execution unit that executes the pre-compiled one or more basic blocks and the remaining basic blocks compiled with the runtime.

In accordance with another embodiment of the present invention, there is provided a method for executing a Java application, the method comprising: selecting one or more basic blocks to be precompiled before execution of the Java application from among a plurality of basic blocks constituting a Java application, -; And precompiling the selected one or more basic blocks before execution of the Java application and compiling the remaining basic blocks excluding the one or more basic blocks among the plurality of basic blocks at runtime. A method of compiling in a device is provided.

According to the present invention, there is an advantage in that the system overhead occurring when the Java virtual machine is used is reduced, and the satisfaction of the response time with respect to the user input is improved.

1 to 3 are views for explaining the concept of execution of a Java application in an apparatus on which a Java virtual machine is installed according to an embodiment of the present invention.
FIG. 4 is a diagram showing a schematic configuration of an apparatus mounted with a Java virtual machine according to an embodiment of the present invention.
5 is a diagram illustrating a concept of using a precompiled shared basic block between parent and child tasks.
FIG. 6 is a diagram illustrating an overall flow of a compiling method in an apparatus mounted with a Java virtual machine according to an embodiment of the present invention.

While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that the invention is not intended to be limited to the particular embodiments, but includes all modifications, equivalents, and alternatives falling within the spirit and scope of the invention. Like reference numerals are used for like elements in describing each drawing.

Hereinafter, embodiments according to the present invention will be described in detail with reference to the accompanying drawings.

1 to 3 are views for explaining the concept of execution of a Java application in an apparatus on which a Java virtual machine is installed according to an embodiment of the present invention.

Referring to FIGS. 1 to 3, a Java application is divided into job (Job) units. Here, a job means a series of processes executed corresponding to one user input (UE, User Event), and the execution time (e) of a job is defined as | user input time - final end time | of a series of processes .

In order to satisfy the user's request, it is preferable that each of the plurality of jobs constituting the Java application is completed within a predetermined deadline (D). If the job is completed before the deadline, the slack time (s) occurs. Therefore, if the allowance is greater than 0, the deadline is met, and if the allowance is less than 0, the deadline is missed.

On the other hand, each of the plurality of jobs may include one or two or more task instances (Task Instance) as shown in FIGS. In particular, one job may include only one task instance as shown in FIG. 1, and may include two or more task instances that are executed serially in a chain form as shown in FIG. 2 (i.e., one (I.e., when the execution of the task instance is terminated, the next task instance is executed sequentially), or may include two or more task instances executed in serial / parallel as shown in FIG. 3 Divided into sub-chains, executed, and then combined into one chain again). Each task instance is performed based on execution of at least one basic block.

A device equipped with a Java virtual machine according to an embodiment of the present invention may pre-compile (pre-compile) some basic blocks among a plurality of basic blocks constituting the Java application, )), Compiles some of the basic blocks into a runtime, executes a basic block (including pre-compilation and run-time compilation), or interprets bytecodes.

Hereinafter, referring to FIG. 4, the operation of an apparatus mounted with a Java virtual machine according to an embodiment of the present invention will be described in detail.

FIG. 4 is a diagram showing a schematic configuration of an apparatus mounted with a Java virtual machine according to an embodiment of the present invention.

Referring to FIG. 4, an apparatus 400 including a Java virtual machine according to an exemplary embodiment of the present invention includes a selector 410, a compiler 420, a storage 430, and an execution unit 440 do. Hereinafter, the function of each component will be described in detail.

The selection unit 410 selects one or more basic blocks to be precompiled before execution of the Java application from among a plurality of basic blocks constituting the Java application.

According to an embodiment of the present invention, the selector 410 selects one or more basic blocks to be pre-compiled in consideration of the degree of reduction of the execution time of the Java application by the pre-compilation of the basic block and the execution frequency of the basic block . This will be described in more detail below.

The compiling unit 420 compiles a plurality of basic blocks (i.e., translates the bytecodes constituting a plurality of basic blocks into native codes). More specifically, the compiling unit 420 precompiles one or more basic blocks selected by the selection unit 410 before execution of the Java application, and executes the remaining basic blocks excluding the selected one or more basic blocks among the plurality of basic blocks, .

The pre-compiled one or more basic blocks are stored in the storage unit 430. As an example, one or more basic blocks precompiled may be classified into task instances and stored in the storage unit 430. [ That is, a certain area of the storage unit 430 may be allocated to each task instance, and one or more basic blocks precompiled for the specific task instance may be allocated to the area of the storage unit 430 corresponding to the corresponding task instance Lt; / RTI > The area of the storage unit 430 may be a logically divided area or a physically divided area.

The execution unit 440 executes the compiled basic block to execute the corresponding Java application. Here, the compiled basic block includes both one or more basic blocks precompiled and the remaining basic blocks compiled into the runtime.

As described above, the device 400 equipped with the Java virtual machine according to the embodiment of the present invention does not precompile all the basic blocks (bytecodes) constituting the Java application, Compared to the conventional compiling method according to the AOT (since the amount of the precompiled basic blocks is small), it is possible to reduce the spatial overhead, and the compilation method according to the conventional JIT There is an advantage in that the time overhead can be lowered when comparing (since only some basic blocks are compiled at runtime).

Hereinafter, the operation of the selection unit 410 for selecting at least one basic block to be pre-compiled will be described in more detail.

According to an embodiment of the present invention, the selector 410 calculates a utility value for each of a plurality of basic blocks, assigns priority to each of the plurality of basic blocks in proportion to the calculated utility value, To select one or more basic blocks to be pre-compiled.

The utility value is a value reflecting the degree of reduction of the execution time of the Java application by the precompile of the basic block and the execution frequency of the basic block. The utility value of the specific basic block is higher, the priority of the corresponding basic block becomes higher , The higher the priority, the more likely it is to be selected as the basic block to be precompiled.

More specifically, if the Deadline Meet Probability (DMP), which is the ratio of jobs whose execution is completed without violating deadlines among a plurality of jobs, is less than or equal to a predetermined threshold probability It is possible to select one or more basic blocks to be precompiled as the higher-order n (higher or higher integer) basic blocks having higher priority (see Equation 1 below). In this case, the deadline satisfaction probability increases in proportion to the number of basic blocks to be precompiled, and n may be a minimum integer such that the deadline satisfaction probability is equal to or greater than the threshold probability. That is, when the Deadline Meet Probability (DMP) is smaller than a preset threshold probability, the selector 410 increases the number of the basic blocks to be precompiled in order of decreasing priority, And selects a set of basic blocks.

Where N is the total number of jobs, Prob ^th is the threshold probability, and s _i is the free time of the ith job, respectively.

Then, the pre-In more detail about the utility values used for selection of the basic block, the utility value for the l-th basic block of the plurality of basic blocks (Interpretation Mode) yi l-th basic block interpretation mode compiled A ratio of a second required time which is a time required when the l < th > basic block is executed according to a native mode, and a ratio of a plurality of jobs May be defined by at least one of the execution rate parameters associated with the rate at which the lth basic block is executed. As an example, the utility value for the 1 < st > basic block may be expressed as Equation 2 below.

Here, Utility (BB _l) is the utility value for the l-th basic block _{(BB l), IE (BB} l) is the first time, NE (BB _l) is the second time, COC (BB _l) is l Lt; th > basic block.

More specifically, l execution rate parameter for the second basic block is, if the number of the l-th basic block in the job rate for the job-performing at least one prescribed threshold percentage is less than set, is set to 0, the l-th among the plurality of job When the ratio of the job that has executed the basic block at least once is equal to or greater than a predetermined threshold ratio, it can be expressed as Equation (3) below.

Here, COC (BB _l) is the l-th basic block (BB _l) is associated with the execution rate parameter, OC _j (BB _l) is the l-th basic when the l-th basic block to be executed in the j-th job in the plurality of job MIN () denotes a function to select a minimum value, and AVG () denotes a function to calculate an average value.

On the other hand, there may be two or more basic blocks having the same utility value. In this case, the selector 410 may give a higher priority to a basic block having a small standard deviation of OC _j (BB _l ). This is because when a job that executes a specific basic block executes a corresponding basic block at a uniform number of times, the corresponding basic block is more pre-compiled.

In the above description, the selecting unit 410 selects one or more basic blocks to be precompiled. When the selecting unit 410 includes only one task instance (the example of FIG. 1) , A case including more than one task instance serially executed in the form of a chain (example of FIG. 2), and a case including two or more task instances executed serially in parallel (the example of FIG. 3).

That is, when the job includes only one task instance, the operation of the selector 410 can be performed because there is no boundary of the basic block due to the difference of the task instances. If the job includes two or more task instances The operation of the selector 410 as described above can be performed by ignoring the boundary of the basic block by the task instance and assuming that all the task instances in one job are one task instance.

In a Java application, a specific task is executed by duplicating a container task. Here, the container task becomes the parent task for the specific task, and the specific task becomes the child task of the container task. In this case, a plurality of class libraries are pre-loaded in the parent task (or container task).

Therefore, the task instance (parent task instance) belonging to the parent task and the child task instance belonging to the child task can share the same one or more compiled basic blocks.

In this case, of the shared one or more compiled basic blocks, the basic block selected to precompile the child task instance is already precompiled and shared when the parent task instance is executed. Therefore, when executing the child task instance, It is possible to utilize an already compiled basic block without precompiling the basic block.

In other words, if the shared basic block selected as the basic block to be precompiled is precompiled, it is stored in the area of the storage 430 allocated for the parent task instance and stored in the storage unit 430). In the area of the storage unit 430 allocated to the child task instance, pre-compiled basic blocks belonging to the child task instance are not shared except for the precompiled shared basic block Stored). In this case, since the parent task instance is replicated and executed at the time of execution of the child task instance, the precompiled shared basic block can be executed even when the child task instance is executed. FIG. 5 illustrates the concept of using precompiled shared basic blocks between such parent-child task instances.

In summary, one or more task instances belonging to one job belong to one of the parent task instance and the child task instance, and two or more pre-compiled one or more basic blocks, The basic block shared by the task instance is stored in an area on the storage unit 430 corresponding to the parent task instance and may not be stored in the area on the storage unit 430 corresponding to the child task instance.

In addition, according to an embodiment of the present invention, the number of child task instances for one parent task instance may be two or more, in which case the shared basic block may be a basic block shared by both the parent task instance and two or more child task instances have. However, if there is a size limitation on the area on the storage unit 430 allocated to the parent task instance, all of the precompiled shared basic blocks may not be stored in the area on the storage unit 430 allocated to the parent task instance have. Therefore, in this case, it is possible to set a priority for a shared basic block, and store only a part of shared basic blocks having a high priority in an area on the storage unit 430 allocated to the parent task instance Stored in the area on storage 430 allocated to the child task instance).

The selection of the priority among the shared basic blocks can be performed by applying the weight values to the child task instances while using the utility value, which is a standard used for selecting the basic block to be precompiled, as it is. Here, when a plurality of task instances chain present, La COC a COC _i (BB _l) of the l-th basic block for each task instance chain that weight is given home by, and task instances chain i, and the weights w _i d and calculated, then the l COC of the second basic block in a plurality of task instances chain defined La _{(BB l) COC, COC (} BB l) through their sum is multiplied by a weight and COC _i (BB _l) of the task instance chain (See Equation 4 below). This makes it possible to reduce the overall system memory usage while allowing each chain of task instances to satisfy the condition according to Equation (1).

FIG. 6 is a diagram illustrating an overall flow of a compiling method in an apparatus mounted with a Java virtual machine according to an embodiment of the present invention. Hereinafter, a process performed in each step will be described (each step can be performed by a processor in a device on which the Java virtual machine is installed).

First, in step S610, one or more basic blocks to be pre-compiled are selected from a plurality of basic blocks constituting a Java application before execution of the Java application.

According to an embodiment of the present invention, in step S610, one or more basic blocks may be selected in consideration of the degree of reduction of the execution time of the Java application by precompiling the basic block and the execution frequency of the basic block.

In step S620, the selected one or more basic blocks are precompiled before execution of the Java application, and the remaining basic blocks excluding one or more of the plurality of basic blocks are compiled into the runtime.

The embodiments of the compiling method in the device mounted with the Java virtual machine according to the present invention have been described and the configuration related to the device 400 mounted with the Java virtual machine described in FIG. Applicable. Hereinafter, a detailed description will be omitted.

In addition, embodiments of the present invention may be implemented in the form of program instructions that can be executed through various computer means and recorded on a computer readable medium. The computer-readable medium may include program instructions, data files, data structures, and the like, alone or in combination. The program instructions recorded on the medium may be those specially designed and constructed for the present invention or may be available to those skilled in the art of computer software. Examples of computer-readable media include magnetic media such as hard disks, floppy disks, and magnetic tape; optical media such as CD-ROMs and DVDs; magnetic media such as floppy disks; Examples of program instructions, such as magneto-optical and ROM, RAM, flash memory and the like, can be executed by a computer using an interpreter or the like, as well as machine code, Includes a high-level language code. The hardware devices described above may be configured to operate as one or more software modules to perform operations of one embodiment of the present invention, and vice versa.

As described above, the present invention has been described with reference to particular embodiments, such as specific elements, and limited embodiments and drawings. However, it should be understood that the present invention is not limited to the above- Various modifications and variations may be made thereto by those skilled in the art to which the present invention pertains. Accordingly, the spirit of the present invention should not be construed as being limited to the embodiments described, and all of the equivalents or equivalents of the claims, as well as the following claims, belong to the scope of the present invention .

Claims (13)

A selection unit for selecting at least one basic block to be pre-compiled among a plurality of basic blocks constituting a Java application before execution of the Java application, the basic block being composed of one or more bytecodes;
A compiling unit for precompiling the selected one or more basic blocks before execution of the Java application and compiling remaining basic blocks excluding the one or more basic blocks among the plurality of basic blocks into a runtime; And
And an execution unit that executes the pre-compiled one or more basic blocks and the remaining basic blocks compiled with the runtime. The method according to claim 1,
Wherein the selection unit selects the at least one basic block in consideration of the degree of reduction of the execution time of the Java application by the precompilation of the basic block and the execution frequency of the basic block. The method according to claim 1,
Wherein the Java application includes a plurality of jobs including one or more task instances executed in response to a single user input, and the one or more task instances are executed in serial or serial-parallel manner. Mounted device. The method of claim 3,
Wherein the selector calculates a utility value for each of the plurality of basic blocks, assigns priority to each of the plurality of basic blocks to be proportional to the calculated utility value, Select one or more basic blocks,
Utility value for the l-th basic block of the plurality of the basic blocks to which the l-th basic block is an inter-free time of the first time and the l-th basic block takes when executed by the presentation mode running in native mode If in the time of rain (ratio), and a plurality of jobs wherein the second amount of time required for a virtual machine, characterized in that which is defined by at least one of the running rate parameter associated with said l-th basic block execution rate Mounted device. 5. The method of claim 4,
Wherein the Java application comprises a plurality of jobs including one or more task instances executed in response to one user input,
Wherein the selection unit selects a priority block having a highest priority from a basic block having the highest priority to a predetermined priority probability when the deadline is not violated among the plurality of jobs, (N is an integer equal to or greater than 1) basic blocks in descending order from the maximum basic block as the at least one basic block to be precompiled, . 6. The method of claim 5,
Wherein the deadline satisfaction probability is increased in proportion to the number of basic blocks to be precompiled, and n is a minimum integer such that the deadline satisfaction probability is equal to or greater than the threshold probability. . 5. The method of claim 4,
Wherein the utility value for the 1 < st > basic block is expressed by the following equation.

Here, the Utility (BB _l) is the utility value, the IE (BB _l) is the first time, the NE (BB _l) for the l-th basic block (BB _l) is the second time, the COC also (BB _l) is meant the ratio, respectively the running parameters of the l-th basic block. 5. The method of claim 4,
If there is more than the l-th basic block in the job number of the ratio of the job-performing at least one prescribed threshold rate is set, the execution rate parameter is expressed by mathematical formula below,
Is less than the threshold from among a plurality of the job is the l-th basic block a proportion of the jobs executed at least once a predetermined ratio, the apparatus is equipped with a Java virtual machine, it characterized in that the execution rate parameter is set to zero.

Here, the COC (BB _l) is that the l-th basic block (BB _l) this parameter, the OC _j (BB _l) is the l-th basic block associated with the execution rate in a number of the job to be executed in the j-th job l the number of executions, the MIN () of the second basic block is also a function of selecting the minimum value, the AVG () represents a function for calculating a mean value each time. delete The method of claim 3,
Wherein the apparatus on which the virtual machine is mounted further includes a storage unit for storing the pre-compiled one or more basic blocks,
Wherein the pre-compiled one or more basic blocks are classified into task instances and stored in a storage unit. 11. The method of claim 10,
Wherein the one or more task instances belong to one of a parent task instance and a child task instance and are shared by two or more task instances in which the relationship of the parent task instance-child task instance among the precompiled one or more basic blocks is established Wherein the basic block is stored in an area on the storage unit corresponding to the parent task instance, and is not stored in an area on the storage unit corresponding to the child task instance. Selecting one or more basic blocks to be precompiled prior to execution of the Java application from among a plurality of basic blocks constituting a Java application, the basic block consisting of one or more bytecodes; And
Compiling the selected one or more basic blocks before execution of the Java application and compiling remaining basic blocks excluding the one or more basic blocks among the plurality of basic blocks into the runtime, How to compile on a machine with a machine. 13. The method of claim 12,
Wherein the selecting step selects the at least one basic block in consideration of the degree of reduction of the execution time of the Java application by precompiling the basic block and the execution frequency of the basic block. How to compile in.

Images