JP2003241967A - Program execution device, its method and program executed therein - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a program execution device and its method capable of relaxing a processing load imposed on memory management in executing class files by an object-oriented language and to provide a program executed therein. <P>SOLUTION: A memory part 20 is composed of memory regions α and β. A memory allocating operation detection part 11 detects a memory allocating operation command from the class files 500. A memory allocation selection part 12 selects the memory region α or β to be allocated to the memory allocation command in its execution. A memory allocation information storage part 13 memorizes the selection result as memory allocation information. A command execution part 14 executes a program described in the class files 500. A memory allocation execution part 15 secures the memory region α or β in response to the memory allocating operation command based on the memory allocation information, and returns control to the execution part 14. <P>COPYRIGHT: (C)2003,JPO

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program execution device and method for executing a class file in an object-oriented language, and a program executed therein. More specifically, the present invention relates to a dynamic memory for executing the class file. A technique for supporting allocation of a region.

[0002]

2. Description of the Related Art In recent years, with the enormous growth of software, attention has been focused on programming languages that are excellent in reusability, extensibility, and productivity of programs. As a typical example, in order to improve reusability and extensibility of a program, an object-oriented design method is introduced in which the program is decomposed into files called class files for designing.

On the other hand, for memory management, which is a heavy burden in program development, a method has been proposed in which the program execution device automatically performs the memory management to reduce the burden on the programmer. Specifically, a method called garbage collection has been put into practical use, in which the program execution device manages all the memory areas that are reserved and used during program execution, and automatically detects and releases used memory areas. . This garbage collection is used for dynamic storage area management, and determines whether the data secured in the memory area is in use or used, and the used area is bundled to reuse the memory area. Is executed regularly.

The Java (R) language, which is one of the object-oriented languages in which the above-mentioned object-oriented design method is used, is an object-oriented language developed by Sun Microsystems and does not depend on hardware and software platforms. It has the feature that the same program can be executed. Also, J
In ava (R), the above-mentioned garbage collection support is specified at the level of the language specification. Therefore,
In the Java (R) processing system, the programmer does not need to write an instruction to release the used memory area on the program side, and the burden on the memory management, which is generally troublesome processing, is reduced. Therefore, highly productive program development is possible.

[0005]

However, the Java (R) processing system provided with a program execution device adopting garbage collection reduces the burden on the programmer, but has the disadvantage that the processing load on the program execution device increases. have. That is, since a lot of time is required to execute the garbage collection, the program execution device spends the execution time of many programs on the garbage collection process, which reduces the execution speed of the program itself. Such processing is particularly noticeable in the execution of programs in which memory areas are frequently allocated and released.

On the other hand, a technique for reducing the processing load on the memory management of the program execution device is disclosed in Japanese Patent Laid-Open No.
000-35893 and JP 2000-330.
No. 793 is disclosed.

In the technique disclosed in Japanese Patent Laid-Open No. 2000-35893, a class is initialized by generating a "special method" including an initialization method of a Java (R) program. The technique detects dynamic memory allocation operations performed for initialization by a preloader that joins class files and performs preliminary processing that facilitates execution of the class files, and statically initializes these. By replacing with, the amount of code to be executed by the program execution device is reduced and the amount of memory used for initialization is saved.

However, the above-mentioned Japanese Patent Laid-Open No. 2000-3
In the technique disclosed in Japanese Patent No. 5893, the target is only the initialization process for the "special method", and the program execution device is used for dynamic memory allocation other than the initialization process. The processing load related to memory management is not reduced.

On the other hand, the technique disclosed in Japanese Unexamined Patent Publication No. 2000-330793 discloses a process of compiling the source code of a program described in C language, C ++ language, Java (R) language, etc. into an object code. By extracting the dynamic memory allocation operation instruction included in the source code and analyzing the live range of the data allocated by the operation instruction, it is possible to reduce the load on dynamic memory management during program execution. It rewrites the object code.

However, in the Java (R) processing system, the Java (R) source code is converted to Java.
(R) Java obtained by compiling with a compiler
The program is generally distributed in the form of (R) class file. That is, the above-mentioned Japanese Patent Laid-Open No. 2000-330.
In the technique disclosed in Japanese Patent No. 793, since the target is the source code, it cannot be applied to a general Java (R) processing system distributed in such a class file format. Further, in this technique, method calling processing (inter-method communication) is frequently performed in the above object-oriented language, but in general, live range analysis processing is difficult to perform in a range beyond methods. There was a problem that the range was limited.

Therefore, an object of the present invention is to provide a program execution device and method for reducing the processing load on the memory management when executing a class file in an object-oriented language, and a program executed there. is there.

[0012]

Means for Solving the Problems and Effects of the Invention In order to achieve the above object, the present invention has the following features. A first aspect of the present invention is a program execution device that executes a class file obtained by compiling a program in an object-oriented language with a predetermined compiler, and is described in a memory divided into a plurality of areas and a class file. A memory allocation operation detection unit for detecting the memory allocation operation instruction, and the memory allocation operation instruction detected by the memory allocation operation detection unit is analyzed, and the memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction. A memory allocation selecting unit, a memory allocation information storage unit that stores memory allocation information that associates the memory area selected by the memory allocation selecting unit with a memory allocation operation command, an instruction execution unit that executes a class file, and an instruction In the execution section Scan time of execution memory allocation operation instructions in the file to, and a memory allocation execution section for instructing the memory region corresponding to the memory allocation operation command based on the memory allocation information to the instruction execution unit.

According to the first aspect of the present invention, it is possible to reduce the load on the dynamic management of the memory area by the program when the program of the class file is executed, and it is possible to improve the execution efficiency of the program. .

A second invention is according to the first invention, wherein the memory allocation selecting section automatically detects a used memory area and releases the processing related to the memory allocation operation instruction. The memory area to be allocated at the time of execution of the class file is selected by distinguishing between the target of the garbage collection processing and the target of the garbage collection processing.

According to the second aspect of the present invention, data that always interferes with the garbage collection process, such as data that continues to exist until the end of execution, can be excluded from the target of the garbage collection process. Therefore, since it is possible to focus only on the garbage collection processing which is essentially necessary, it is possible to reduce the load on the garbage collection processing and improve the execution efficiency of the program.

A third invention is an invention according to the first invention, wherein the memory allocation selecting unit calculates a live range as a period during which a process related to the memory allocation operation instruction is continuously executed, A memory area to be allocated when the class file is executed is selected based on the live range.

According to the third aspect of the invention, a memory allocation operation for data whose life span is very short is detected, and this data is allocated to a temporary memory area dedicated to data, so that data with a short life is frequently generated. Since it is possible to prevent the memory area from being disturbed due to the disappearance and the load on the execution of the garbage collection process, it is possible to improve the execution efficiency of the program.

A fourth invention is an invention according to the first invention, and includes an embedded class file storage unit which stores in advance an embedded class file which is a class library in the execution environment and which is composed of at least one fixed class file. , Further includes a selection assistant information storage unit that stores selection assistant information indicating a criterion for selecting a memory area to be allocated at the time of execution of the class file by analyzing the embedded class file in advance, and memory allocation selection The section selects a memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction detected by the memory allocation operation detection section, based on the selection assistant information stored in the selection assistant information storage section.

According to the fourth aspect of the invention, the analysis information of the class file required by the memory allocation selecting step is previously stored in the embedded class file, which is a class file whose content is fixed no matter which program is executed. It can be given as selection assistance information. Therefore, it is possible to reduce the processing load on the memory allocation selecting step. Furthermore, by describing advanced selection assistant information that is difficult to analyze only with the information described in the class file, such as survival information of data across methods, a more efficient memory can be executed during program execution. It becomes possible to make assignments.

A fifth aspect of the invention is an invention dependent on the fourth aspect of the invention, wherein the selection assistant information describes a criterion for selecting a memory area to which an instance of the built-in class is allocated for each built-in class. It is characterized by

According to the fifth invention, it is difficult to analyze only the information described in the class file, and it is possible to describe the method of allocating the memory area based on the behavioral characteristics of the entire class. It becomes possible to perform more efficient memory allocation when executing.

A sixth invention is according to the fourth invention, wherein the selection assistant information is assigned to a memory allocation operation instruction executed by the embedded class file when the memory allocation operation instruction is executed. It is characterized in that criteria for selecting a memory area to be written are described.

According to the sixth aspect of the invention, the selection assistant information that is difficult to analyze only with the information described in the class file, such as survival of data across methods and behavior of global variables, is used as a built-in class Since it is possible to describe each memory allocation operation instruction of the file, it becomes possible to perform more efficient memory allocation when the program is executed.

A seventh invention is an invention according to the sixth invention, wherein the selection assistance information is linked with a selection result of the memory area allocated to the instance of the built-in class executing the memory allocation operation instruction. , A criterion for selecting a memory area to be allocated by the memory allocation operation command is described.

According to the seventh aspect of the present invention, when the generation / disappearance of the data to which the memory area is allocated in the instance method of the built-in class is completely linked to the generation / disappearance of the instance, the allocation of the memory area for this data is performed. As a method, for example, by allocating the data area so that it is adjacent to the data area allocated to the instance, it is possible to prevent the memory area from being disturbed due to the generation and disappearance of the instance, which may impose a load on the execution of the garbage collection process. It is possible to improve the execution efficiency of.

An eighth invention is an invention according to the third invention, and includes an embedded class file storage unit which stores in advance an embedded class file which is a class library in the execution environment and which is constituted by at least one fixed class file. , Further includes a selection assistant information storage unit that stores selection assistant information indicating a criterion for selecting a memory area to be allocated at the time of execution of the class file by analyzing the embedded class file in advance, and the selection assistant information. Describes for each method of the built-in class file the effect that the data generated by the execution of the method has on the live range in which it is continuously used. Based on the stored selection assistant information,
A memory area to be allocated when the class file is executed is selected by the memory allocation operation instruction detected by the memory allocation operation detection unit.

According to the eighth invention, it is difficult to analyze only the information described in the class file. It is easy to analyze the live range of data across methods, that is, between method calls. Based on the analysis result, more efficient memory allocation can be performed when the program is executed.

A ninth aspect of the invention is an aspect dependent on the eighth aspect of the invention, wherein the influence of the selection assistant information on the live range of the data generated by the execution of the method is passed to the method of the embedded class file. Described depending on the runtime type of the argument, the memory allocation selection unit analyzes the type of the instance of the built-in class, and by referring to the selection assistant information based on the runtime type of the instance,
It is characterized in that the memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction detected by the memory allocation operation detection unit.

According to the ninth aspect, when a method of a built-in class is called, when a reference to the instance is passed as an argument of the method, the runtime type of the instance (dynamic binding) Even in a situation where the operation of the method changes due to, the appropriate selection assistant information can be described based on the type at the time of execution. Therefore, if the runtime type (class) of the instance passed as a reference to the argument of the method is uniquely determined by the type analysis performed in the memory allocation selection step, describe the operation of the method in more detail. Since it is possible to apply the selected selection assistant information, it is possible to more efficiently allocate the memory area.

The tenth invention is an invention subordinate to the fourth invention, wherein the selection assistance information is java. Lang. S
It is characterized in that criteria for selecting a memory area to be allocated at the time of execution of a class file by a memory allocation operation instruction are described for the string class.

According to the tenth invention, general Java
(R) A java. Lang. Str
Instances of the ing class can be allocated to different memory areas as needed, so it is possible to prevent the memory area from being disturbed by the creation and disappearance of these instances, and to prevent garbage collection from being executed. It is possible to improve efficiency.

An eleventh invention is an invention dependent on the fourth invention, wherein the selection assistance information is java. Lang. S
For the stringBuffer class, the criteria for selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction are described.

According to the eleventh invention, a general Java
(R) A java. Lang. Str
Instances of the ingBuffer class can be allocated to different memory areas as needed, so it is possible to prevent the memory area from being disturbed by the creation and disappearance of these instances, and to prevent the garbage collection from being executed. It is possible to improve efficiency.

A twelfth invention is according to the first invention, wherein the memory allocation selecting section is a memory area to be allocated when the class file is executed by the memory allocation operation instruction detected by the memory allocation operation detecting section. The feature is that the process of selecting is performed when the class file is loaded.

According to the twelfth aspect of the invention, since the processing in the memory allocation selecting step does not occur for unnecessary class files, the load in the memory allocation selecting step can be minimized. Furthermore, since the memory allocation selection step can be performed at the same time as the verification processing that is performed when the class file is loaded, the type information and other information generated during the verification process can be used as is for memory allocation selection. You can

A thirteenth invention is an invention according to the first invention, wherein the memory allocation selecting section is a memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction detected by the memory allocation operation detecting section. Is selected every time the method including the memory allocation operation instruction is executed for the first time or every predetermined number of times.

According to the thirteenth aspect of the invention, the memory area is selected by the memory allocation selecting step when the method is called the number of times exceeding a certain threshold, for example, the tenth time, so that the method is frequently called. That is, it is possible to select only the memory allocation of the portion that largely contributes to the execution performance of the program. Therefore, it is possible to more efficiently allocate the memory area with a lower load of the memory allocation selecting step.

A fourteenth invention is a program execution method for executing a class file obtained by compiling a program in an object-oriented language by a predetermined compiler, using a memory divided into a plurality of areas, A memory allocation operation detection step of detecting a memory allocation operation instruction described in the class file, and a memory allocation operation instruction detected by the memory allocation operation detection step should be analyzed and allocated by the memory allocation operation instruction when the class file is executed. A memory allocation selecting step of selecting a memory area; a memory allocation information storing step of storing memory allocation information associating the memory area selected by the memory allocation selecting step with a memory allocation operation instruction; Instruction execution step for executing a file, and at the time of executing the memory allocation operation instruction in the class file in the instruction execution step, a memory area corresponding to the memory allocation operation instruction is instructed to the instruction execution step based on the memory allocation information. A memory allocation execution step.

A fifteenth invention is an invention dependent on the fourteenth invention, wherein the memory allocation selecting step automatically detects a used memory area and releases the processing related to the memory allocation operation instruction. The memory area to be allocated at the time of execution of the class file is selected by distinguishing between the target of the garbage collection processing and the target of the garbage collection processing.

A sixteenth invention is an invention according to the fourteenth invention, wherein the memory allocation selecting step calculates a live range as a period during which a process related to the memory allocation operation instruction is continuously executed, A memory area to be allocated when the class file is executed is selected based on the live range.

A seventeenth invention is an invention according to the fourteenth invention, and includes a built-in class file storing step for pre-storing a built-in class file which is a class library in the execution environment and which is composed of at least one fixed class file. Further comprising a selection assistant information storing step of storing selection assistant information indicating a criterion for selecting a memory area to be allocated at the time of execution of the class file by analyzing the embedded class file in advance, and selecting the memory allocation. The step selects a memory area to be allocated at the time of execution of the class file by the memory allocation operation command detected by the memory allocation operation detection step, based on the selection assistant information stored in the selection assistant information storage step.

An eighteenth invention is an invention subordinate to the seventeenth invention, wherein the selection assistant information describes a criterion for selecting a memory area to which an instance of the built-in class is allocated for each built-in class. It is characterized by

A nineteenth invention is an invention according to the seventeenth invention, wherein the selection assistant information is for a memory allocation operation instruction executed by an embedded class file,
It is characterized in that criteria for selecting a memory area to be allocated at the time of executing the memory allocation operation instruction are described.

A twentieth aspect of the invention is an invention dependent on the nineteenth aspect of the invention, wherein the selection assistance information is linked to the selection result of the memory area allocated to the instance of the built-in class executing the memory allocation operation instruction. , A criterion for selecting a memory area to be allocated by the memory allocation operation command is described.

A twenty-first invention is an invention subordinate to the sixteenth invention, and includes an embedded class file storing step for pre-storing an embedded class file which is a class library in the execution environment and which is constituted by at least one fixed class file. Further comprising a selection assistant information storage step of storing selection assistant information indicating a criterion for selecting a memory area to be allocated at the time of execution of the class file by analyzing the embedded class file in advance, the selection assistant information. Describes for each method of the built-in class file the effect that the data generated by the execution of the method has on the live range in which it is continuously used. Memorized selection assistant information Based on, selects the memory area to be allocated when the class file is executed by the memory allocation operation detection step by the detected memory allocation operation instruction.

A twenty-second aspect of the invention is an invention dependent on the twenty-first aspect of the invention, and in the selection assistant information, the influence on the live range of the data generated by the execution of the method is passed to the method of the built-in class file. Described depending on the runtime type of the argument, the memory allocation selection step is
The memory to be allocated at the time of execution of the class file by the memory allocation operation instruction detected by the memory allocation operation detection step by analyzing the instance type of the built-in class and referencing the selection assistance information based on the runtime type of the instance It is characterized by selecting a region.

The twenty-third invention is an invention subordinate to the seventeenth invention, wherein the selection assistance information is java. Lang.
For the String class, the criteria for selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction are described.

A twenty-fourth invention is an invention dependent on the seventeenth invention, wherein the selection assistance information is java. Lang.
For the StringBuffer class, the criteria for selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction are described.

A twenty-fifth invention is according to the fourteenth invention, wherein the memory allocation selecting step is a memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction detected by the memory allocation operation detecting step. The feature is that the process of selecting is performed when the class file is loaded.

A twenty-sixth invention is an invention according to the fourteenth invention, wherein the memory allocation selecting step is a memory area to be allocated at the time of execution of the class file by the memory allocation operating instruction detected by the memory allocation operation detecting step. Is selected every time the method including the memory allocation operation instruction is executed for the first time or every predetermined number of times.

The twenty-seventh invention is a program executed by a computer which processes a class file obtained by compiling a program in an object-oriented language by a predetermined compiler, using a memory divided into a plurality of areas. The memory allocation operation detection step of detecting the memory allocation operation instruction described in the class file, and the memory allocation operation instruction detected by the memory allocation operation detection step is analyzed, and when the class file is executed by the memory allocation operation instruction. A memory allocation selecting step for selecting a memory area to be allocated and a memory allocation information storage step for storing memory allocation information in which the memory area selected in the memory allocation selecting step and the memory allocation operation instruction are associated with each other. An instruction execution step for executing the class file, and a memory area corresponding to the memory allocation operation instruction based on the memory allocation information when executing the memory allocation operation instruction in the class file in the instruction execution step. And a memory allocation execution step for instructing.

A twenty-eighth invention is an invention according to the twenty-seventh invention, and includes an embedded class file storing step of pre-storing an embedded class file which is a class library in the execution environment and which is constituted by at least one fixed class file. Further comprising a selection assistant information storing step of storing selection assistant information indicating a criterion for selecting a memory area to be allocated at the time of execution of the class file by analyzing the embedded class file in advance, and selecting the memory allocation. The step selects a memory area to be allocated at the time of execution of the class file by the memory allocation operation command detected by the memory allocation operation detection step, based on the selection assistant information stored in the selection assistant information storage step.

[0053]

BEST MODE FOR CARRYING OUT THE INVENTION (First Embodiment) FIG.
It is a block diagram showing a hardware configuration of a program execution device according to the embodiment of. In FIG. 1, the program execution device includes a central processing unit (CPU) 1, a storage device 2, an input device 3, an output device 4, and a transmission / reception device 5, each of which is connected via a system bus 6. Has been done. The storage device 2 is a ROM (Read-Only).
Memory), RAM (Random-Access)
Memory), a hard disk, etc., and is used as a storage area used when the CPU 1 processes and an area for storing the program itself. The input device 3 is typically composed of a keyboard, a mouse, etc.,
Input processing for inputting an instruction from the user to the program execution device is performed. The output device 4 is configured by a display device such as a liquid crystal display device and a speaker, and performs output processing such as screen display of data output from the CPU 1 and reproduction of audio data. The transmission / reception device 5 performs data communication via a wireless or wired transmission path, and the CPU 1 receives data such as a program from an external device (not shown) via the transmission / reception device 5 and outputs a processing result to the external device. You can send it. The input device 3, the output device 4, and the transmission / reception device 5 may not be provided depending on the environment in which the program execution device is used and the required function. For example, when data communication with an external device is unnecessary, the program execution device does not need to include the transmission / reception device 5.

FIG. 2 is a functional block diagram showing an example of a functional configuration formed by executing the program of the present invention by the program execution device. The program can be included in an appropriate storage medium, and the same function can be ported by installing the program in another processing device.

In FIG. 2, the program execution device includes a program execution unit 10 and a storage unit 20. The program execution unit 10 includes a memory allocation operation detection unit 1
1, a memory allocation selection unit 12, a memory allocation information storage unit 13, an instruction execution unit 14, and a memory allocation execution unit 15. The storage unit 20 is a storage area required in the process of execution by the program execution unit 10, and is composed of memory areas α and β. Here, the input to the program execution unit 10 is a Java obtained by a user compiling a program written in a typical Java (R) language as an object-oriented language by a predetermined Java (R) compiler.
(R) Class file (hereinafter referred to as class file 500).

As an example of the above-described compilation, FIG. 3 shows a program written in the Java (R) language, and FIG. 4 shows a byte from the class file 500 obtained by compiling the program shown in FIG. This is an excerpt of the code BC portion. Note that FIG. 3 shows Java.
(R) source code foo. A class file 500 obtained by compiling the source code is input to the program execution unit 10, which is a program indicated by Java.

The memory allocation operation detection unit 11 detects an instruction for performing a dynamic memory allocation operation from the program described in the class file 500, that is, the bytecode BC sequence used in the Java (R) VM. . In the Java (R) bytecode BC as shown in FIG. 4, as an instruction for dynamically allocating memory, specifically, "ne" for generating a new instance is used.
w ”,“ newarray ”that creates a new array,
"Newarray," and "multinew
array ”, or Java. Lang. Stri
"ldc" (CO that creates an instance of ng class
In the case of NSTANT_String), etc. (in the example of FIG. 4, “n” described in addresses 1 and 13)
"ewarray int" corresponds to an instruction for dynamically allocating memory). Memory allocation operation detection unit 11
Adds the predetermined information indicating the locations of these instructions detected in the above bytecode BC sequence to the class file 500 and outputs it to the memory allocation selecting unit 12.

The memory allocation selecting section 12 selects the memory area α or β of the storage section 20 to be allocated at the time of execution for each of the memory allocation operation instructions detected by the memory allocation operation detecting section 11. Memory area α or β performed by the memory allocation selecting unit 12
As a criterion for selecting, the live range of the data stored in the storage unit 20 by the memory allocation operation is analyzed,
The memory area α or β to be allocated is selected according to the length of the live range (details will be described later).

The memory allocation information storage unit 13 stores memory allocation information indicating the selection result of the memory area α or β to be allocated which is selected by the memory allocation selection unit 12. The memory allocation information is composed of a set in which the memory allocation operation instruction in the class file 500 is associated with the selection result of the memory area α or β to be allocated by the memory allocation operation instruction. This is a memory area α to be allocated with the memory allocation operation instruction as a key.
Alternatively, it can be realized by constructing a database having β as a record.

The instruction executing section 14 uses the class file 500.
4), that is, the Java (R) bytecode BC illustrated in FIG. 4 is executed. here,
When the bytecode executed by the instruction executing unit 14 is the memory allocation operation instruction, the instruction executing unit 14 calls the memory allocation executing unit 15. On the other hand, the instruction execution unit 14
If the bytecode to be executed is other than the memory allocation operation instruction, the program corresponding to the bytecode is executed as in the conventional case. Java ^™ Virtual Machine Specification, "Addison-Wesley Publishers Japan KK,
December 25, 1997, first edition, first printing issue "(hereinafter referred to as prior art document 1)".

The memory allocation execution unit 15 executes the memory allocation operation instruction described in the class file 500. The memory allocation execution unit 15 searches the memory allocation information stored in the memory allocation information storage unit 13 for the memory allocation information corresponding to the memory allocation operation instruction to be executed by the instruction execution unit 14. get. Then, the memory allocation execution unit 1
5 reserves a memory area for the memory area α or β to be allocated from the storage unit 20 based on the acquired memory allocation information, and returns control to the instruction execution unit 14.

Next, if the program execution device is Java
The operation of processing the (R) class file 500 and selecting memory allocation will be described. FIG. 5 is a flowchart showing an operation procedure in which the program execution device processes the class file 500 and selects memory allocation.

In FIG. 5, the program execution device receives the class file 500 and inputs it to the program execution unit 10 (step S11). This class file 50
0 may be received by data communication via the transmission / reception device 5, or may be received from another external device via the system bus 6. Also, the class file 500
May be stored in the storage device 2 in advance. Note that, here, as described above as an example, the Java (R) source code foo. Java (R) class file 5 obtained by compiling Java
00 is input to the program execution unit 10. Also, FIG. 4 shows the Java obtained by compiling the above.
(R) Byte code B from class file 500
This is an excerpt of the C part.

Next, the memory allocation operation detection unit 11
From the bytecode BC string of the class file 500,
An instruction for performing a dynamic memory allocation operation is detected (step S12). In the example of the bytecode BC in FIG. 4, the memory allocation operation detection unit 11 detects “newwarray” described in the addresses 1 and 13 as an instruction for dynamically allocating memory. Note that other instructions for dynamically allocating memory detected by the memory allocation operation detection unit 11 include “new” that creates a new instance and “newwarr” that creates a new array.
ay ”and“ multilane warray ”, or Java. Lang. There is a bytecode such as "ldc" that creates an instance of the String class.

Next, the memory allocation selecting unit 12 responds to the dynamic memory allocation operation command detected by the memory allocation operation detecting unit 11 in the memory area α of the storage unit 20.
Alternatively, select which of β is to be assigned. here,
The memory allocation selecting unit 12 operates based on the procedure described below in order to select the memory area α or β to be allocated to the dynamic memory allocation operation instruction.

First, the criterion for selecting the memory area α or β to be allocated by the memory allocation selecting unit 12 is that the memory area α is a memory area targeted for garbage collection processing and the memory area β is a memory area not targeted for garbage collection processing. Is set as. That is,
The memory area α is allocated to store normal data that survives for a relatively long period of time, and the memory area β is allocated to store local (temporary) data that survives for a very short period of time. To be Then, the memory area β
The management of the generation and disappearance of the data stored in is explicitly performed by the memory allocation execution unit 15 and the instruction execution unit 14 without depending on the garbage collection process. Therefore, it is possible to prevent a situation where a large number of memory areas are secured by extremely short-lived data and a large number of memory areas are collected by garbage collection, so the processing by garbage collection is reduced and the execution efficiency of the program itself can be improved. Becomes

In order for the memory allocation selecting unit 12 to select the memory allocation based on such a criterion, it is necessary to analyze the lifetime of the data to be allocated. Therefore, the memory allocation selecting unit 12 uses the class file 50
By performing a data flow analysis on 0, the live range of the data is analyzed. Regarding this data flow analysis, for example, "AV Eiho, R. Cesi,
J. D. Ullman, "Compiler II-Principle
Techniques / Tools ", Science Co., Ltd., October 10, 1990, first edition issued (pages 741 to 772," 1.
0.5 Overview of Global Data Flow Analysis ”and“ 1.
0.6 Iterative solution of the data flow equation ")" (hereinafter,
Prior art document 2).

First, the memory allocation selecting unit 12 converts the bytecode BC sequence of the class file 500 into a notation of a register type substitution expression (step S13). Figure 6
(A) is an example in which the memory allocation selecting unit 12 converts the bytecode BC sequence of the class file 500 shown in FIG. 4 into a notation of a register-type assignment expression 501 and a reference possibility list 502 described later. , FIG. 6B shows D
This is an example of conversion into U chain information 503.

In FIG. 6A, the Java (R) virtual machine has a storage area called an operand stack and a local variable as a temporary storage area that is valid only in the method during execution of a specific method. have. Here, the bottom operand stack is O
The first and second are O2, hereinafter O3, O4, .... Also,
Let L0, L1, ..., L (n-1), assuming that the method has n local variables. For example, "iconst_ by the bytecode BC at address 0
For the "2" instruction, since the constant 2 is stacked on the operand stack from the state where the operand stack is empty, 2 is assigned (O1 = 2) to the operand stack O1 which is the bottom in the register type assignment expression 501. It will be.

For the "newlayray int" instruction with the byte code BC at address 1, one integer value is lowered from the operand stack (the operand stack O1 disappears here), and the register type assignment expression 5
In 01, a new memory area (here, the memory area A) is secured, and a reference to the secured memory area A is stacked on the operand stack O1 (O1 = A). To summarize these, in the register-type assignment expression 501, “new
A, O1 = A ”. Here, the operator "ne
“W” indicates that a new memory area A is secured.

Next, for the "store_1" instruction by the byte code BC at address 3, one reference value is lowered from the operand stack, and the register type assignment expression 5
In 01, since it is substituted into the local variable No. 1 (L0), it becomes two instructions of "L0 = O1, O1 = φ". Here, “O1 = φ” indicates that the value held by the operand stack O1 is invalid, and is not necessarily a necessary assignment expression, but it is explicitly inserted to simplify the operation of the data flow analysis. To do.

Further, for the "iastore" instruction with the byte code BC at address 7, two integer values and one reference value are lowered from the operand stacks O1 to O3 that are stacked at this point, and register type substitution is performed. Formula 501
Then, since the elements are assigned to the array, "O1 [O
2] = O3, O1 = φ, O2 = φ, O3 = φ ”(“ O1 = O2 = O3 = φ ”means“ O1 = φ, O2
= [Phi], O3 = [phi] ", and a [b] = c represents substitution into array elements).

For the "newlayray int" instruction with the byte code BC at the address 13, one integer value is lowered from the operand stack (the operand stack O1 disappears here), and the register type assignment expression 501 has a new value. A memory area (here, memory area B) is secured, and a reference to the secured memory area B is stacked on the operand stack O1 (O1 = B). To summarize these, in the register-type assignment expression 501, “new
B, O1 = B ”. By repeating such a conversion operation, the memory allocation selecting unit 12
The bytecode BC string of the class file 500 is converted into the notation of the register type substitution expression 501.

Since the conventional data flow analysis technique is mainly applied to the native machine instruction format, it is basically assigned to the register.
On the other hand, the program execution device of a Java (R) class file (Java (R) virtual machine) is a stack machine based on stack operation. Therefore, by the process of step S13, the stack operation is converted into a format equivalent to the register operation, so that it becomes easy to apply the conventional data flow analysis technique. However, if such an effect is not expected, the process of step S13 may not necessarily be performed. For example, bytecode BC
It goes without saying that the same function can be provided even if the configuration is such that the data flow analysis is directly performed for the stack operation of the columns.

Next, the memory allocation selecting unit 12 performs alias analysis on a method-by-method basis with respect to the register-type assignment expression 501 obtained at step S13 (step S14). The method of this alias analysis is described in detail in the above-mentioned Prior Art Document 2, pp. 790 to 806, "10.8 Handling of Aliases". By executing this alias analysis, it is possible to indicate for each row of the bytecode BC column which register may point to which memory area, and as a result of the analysis, a list 502 of reference possibilities is obtained. To be

In FIG. 6A, after the execution of the "newarray" instruction by the bytecode BC at address 1,
The reference possibility list 502 is “O1 = A”, and the operand stack O1 points to the memory area A. In addition, “aload” by the bytecode BC of address 4
After execution of the "_1" instruction, the reference possibility list 502 is "L".
0 = A ”, and the operand stack O1 and the local variable L0 point to the memory area A. in this way,
The data used in the Java (R) virtual machine is basically a basic data type and a reference type, and a dedicated bytecode is assigned for an operation on this reference type. Therefore, for example, "aload" and "as"
If attention is paid to a reference type operation instruction such as “tore”, the alias analysis can be realized relatively easily.

Next, the memory allocation selecting unit 12 obtains DU (Define-Use: definition-use) chain information based on the result of the alias analysis obtained in step S14 (step S15). For the method of acquiring the DU chain information, refer to No. 769 of the above-mentioned Prior Art Document 2.
For details, see page 772-Analysis of Living Variables. The DU chain information is expressed as a list of addresses of all places where the definition is used (U) with respect to the address representing the place where the definition (D) is performed.

In the example of FIG. 6B, the DU chain information 503 regarding the references to the memory areas A and B is shown. DU chain information 5 regarding reference to memory area A
In 03, an address 1 at which a new memory area A is secured is expressed as a defined address, and an address of a location where the memory area A is used for subsequent addresses is expressed. Similarly, in the DU chain information 503 related to the reference of the memory area B, the address 13 at which a new memory area B is secured is expressed as a defined address,
The addresses of the locations where the memory area B is used are expressed for the subsequent addresses.

Next, the memory allocation selecting unit 12 acquires one memory allocation operation command detected in the above step S12 in a predetermined order (step S16).

Then, the memory allocation selecting unit 12 analyzes the live range of the data stored in the memory area allocated by the memory allocation operation with respect to the memory allocation operation command obtained in step S16 (step S17). ). The method of analyzing this live range uses the DU chain information obtained in step S15. That is, the DU chain is traced to the memory area allocated by the memory allocation operation, and the live range extends from the address of the memory allocation operation instruction to the last used address.

In the DU chain information 503 of FIG. 6 (b), the memory area A defined by the memory allocation operation instruction of the byte code BC of address 1 is used from address 1 to address 35. The lifetime of the area A is addresses 1 to 35. Further, the addresses where the memory area B defined by the memory allocation operation instruction of the bytecode BC of the address 13 is used are from the address 13 to the address 47, and the lifetime of the memory area B is the addresses 13 to 47. .

Next, the memory allocation selecting unit 12 determines whether or not the live range analyzed in step S17 is closed inside the method in which the memory allocation operation is executed (step S18). The determination method of the memory allocation selecting unit 12 is that the live range of the reference value to the memory area is completely included in the method, no other method is called in the middle of the live range, and the method ends. If there is no register other than the operand stack and the local variable that is the alias of the reference value to the area at this point, it is determined to be “closed inside the method”. This is because the live range obtained in step S17 is based on the DU chain information based on the data flow analysis performed within the range limited in the method, and the use of the value by other methods is not considered. This is because. Therefore, this analysis cannot exclude the possibility that the value will be used during the invocation of another method or after the end of the execution of the method. In addition, a condition is added that there is no register other than the operand stack and the local variable that is an alias of the reference value to the area.

Then, when the live range is closed inside the method, the memory allocation selecting unit 12 executes the memory allocation operation instruction with local (temporary) data (that is, garbage collection) that survives for a very short period. Memory area β to store data that is not subject to
Memory allocation information is stored in the memory allocation information storage unit 13 as the memory allocation information (step S19), and the process proceeds to the next step S21. On the other hand, when the live range is not closed inside the method, the memory allocation selecting unit 12 stores the memory allocation operation instruction as normal data that survives for a relatively long period of time (that is, data that is the target of garbage collection). Therefore, it is determined that the memory area α is to be allocated, recorded in the memory allocation information storage unit 13 as the memory allocation information (step S20), and the process proceeds to the next step S21.

In the example of FIGS. 6A and 6B, the live range of the memory area A allocated by the memory allocation operation of the address 1 is completely included in the method as shown in the DU chain information 503. There is no code for calling another method on the way, and the register pointing to the memory area A at the end of the method is only the local variable L0. That is, since the lifetime of the memory area A is closed in the method, the allocation to the memory area β is determined. This indicates that the problem does not occur even if the memory area A is released when the execution of the method is completed. Therefore, if the instruction execution unit 14 performs an operation of releasing all the memory area β at the time when the method ends (that is, at the time when the “return” instruction is executed), the memory area β is excluded from the target of garbage collection. Also, the generation and disappearance of data can be completely controlled.

On the other hand, the live range of the memory area B allocated by the memory allocation operation of the address 13 is also D
It is completely included in the method as shown in U-chain information 503. However, as a register pointing to the memory area B at the end of the method, the reference possibility list 502
"<Field foo.b [I> = B", that is, the static field of the foo class remains, and the lifetime of the memory area B is not closed in the method, so the allocation to the memory area α is determined. . This is because the value stored in the static field does not disappear even when the method execution ends, and the possibility that the value will be used again by the subsequent program execution cannot be excluded, so it is released when the method ends. This is because the memory area β to be allocated cannot be allocated.

Incidentally, the above step S19 or S20.
The memory allocation information recorded in the memory allocation information storage unit 13 by means of, for example, an identifier (class name, a method name including argument information, a set of addresses, etc.) for specifying the position of the memory allocation operation instruction as shown in FIG. ) As a key, and the selection result of the memory area to be allocated by the memory allocation operation instruction is used as a record, and these sets are recorded.

Returning to FIG. 5, the memory allocation selecting unit 12
Determines whether or not there is an unprocessed memory allocation operation instruction with respect to all the memory allocation operation instructions detected in step S12 (step S21). Then, the memory allocation selecting unit 12 performs the above step S21.
If there are unprocessed memory allocation operation instructions in
Returning to step S16, the processing is continued, and when there is no unprocessed memory allocation operation instruction, the flow ends. In this way, the memory allocation selecting unit 12
Stores the memory allocation information in the memory allocation information storage unit 1
Record in 3.

Next, the operations of the instruction executing section 14 and the memory allocation executing section 15 will be described. Instruction execution unit 14
Executes the bytecode string described in the class file 500 input as described above. At that time, the instruction execution unit 14 determines that the bytecode to be executed is the memory allocation operation instruction described above, that is, “new”, “newar”.
"ray", "anewarray", "multian"
"ewarray", and "ldc" (CONSTAN
In the case of a T_String) instruction or the like, the memory allocation execution unit 15 is called. Further, the instruction execution unit 14 determines that the bytecode to be executed is the end of the method, that is, “retu
In the case of the "rn" instruction or the like, the release processing is performed on the memory area β of the storage unit 20 as described above, together with the method termination processing.

When the memory allocation execution unit 15 is called by the instruction execution unit 14 based on the above-mentioned memory allocation operation command, the position of the memory allocation command (class name, method name including argument information, and set of addresses, etc.). ) As a key, the memory allocation information storage unit 13 is searched, and the record of the memory area α or β to be allocated corresponding to the memory allocation instruction is acquired. Then, when the content of the acquired record is the “memory area α”, the memory allocation execution unit 15 secures a necessary memory area from the memory area α and performs the memory allocation operation based on the bytecode instruction. I do. On the other hand, when the content of the acquired record is the “memory area β”, the memory allocation execution unit 15 secures a necessary memory area from the memory area β and allocates the memory based on the bytecode instruction. Do the operation. Then, the memory allocation execution unit 15 returns the control to the instruction execution unit 14 as the result of the memory allocation operation for each memory area α or β.

As described above, according to the program execution device, it is possible to detect the memory allocation operation for the data having a very short life and allocate the data to the temporary memory area β dedicated to the data. This can prevent the memory area from being disturbed by the frequent generation and disappearance of short-lived data, which imposes a load on the execution of garbage collection, thus reducing the load on the program for dynamically managing the memory area. Therefore, it is possible to improve the execution efficiency of the program.

In this embodiment, the memory area β which is not the target of the garbage collection is allocated to store the local (temporary) data that survives for a very short period, but it survives for a very long period. Alternatively, the memory area β may be used to store data that does not disappear until the end of execution of the program. In this case, the data that is unlikely to be collected by the garbage collection is excluded from the search target of the garbage collection, so that the load on the garbage collection can be reduced and the execution efficiency of the program can be improved.

Further, in the present embodiment, the data flow analysis and the live range analysis were limited to the method, but the live range beyond the method was analyzed by performing the already known inter-procedural data flow analysis. Then, it may be used as a judgment condition for selecting the memory area.

Further, in the present embodiment, as an example of the memory allocation operation instruction, "invokevirtua"
It is also possible to treat a method call instruction such as an "l" instruction as a target of a memory allocation operation. General Java
(R) In the implementation of the virtual machine, “invokevirtual” and “invokekei” which are method call instructions.
interface "," invokespecia "
l ”and“ invokestatic ”command, a new method is called, and a new memory (Java) is used as a work area for method execution management.
(R) frame). Therefore, for example, the Java (R) frame area secured by the method call instruction is always Java.
A configuration is also possible in which the memory area is dedicated to the (R) frame. In this case, it is possible to prevent the memory area from being disturbed by the method invocation and to impose a load on the execution of the garbage collection, so that it is possible to improve the execution efficiency of the program.

Further, in the present embodiment, the memory allocation information storage unit 13 is constituted by the database in which the memory allocation operation command is a key and the memory area to be allocated is a record. All the information in the above may be stored. In the case of such a configuration, different memory allocation operation instructions can be applied to each memory area to be allocated. For example, a new instruction "new_b" to be assigned to the special memory area β is newly provided for the "new" instruction to be assigned to the normal memory area α, and the memory allocation selecting unit 12 directly rewrites the bytecode string included in the class file 500. It can be realized by writing in the memory allocation information storage unit 13.

Further, in the present embodiment, each processing in the memory allocation operation detecting section 11 and the memory allocation selecting section 12 is supposed to be carried out at the time of loading the Java (R) class file. It may be configured so that it is performed at the first or specific time of calling a method including. According to this configuration, the method is frequently called by causing the memory allocation selecting unit 12 to select the memory area when a certain method exceeds the predetermined threshold value, for example, when the method is called ten times. It is possible to select only the memory allocation of the portion that greatly contributes to the execution performance of the program. Therefore, it is possible to more efficiently allocate the memory area with a lower load of the memory allocation selecting unit 12.

(Second Embodiment) Next, by using the selection assistant information describing the selection method of the memory allocation obtained by analyzing the already-known embedded class file, further than the above-described first embodiment. A program execution device according to the second embodiment that efficiently and accurately allocates memory areas will be described. The hardware configuration of the program execution device according to the second embodiment is as follows.
Since it is the same as the first embodiment described in FIG. 1 described above, detailed description thereof will be omitted here.

Next, the functional configuration of the program execution device according to the second embodiment will be described. FIG. 8 is a functional block diagram showing an example of a functional configuration formed by executing the program of the present invention by the program execution device. The program can be included in an appropriate storage medium, and the same function can be ported by installing the program in another processing device.

In FIG. 8, the program execution apparatus adds the selection assistant information storage unit 16 to the program execution unit 10 of the program execution apparatus described in the first embodiment, and the program execution unit 10 executes the storage unit 20. The configuration of the memory area γ is added as a storage area required in the process. Further, the built-in class file 600 is input to the program execution unit 10 in advance. The selection assistant information storage unit 16 creates and stores the selection assistant information, which will be described later, which describes the selection method of memory allocation by analyzing the embedded class file 600 in advance. The other functional blocks are the same as those in the first embodiment described above, and therefore, the same blocks are designated by the same reference numerals and detailed description thereof will be omitted.

First, the operation of the selection assistant information storage unit 16 of the program execution apparatus processing the built-in class file 600 to create the selection assistant information will be described. FIG. 9 is a flowchart showing the operation of the selection assistant information storage unit 16 processing the embedded class file 600. Note that the selection assistant information storage unit 16 stores the embedded class file 6
The operation of processing 00 is processed before the operation of selecting memory allocation which will be described later.

In FIG. 9, the embedded class file 600 is input to the program execution unit 10 (step S3).
1). The built-in class file 600 is composed of one or more fixed class files. The fixed class file here is a class file that is always loaded (or may be loaded) when the program execution device executes any program, and as a class library in the Java (R) execution environment. It is something that can be captured. The embedded class file 600 in this embodiment is Java
Java that provides basic classes that are closely related to the design of the (R) language. It is a class file included in the lang package. It should be noted that the embedded class file 600 is typically stored in the storage device 2 by being initially set in the program execution device in advance or acquired from the outside.

Next, the selection assistant information storage unit 16 analyzes the built-in class file 600 input in step S31 to create and store the selection assistant information which describes the memory allocation selection method (step S3).
2). The selection assistant information storage unit 16 stores the selection assistant information obtained by the above analysis as table information. FIG. 10A shows a method call replacement table 6 stored in the selection assistant information storage unit 16 as the selection assistant information.
10B is a memory allocation interlocking table 602 that the selection assistant information storage unit 16 stores as the selection assistant information. FIG. 10C shows the selection assistant information storage unit 16 as the selection assistant information. An example of a class-based memory allocation table 603 to be stored is shown.

In FIG. 10A, the method call replacement table 601 shows the influence of the method inside the built-in class file 600 from the user class file 500 on the survival and disappearance of the data generated by the user class file 500. It is a description.
Specifically, when the method y of the embedded class file 600 is called from the method x of the user class file 500 (or the embedded class file 600), the operand stack O of the method x, the local variable L, and other storage areas are The assignment operation that may be performed is expressed by the notation of a register-type assignment expression. That is, it may be performed for an identifier (class name, a set of method names including argument information, etc.) that identifies method y, and the runtime type (dynamic binding) of the arguments passed when method y is called. Is a list of assignment operations with.

Analysis criteria for creating the method call replacement table 601 will be described. For example, if the built-in class file 600 is analyzed, “java.la.
ng. "ToSt" of the "StringBuffer" class
In a typical implementation of the "ring ()" method, the instance (th
reference to is instance) is not copied anywhere,
The newly generated "java.lang.Strin"
It can be seen that the "g" instance is returned as the return value. That is, the value of the reference to the this instance is unloaded from the operand stack, and the newly created "StringBuffer" instance is stacked on the operand stack instead. Therefore, this method invocation will result in a newly created "java
a. Lang. Since the “String” instance is an instance S, it is guaranteed to be equivalent to the assignment expression “new S; Ot = S (the operand stack Ot indicates the position of the top of the operand stack O at that time t)”. Method call replacement table 601
Is described as the substitution expression after replacement.

If the built-in class file 600 is analyzed, "valueOf (java.lang.Obj) of the" java.lang.String "class is analyzed.
In a typical implementation example of the “ect) method, the destination of the reference passed as an argument is“ java.lang.Str ”.
ing "instance, if" java.la.
ng. "ToString" of the "String" class
It can be seen that the "g ()" method is called. However, this "toString ()" method is simply thi
Only the s instance is returned, and it is guaranteed that the contents of the operand stack O and the local variable L of the calling method are not affected at all. Because "to
This is because one argument is dropped from the operand stack O in the "String ()" method, and the same value is stacked as a return value in the operand stack O (an example of a source file in which typical implementations of these methods are described). Is shown in FIG. 11). Therefore, in the method call replacement table 601, “java.lang.Strin” is displayed.
g ”class of“ valueOf (java.lang.
Object) ”is an argument“ java.lang.St.
When called by "ring", it may be replaced with an empty assignment expression, and "none" is described in the replaced assignment expression of the method call replacement table 601.

In FIG. 10B, the memory allocation interlocking table 602 shows the memory area to be secured by the memory allocation operation for each memory allocation operation instruction included in the bytecode of the instance method of the built-in class file 600. , The instance (t
It describes whether or not to interlock with the memory area allocated to the (his instance). Specifically, the identifiers (class name, method name including argument information, address set, etc.) for specifying the position of the memory allocation operation instruction to be allocated to the memory area linked with the above-mentioned instance are listed.

The analysis criteria for creating the memory allocation interlocking table 602 will be described. For example, the typical "java.lang.String" and "java."
a. Lang. In the implementation of "StringBuffer", the instance field has a reference to the char type array that stores the contents of the character string. However, this char type array is always allocated a memory area immediately after the instance is created, and the instance After disappears, it will no longer be referenced from anywhere. Therefore, the instance and the char type array can be considered to be simultaneously created and deleted. That is, when the instance is allocated to the memory area β for the data having a short life, the life of the char-type array is also short, so it is efficient to allocate it to the memory area β. On the other hand, when the instance is allocated to the memory area α having a general life, the life of the char type array is long, so ch
The ar type array is also preferably assigned to the memory area α.
Therefore, such a char-type array memory allocation operation instruction is described in the memory allocation interlocking table 602 in order to be allocated to the memory area associated with the instance.

For example, "java.lang.StringBuff" described in the embedded class file 600 obtained by compiling the source code shown in FIG.
When the implementation example of the "er" class is analyzed, the memory allocation operation for the char-type array value that stores the content of the character string is the operations X1 and X2 performed by the constructor in FIG. 12, and the operation X performed when the buffer is expanded.
There are 3 locations. Therefore, "java.lang.St" obtained by compiling the source code of FIG.
"RingBuffer" built-in class file 600
If the position (address) of the “newwarray” instruction corresponding to the above three positions is described in the memory allocation interlocking table 602 in the byte code BC of
char type array val in the same memory area as the memory area allocated to the "stringBuffer" instance
It can be represented that the area of ue allocates.

In FIG. 10C, the class-based memory allocation table 603 is a built-in class file 600.
It describes the memory area to be allocated when the instance of the built-in class included in is created.
Specifically, it describes a set of a class name and a memory area to be assigned to an instance of the class.

This class-based memory allocation table 60
The analysis criteria for the production of 3 is “java.lang.
The "Exception" class and its derived classes will be described as an example. In the "java.lang.Exception" class in the Java (R) standard specification, an exception instance can have a detailed message character string. However, in an environment where resources such as a memory are limited, such as a home electric appliance, a function requiring extra memory such as the detailed message character string is often not used. In such a case, an implementation that does not have a detailed message character string can be adopted as the "java.lang.Exception" class in the built-in class. For example, the embedded class file 6 obtained by compiling the source code as shown in FIG.
If 00 is parsed, it can be an empty implementation for a typical implementation of the “java.lang.Exception” class that does not have a detailed message string and its derived classes. That is, even if multiple instances of these classes are generated, there is no distinction based on the contents of the instances, so "java.lang.Exce.
If only one instance of the “ption” class is generated in a specific memory area (here, the memory area γ), then “java.lang.Excepti” is generated.
When it is necessary to generate an instance of the "on" class, processing can be performed by simply returning a reference to the above-described instance generated in the memory area γ without securing a new memory area.

As described above, if the class-specific memory allocation table 603 is described such that the reusable class by sharing the instance is allocated to the sharable instance-specific memory area γ, it is generated in accordance with the exception processing. It is possible to prevent the memory area from being disturbed by the generation and extinction of the exception instance that occurs, and to prevent the load of the garbage collection from being executed, thereby improving the execution efficiency of the program. If the memory area γ is not subject to garbage collection and the releasing process is not performed, the instance once generated can be reused forever.

In this way, the selection assistant information storage unit 16
Creates and stores the above-mentioned selection assistant information, and ends the process according to the flow. In addition, the process of analyzing the built-in class file 600 processed by the selection assistant information storage unit 16 and creating the selection assistant information is performed by the creator of the built-in class file 600 directly in each of the tables 601 to 603.
May be described, or information that assists the above analysis may be separately provided to the selection assistant information storage unit 16.

After the analysis processing of the built-in class file 600, a class file other than the built-in class file 600 (hereinafter referred to as a user class file 500 to distinguish from the built-in class file 600) is input to the program execution unit 10. User class file 500
Is the same as the class file described in the first embodiment, and is obtained by compiling a program written by the user in the Java (R) language with a predetermined Java (R) compiler. ) It is a class file. The bytecode described in this user class file 500 is the embedded class file 600.
When an internal method is called, the information regarding the survival / disappearance of data is described in the method as the selection assistant information, so that the selection assistant information storage unit 16 stores the selection of the memory allocation area in the user class file 500. The above selection assistant information is used.

As an example of the above-mentioned compilation, FIG.
Indicates a program written in Java (R) language,
FIG. 15 shows the bytecode BC portion extracted from the user class file 500 obtained by compiling the program shown in FIG. Note that FIG.
4 is Java (R) source code bar. Java
The user class file 500 obtained by compiling the source code is input to the program execution unit 10.

Next, the program execution device is operated by the user class file 500 and the embedded class file 600.
Will be described and the operation of selecting memory allocation will be described. 16 and 17 are flowcharts showing an operation procedure in which the program execution device processes the user class file 500 and the embedded class file 600 and selects memory allocation.

In FIG. 16, the program execution device receives the user class file 500 and the embedded class file 600 and inputs them to the program execution unit 10 (step S41). This user class file 500
May be received by data communication via the transmission / reception device 5, or may be received from another external device via the system bus 6. Also, the user class file 50
0 may be stored in the storage device 2 in advance.
Here, as described above as an example, the Java (R) source code bar. Java
User class file 500 obtained by compiling
Are input to the program execution unit 10. Further, FIG. 15 is an excerpt of the bytecode BC portion from the user class file 500 obtained by the above compilation.

Next, the memory allocation operation detecting section 11
An instruction to perform a dynamic memory allocation operation is detected from the bytecode BC strings of the user class file 500 and the embedded class file 600 (step S42),
The memory allocation selecting unit 12 uses the user class file 5
The bytecode BC string of 00 is converted into the notation of a register-type substitution expression (step S43). These steps S4
Steps 2 and S43 are the same as steps S12 and S13 in FIG. 5 described in the above-described first embodiment, so detailed description will be omitted here.

FIG. 18A shows the memory allocation selecting unit 12
Is an example in which the bytecode BC sequence of the user class file 500 shown in FIG. 15 is converted into a notation of a register type substitution expression 504 and a result of type analysis 505 described later, and FIG. 18B is described later. It is an example converted into a substitution expression 506 and a reference possibility list 507 after replacement,
FIG. 18C is an example in which the DU chain information 508 is converted.

In FIG. 18 (a), the memory allocation selecting unit 12 sets the byte code BC string of the user class file 500 to the register type substitution expression 5 in step S43.
Convert to 04 notation. Here, register-type assignment expression 5
The memory areas S1 to S3 described in 04 are “java
a. Lang. The memory area is allocated to the "String" instance, and the memory area B1 is "java".
a. Lang. It shows the memory area allocated to the "StringBuffer" instance. The memory allocation selecting unit 12 calls "i" with another method.
In the step S43, the conversion is not performed for the "nvoke" type bytecode instructions (that is, the instructions described in the addresses 8, 11, 16, and 19 of the bytecode BC).

Returning to FIG. 16, the memory allocation selecting unit 12
Performs type analysis on the reference type value used in the method (step S44). As the method of this type analysis, the result of the type check performed by the already known data flow analyzer is used. The data flow analyzer is a module included in a bytecode verifier that is executed to verify the integrity of bytecode when loading a class file. For a detailed description of the operation of the data flow analyzer, refer to the above-mentioned prior art document 1.
(Pages 97-99 "4.9.2 Bytecode Verifier").

In FIG. 18A, the memory allocation selecting unit 12 obtains the result 505 of the type analysis by the type analysis in step S44. For example, the result of type analysis 5
At address 8 of 05, "java.lang.StringBuf" is added to the operand stacks O1 and O2.
The reference value of the “fer” type is stored in the operand stack O3 and the local variable L0 as “java.lang.Strin”.
The information that the “g” type reference value is stored is obtained by the type analysis in step S44.

Returning to FIG. 16, the memory allocation selecting unit 12
Is the "inv that remains without being converted in step S43.
“Byte” type bytecode instructions are replaced with the register type assignment expression notation based on the method call substitution table 601 stored in the selection assistant information storage unit 16 to create the substitution expression 506 after the substitution (step S45).

For example, in FIGS. 18A and 18B, the address 19 "invoo" of the register type assignment expression 504 is used.
kevirual # 15 <Method jav
a. Lang. StringBuffer. toStr
ing () Ljava / lang / String;>
10 "in the method invocation replacement table 601 in FIG. 10A," java.lang.Str. "
"ngString" class "toString ()"
Since the method is equivalent, in the substitution expression 506 after replacement, “n
ew S3; O1 = S ”.

As described above, in the method call substitution table 601 described above, when the argument passed when the method is called includes the reference type, the runtime type of the instance indicated by the value of the reference type is described. can do. That is, the memory allocation selecting unit 12 displays “inv
A method is described in the method call replacement table 601 for the "oke" type bytecode instruction,
And, if the type of the referenced instance passed as a reference type argument also matches the type described in the table, it is replaced with the register type assignment expression notation. With this configuration, even in a situation where the behavior of the method changes depending on the runtime type (dynamic binding) of the referenced instance that is passed as an argument, it is possible to use an appropriate type based on the runtime type. Can describe optional assistant information.

Here, if the method to be called is not described in the method call replacement table 601, the memory allocation selecting unit 12 does not perform replacement. In this way, when the code of the method call remains unreplaced, the memory allocation selecting unit 12 determines whether or not the live range is closed in the method in step S54, which will be described later, during the live range. It will be judged that another method is called. For example, "java.lan
g. "ValueOf (jav
a. Lang. If the execution type of the argument of the "Object)" method is not "java.lang.String", there is no description in the method call replacement table 601, and the memory allocation selecting unit 12 does not perform replacement.

Returning to FIG. 16, the memory allocation selecting unit 12
Performs alias analysis on a method-by-method basis with respect to the register-type substitution expression 506 after substitution obtained in step S45 (step S46), and based on the list of reference possibilities obtained by the alias analysis, DU The chain information is acquired (step S47), and one memory allocation operation command detected in step S42 is acquired in a predetermined order (step S48). These steps S46 to S4
The procedure of No. 8 is the same as the steps S14 to S16 of FIG. 5 described in the above-described first embodiment, and therefore detailed description thereof will be omitted here. However, the DU in step S47 above
In chain information acquisition, the reference (including this instance) passed as an argument for the method call instruction is
Obtain DU chain information as all used. In FIG. 18B, the reference possibility list 507 is obtained by performing the alias analysis in step S46 on the substitution expression 506 after the replacement, and the DU chain information acquisition in step S47 is performed to obtain the list in FIG. The DU chain information 508 of (c) is obtained.

In FIG. 17, the memory allocation selecting unit 1
2 searches the memory allocation interlocking table 602 stored in the selection assistant information storage unit 16, and executes the above step S
It is determined whether or not the memory allocation operation instruction acquired in 48 is described in the memory allocation interlocking table 602 (step S49). Then, when the memory allocation operation command is described in the memory allocation interlocking table 602, the memory allocation selecting unit 12 determines to allocate a memory area associated with the this instance to the memory allocation operation command, and the memory allocation operation instruction is executed. It is recorded in the information storage unit 13 (step S5
0), the process returns to step S48. On the other hand, if the memory allocation operation instruction is not described in the memory allocation interlocking table 602, the memory allocation selecting unit 12 advances the process to the next step S51.

Here, the memory allocation operation command determined to be described in the memory allocation interlocking table 602 in the above step S49 is a command acquired based on the embedded class file 600 stored in advance (typically Specifically, the memory allocation operation instruction based on the user class file 500 is not described in the memory allocation interlocking table 602). That is, as long as the same embedded class file 600 is stored in the program execution device, the memory allocation information recorded in the memory allocation information storage unit 13 in step S50 is considered to be unchanged. Therefore, the above step S49
As for the memory allocation information in S50 and S50, the first analysis result is stored in the memory allocation information storage unit 13,
In the subsequent analysis procedure, steps S49 and S50 may be deleted.

Next, the memory allocation selecting unit 12 searches the class-specific memory allocation table 603 stored in the selection assistance information storage unit 16, and the memory allocation operation instruction acquired in step S48 is the class-specific memory. It is determined whether or not it is described in the allocation table 603 (step S51). Then, when the memory allocation operation instruction is described in the class-specific memory allocation table 603, the memory allocation selecting unit 12
The memory allocation information storage unit 1 determines that the memory area γ described in the class-specific memory allocation table 603 is allocated by the memory allocation operation.
3 (step S52), and the process proceeds to step S
Return to 48. On the other hand, if the memory allocation operation instruction is not described in the class-based memory allocation table 603, the memory allocation selection unit 12 advances the process to step S53.

Next, the memory allocation selecting unit 12 analyzes the live range of the data stored in the memory area allocated by the memory allocation operation with respect to the memory allocation operation command obtained in step S48 (step S48). S53), it is determined whether the live range is closed inside the method in which the memory allocation operation is executed (step S54). These steps S
The procedures of 53 and S54 are the same as steps S17 and S18 of FIG. 5 described in the above-described first embodiment, and thus detailed description thereof will be omitted here. However, as described above, when the method call code related to the memory allocation operation instruction remains unreplaced, the memory allocation selection unit 12 determines that another method is called during the life cycle. In step S54, it is determined that the live range is not closed inside the method.

Then, when the live range is closed inside the method, the memory allocation selecting unit 12 executes the memory allocation operation instruction with local (temporary) data (that is, garbage collection) that survives for a very short period. Memory area β to store data that is not subject to
Memory allocation information is stored in the memory allocation information storage unit 13 as the memory allocation information (step S55), and the process proceeds to the next step S57. On the other hand, when the live range is not closed inside the method, the memory allocation selecting unit 12 stores the memory allocation operation instruction as normal data that survives for a relatively long period of time (that is, data that is the target of garbage collection). Therefore, it is determined that the memory area α is to be allocated, recorded in the memory allocation information storage unit 13 as the memory allocation information (step S56), and the process proceeds to the next step S57. The procedure of these steps S55 and S56 is also the same as the steps S19 and S20 of FIG. 5 described in the above-described first embodiment, and therefore detailed description thereof is omitted here.

Next, the memory allocation selecting section 12 judges whether or not there is an unprocessed memory allocation operating instruction with respect to all the memory allocation operating instructions detected in the above step S42 (step S57). Then, if there is an unprocessed memory allocation operation instruction remaining in step S57, the memory allocation selection unit 12 returns to step S48 to continue the processing, and if there is no unprocessed memory allocation operation instruction remaining, The flow ends. Note that, in FIG. 19, the memory allocation information storage unit 13 is processed by processing the bytecode BC of the user class file 500 shown in FIG. 15 based on the flow.
Shows memory allocation information stored in.

Next, the operations of the instruction executing section 14 and the memory allocation executing section 15 will be described. Instruction execution unit 1
4 executes the bytecode sequence described in the class file 500 input as described above. At that time, when the bytecode to be executed is the memory allocation operation instruction described above, the instruction execution unit 14 executes the memory allocation execution unit 15
Call. Further, the instruction execution unit 14 determines that the bytecode to be executed is the end of the method, that is, “return”.
When it is an instruction or the like, the release processing is performed on the memory area β of the storage unit 20 as described above, together with the method termination processing.

When the memory allocation execution unit 15 is called by the instruction execution unit 14 based on the above-mentioned memory allocation operation instruction, the memory allocation instruction position (class name, method name including argument information, and set of addresses, etc.). ) As a key, the memory allocation information storage unit 13 is searched, and the record of the memory area to be allocated corresponding to the memory allocation instruction is acquired. Then, when the content of the acquired record is the “memory area α”, the memory allocation execution unit 15 secures a necessary memory area from the memory area α and performs the memory allocation operation based on the bytecode instruction. I do. In addition, when the content of the acquired record is the “memory area β”, the memory allocation execution unit 15 secures a necessary memory area from the memory area β, and performs the memory allocation operation based on the bytecode instruction. I do. Further, when the content of the acquired record is “memory area γ”, the memory allocation executing unit 15 already generates an instance of the same class that the memory allocation instruction is trying to generate in the memory area γ. If completed, a reference to the above instance is returned, and if not generated, a necessary memory area is secured from the memory area γ, and a memory allocation operation based on the bytecode instruction is performed. In addition, in the case where the content of the acquired record is “linked with this instance”, the memory allocation execution unit 15 determines in which memory area α to γ the this instance in the instance method including the memory allocation operation instruction is stored. , A necessary memory area is secured from the stored memory areas α to γ, and a memory allocation operation based on the bytecode instruction is performed.

As described above, according to the memory allocation information shown in FIG. 19, the String instance and the StringBuffer instance having a very short life can be allocated to the temporary data dedicated memory area β. As a result, it is possible to prevent the memory area from being disturbed by the frequent generation and disappearance of short-lived data, and thus avoiding a load on the execution of garbage collection, so that it is possible to improve the execution efficiency of the program.

Here, the method call replacement table 60
With respect to the memory allocation operation instruction (for example, the memory area S3 in the substitution expression 506 after the replacement in FIG. 18B) that appears in the register-type substitution expression replaced by 1, the memory allocation information indicates the memory area α in the memory allocation information.
However, the instruction execution unit 14 may not recognize this instruction as a memory allocation instruction. As described above, the memory area S3 is defined by the method call replacement table 601 shown in FIG.
The invocation instruction of the “toString ()” method of the “java.lang.StringBuffer” class is generated by being replaced with “new S; Ot = S”. In other words, the operation of "new S" is
Actually, "java.lang.StringBuff
It is executed in the "toString ()" method of the "er" class. In such a case, the instruction execution unit 14 is configured to be able to write the memory allocation information to the memory allocation information storage unit 13, and “toStrin
By storing the information of the memory area to be allocated to the memory area S3 when the "g ()" method is called in the memory allocation information storage unit 13, "toStrin"
Memory allocation is possible by determining the memory area to be allocated to the memory area S3 by referring to the memory allocation information when executing the memory allocation operation in the "g ()" method. Furthermore, the live range of the memory area S3 is analyzed, and if the live area is closed in the method, the load on the execution of garbage collection can be further reduced by allocating the memory area β to the memory area S3.

In the second embodiment, specific table configurations are illustrated as the memory allocation information and the selection assistance information, but it goes without saying that the scope of application of the present invention is not limited to these formats. .

Further, in this embodiment, the class-specific memory allocation table 603 of the built-in class describes the reusable class by sharing the instance, but the class does not have to be such a class. For example, it can be applied to memory area allocation based on behavior characteristics of each class. This is because the storage unit 20 stores a memory area α for long-life data having a low frequency of performing garbage collection and a memory for short-life data having a high frequency of performing garbage collection based on the length of the data lifetime. In the case of being composed of the area β, if the class-specific memory allocation table 603 is described so that the class having the characteristic of having a short life is allocated to the memory area β, it is possible to perform efficient memory allocation when the program is executed. Becomes

Alternatively, when the storage unit 20 is composed of an internal memory module capable of high-speed access and an external memory module having a low access speed, a class having a characteristic of frequent reading and writing is assigned to the internal memory module. The class-based memory allocation table 603 can be described as follows.

As described above, according to the program execution device of the second embodiment, the class file required by the memory allocation selector is not changed from the built-in class file whose contents do not change even when any program is executed. Analysis information can be given in advance as selection assistant information. Therefore, it is possible to reduce the processing load on the memory allocation selecting unit. Furthermore, by describing advanced selection assistant information that is difficult to analyze only with the information described in the class file, such as survival information of data across methods, it is more efficient and accurate when the program is executed. Memory allocation can be performed.

[Brief description of drawings]

FIG. 1 is a block diagram showing a hardware configuration of a program execution device according to a first embodiment of the present invention.

FIG. 2 is a functional block diagram showing an example of a functional configuration formed by executing the program of the present invention by the program execution device of FIG.

FIG. 3 is a diagram showing an example of a program written in Java (R) language.

FIG. 4 is a diagram showing a bytecode BC portion extracted from a class file 500 obtained by compiling the program of FIG.

5 is a class file 5 of the program execution device of FIG.
10 is a flowchart showing an operation procedure of processing 00 to select memory allocation.

FIG. 6 is a diagram showing an example in which the memory allocation selecting unit 12 in FIG. 2 converts a bytecode BC sequence into a notation of a register type assignment expression 501, a reference possibility list 502, and DU chain information 503. .

7 is a diagram showing an example of memory allocation information recorded in a memory allocation information storage unit 13 of FIG.

FIG. 8 is a functional block diagram showing an example of a functional configuration formed by executing the program according to the second embodiment of the present invention by the program execution device of FIG. 1.

9 is a flowchart showing an operation in which the selection assistant information storage unit 16 of FIG. 8 processes an embedded class file 600. FIG.

10 is a method call replacement table 601 stored as selection assistant information in the selection assistant information storage unit 16 of FIG. 8;
It is a figure which shows an example of the memory allocation interlocking | linkage table 602 and the memory allocation table 603 classified by class.

11 is a diagram showing an example of a source file in which a typical implementation of a method is described for the selection assistant information storage unit 16 of FIG. 8 to create the method call replacement table 601 of FIG.

12 is a diagram showing an example of a source file for the selection assistant information storage unit 16 of FIG. 8 to create the memory allocation interlocking table 602 of FIG.

13 is a diagram showing an example of a source file for the selection assistant information storage unit 16 of FIG. 8 to create the class-based memory allocation table 603 of FIG. 10;

FIG. 14 is a diagram showing an example of a program written in Java (R) language.

15 is a diagram showing a bytecode BC portion extracted from a user class file 500 obtained by compiling the program shown in FIG.

16 is a flowchart showing an operation procedure in which the program execution device of FIG. 8 processes the user class file 500 and the embedded class file 600 and selects memory allocation.

17 is a flowchart showing an operation procedure in which the program execution device of FIG. 8 processes the user class file 500 and the embedded class file 600 and selects memory allocation.

FIG. 18 is a diagram showing how the memory allocation selecting unit 12 of FIG. 8 writes the bytecode BC sequence into a register type assignment expression 504, a type analysis result 505, a substitution expression 506 after replacement, a reference possibility list 507, and It is a figure which shows an example converted into DU chain information 508.

19 is a diagram showing an example of memory allocation information recorded in the memory allocation information storage unit 13 of FIG.

[Explanation of symbols]

1 ... CPU 10 ... Program execution unit 11 ... Memory allocation operation detection unit 12 ... Memory allocation selecting section 13 ... Memory allocation information storage unit 14 ... Instruction execution unit 15 ... Memory allocation execution unit 16 ... Selection assistant information storage unit 2 ... Storage device 20 ... storage unit 3 ... Input device 4 ... Output device 5 ... Transceiver 6 ... System bus 500 ... Class file 501, 504 ... Register type assignment expression 502, 507 ... List of reference possibilities 503, 508 ... DU chain information 505 ... Result of type analysis 506 ... Substitution expression after replacement 600 ... Built-in class file 601 ... Method call replacement table 602 ... Memory allocation interlocking table 603 ... Memory allocation table by class BC ... byte code α, β, γ ... Memory area

   ─────────────────────────────────────────────────── ─── Continued front page    (72) Inventor Tomokazu Kanamaru             1006 Kadoma, Kadoma-shi, Osaka Matsushita Electric             Sangyo Co., Ltd. (72) Inventor Nobuteru Tominaga             1006 Kadoma, Kadoma-shi, Osaka Matsushita Electric             Sangyo Co., Ltd. F-term (reference) 5B060 AA06

Claims (28)

[Claims] 1. A program execution device for executing a class file obtained by compiling a program in an object-oriented language with a predetermined compiler, comprising: a memory divided into a plurality of areas; and a memory described in the class file. A memory allocation operation detection unit for detecting a memory allocation operation instruction, and the memory to be allocated at the time of execution of the class file by analyzing the memory allocation operation instruction detected by the memory allocation operation detection unit. A memory allocation selecting unit that selects an area; a memory allocation information storage unit that stores memory allocation information that associates the memory area selected by the memory allocation selecting unit with the memory allocation operation instruction; Execution And a memory area corresponding to the memory allocation operation instruction on the basis of the memory allocation information when executing the memory allocation operation instruction in the class file in the instruction execution section. And a memory allocation execution unit that gives instructions. 2. The memory allocation selecting unit is a target of a garbage collection process for automatically detecting and releasing the used memory area, and the processing related to the memory allocation operation instruction, and the garbage collection. The program execution device according to claim 1, wherein the memory area to be allocated at the time of execution of the class file is selected by distinguishing it from being not a processing target. 3. The memory allocation selecting unit should calculate a live range as a period in which a process related to the memory allocation operation instruction is continuously executed, and allocate the live range based on the live range when the class file is executed. The program execution device according to claim 1, wherein the memory area is selected. 4. A built-in class file storage unit that stores in advance an embedded class file that is a class library in an execution environment and that is configured by at least one fixed class file; and the memory allocation operation by analyzing the embedded class file in advance. Further comprising a selection assistant information storage unit for storing selection assistant information indicating a criterion for selecting the memory area to be allocated at the time of executing the class file by an instruction, wherein the memory allocation selection unit is stored in the selection assistant information storage unit. 2. The program execution device according to claim 1, wherein the memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction detected by the memory allocation operation detection unit based on the selected assistant information. . 5. The selection assistant information according to claim 4, wherein a criterion for selecting the memory area to which an instance of the built-in class is to be assigned is described for each built-in class. Program execution unit. 6. The selection assistant information describes, with respect to the memory allocation operation instruction executed by the embedded class file, a criterion for selecting the memory area to be allocated when the memory allocation operation instruction is executed. The program execution device according to claim 4, characterized in that 7. The selection assistant information, in association with a selection result of the memory area allocated to an instance of an embedded class that executes the memory allocation operation instruction, selects the memory area to be allocated by the memory allocation operation instruction. 7. The program execution device according to claim 6, wherein criteria for selection are described. 8. A built-in class file storage unit that stores in advance a built-in class file that is a class library in an execution environment and that is configured by at least one fixed class file, and the memory allocation operation by analyzing the built-in class file beforehand. Further comprising a selection assistant information storage unit that stores selection assistant information indicating a criterion for selecting the memory area to be allocated at the time of executing the class file by an instruction, and the selection assistant information is stored in each method of the embedded class file. On the other hand, the influence that the data generated by the execution of the method has on the live range that is continuously used is described, and the memory allocation selecting unit is configured to store the selection assistant information stored in the selection assistant information storage unit. Based on the memory allocation operation detection The program execution device according to claim 3, wherein the memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction detected by the unit. 9. The selection assistance information describes the influence of the data generated by the execution of the method on the live range, depending on the runtime type of the argument passed to the method of the embedded class file. The memory allocation selecting unit analyzes the type of an instance of a built-in class and refers to the selection assistant information based on the runtime type of the instance to detect the memory allocation operation detecting unit. 9. The program execution device according to claim 8, wherein the memory area to be allocated at the time of executing the class file is selected by a memory allocation operation instruction. 10. The selection assistant information is Java. la
ng. The program execution device according to claim 4, wherein a criterion for selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction is described for a String class. 11. The selection assistant information is Java. la
ng. The program execution device according to claim 4, wherein a criterion for selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction is described for the StringBuffer class. 12. The memory allocation selecting unit performs a process of selecting the memory area to be allocated at the time of execution of the class file according to the memory allocation operation instruction detected by the memory allocation operation detecting unit, loading the class file. Characterized by doing occasionally,
The program execution device according to claim 1. 13. The memory allocation operation command, wherein the memory allocation selection unit performs a process of selecting the memory area to be allocated at the time of execution of the class file according to the memory allocation operation command detected by the memory allocation operation detection unit. The program execution device according to claim 1, wherein the method is performed for the first time or for every predetermined number of times. 14. A program execution method for executing a class file obtained by compiling a program in an object-oriented language by a predetermined compiler, using a memory divided into a plurality of areas, wherein A memory allocation operation detecting step of detecting a described memory allocation operation instruction, and the memory allocation operation instruction detected by the memory allocation operation detecting step should be analyzed and allocated by the memory allocation operation instruction when the class file is executed. A memory allocation selecting step for selecting the memory area, and a memory allocation information storage for storing memory allocation information in which the memory area selected by the memory allocation selecting step and the memory allocation operation instruction are associated with each other. A step of executing the class file, an instruction execution step of executing the class file, and a memory corresponding to the memory allocation operation instruction based on the memory allocation information when the memory allocation operation instruction in the class file is executed in the instruction execution step. And a memory allocation execution step of designating an area to the instruction execution step. 15. The memory allocation selecting step comprises:
By distinguishing the process related to the memory allocation operation instruction from the target of the garbage collection process that automatically detects and releases the used memory area and the target of the garbage collection process, 15. The program execution method according to claim 14, wherein the memory area to be allocated is selected when the class file is executed. 16. The memory allocation selecting step comprises:
The live range is calculated as a period during which the process related to the memory allocation operation instruction is continuously executed, and the memory area to be allocated at the time of execution of the class file is selected based on the live range. Program execution method. 17. An embedded class file storing step of pre-storing an embedded class file which is a class library in an execution environment and is configured by at least one fixed class file, and the memory allocation operation by analyzing the embedded class file in advance. Further comprising a selection assistant information storage step of storing selection assistant information indicating a criterion for selecting the memory area to be allocated at the time of executing the class file by an instruction, the memory allocation selection step being stored in the selection assistant information storage step. 15. The memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction detected by the memory allocation operation detection step based on the selected selection assistance information. Program execution method of mounting. 18. The selection assistant information according to claim 17, wherein a criterion for selecting the memory area to which an instance of the built-in class is to be assigned is described for each built-in class. Program execution method. 19. The selection assistant information describes, with respect to the memory allocation operation instruction executed by the embedded class file, a criterion for selecting the memory area to be allocated when the memory allocation operation instruction is executed. 18. The program execution method according to claim 17, wherein: 20. The selection assistant information is interlocked with a selection result of the memory area allocated to an instance of an embedded class that executes the memory allocation operation instruction,
20. The program execution method according to claim 19, wherein criteria for selecting the memory area to be allocated by the memory allocation operation instruction are described. 21. An embedded class file storing step of pre-storing an embedded class file which is a class library in an execution environment and is configured by at least one fixed class file; and the memory allocation operation by analyzing the embedded class file in advance. Further comprising a selection assistant information storage step of storing selection assistant information indicating a criterion for selecting the memory area to be allocated at the time of execution of the class file by an instruction, the selection assistant information being stored in each method of the embedded class file. On the other hand, the effect that the data generated by the execution of the method has on the live range that is continuously used is described, and the memory allocation selecting step is performed on the selection assistant information stored in the selection assistant information storing step. On the basis of, 17. The program execution method according to claim 16, wherein the memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction detected by the memory allocation operation detection step. 22. The selection assistant information is described in such a manner that the influence of the data generated by the execution of the method on the live range depends on the runtime type of the argument passed to the method of the embedded class file. The memory allocation selecting step analyzes the type of an instance of a built-in class, and refers to the selection assistant information based on the runtime type of the instance to detect the memory allocation operation detecting step. 22. The program execution method according to claim 21, wherein the memory area to be allocated at the time of executing the class file is selected by a memory allocation operation instruction. 23. The selection assistant information is Java. la
ng. 18. The program execution method according to claim 17, wherein criteria for selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction are described for the String class. 24. The selection assistant information is Java. la
ng. 18. The program executing method according to claim 17, wherein a criterion for selecting the memory area to be allocated at the time of executing the class file by the memory allocation operation instruction is described for the StringBuffer class. 25. The memory allocation selecting step comprises:
15. The process of selecting the memory area to be allocated when the class file is executed by the memory allocation operation instruction detected by the memory allocation operation detection step is performed when the class file is loaded. The program execution method described. 26. The memory allocation selecting step comprises:
Performing a process of selecting the memory area to be allocated at the time of execution of the class file by the memory allocation operation instruction detected by the memory allocation operation detection step, every time the method including the memory allocation operation instruction is performed or every predetermined number of times. 15. The program execution method according to claim 14, wherein: 27. A program executed by a computer that processes a class file obtained by compiling a program in an object-oriented language by a predetermined compiler, using a memory divided into a plurality of areas, wherein the class A memory allocation operation detection step of detecting a memory allocation operation instruction described in a file, analyzing the memory allocation operation instruction detected by the memory allocation operation detection step, and executing the class file by the memory allocation operation instruction. A memory allocation selecting step of selecting the memory area to be allocated, and a memory allocation storing memory allocation information in which the memory area selected by the memory allocation selecting step and the memory allocation operation instruction are associated with each other. An allocation information storage step, an instruction execution step for executing the class file, and a memory allocation operation instruction based on the memory allocation information when the memory allocation operation instruction in the class file is executed in the instruction execution step. A memory allocation executing step of instructing the corresponding memory area to the instruction executing step. 28. A built-in class file storing step of pre-storing a built-in class file which is a class library in an execution environment and is constituted by at least one fixed class file, and the memory allocation operation by analyzing the built-in class file beforehand. Further comprising a selection assistant information storage step of storing selection assistant information indicating a criterion for selecting the memory area to be allocated at the time of executing the class file by an instruction, the memory allocation selection step being stored in the selection assistant information storage step. The memory area to be allocated at the time of execution of the class file is selected by the memory allocation operation instruction detected by the memory allocation operation detection step based on the selected assisting information. The placing of the program.