JPH02156332A - Inter-process shared code management method - Google Patents

Abstract

PURPOSE:To share a compiled code object between interpreters by storing the address of data on a heap area of a processor, which a machine language instruction in the shared compiled code object allocated in a space shared between processes refers to, in this heap area to advance the execution of interpretation. CONSTITUTION:A compiled code object 6 to be shared between interpreters 4-1 and 4-2 operated as processes 1 and 2 respectively is allocated in an inter- process shared space 3, and storage areas 10-1 and 10-2 addresses of their own data corresponding to data to which machine language instructions in the object 6 refer are generated in heap areas 9-1 and 9-2 respectively. Thus, data can be referred to by plural interpreters 4-1 and 4-2, and the compiled code object is shared.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to an information processing apparatus that executes a plurality of language processors as one process in which an interpreter executes and manages compiled code objects output by a compiler. The present invention relates to an inter-process shared code management method that allows compiled code objects to be shared by multiple interpreters.

[Conventional technology]

As one method of a language processor, for example, as shown in FIG. 5, there is a compiler 42 that translates a source program to generate a compiled code object 44 in order to improve execution efficiency, and a compiler 42 that generates a compiled code object 44 in addition to the source program. There is a language processor provided with an interpreter 41 that manages the storage area and execution of objects 44.

A conventional compiled code object 44 in such a language processor stores various types of header information (including a name for identifying the compiled code object, such as a function name, size, etc.), as shown in the figure. A header area 45 for storing the sequence of machine language instructions, and l! for storing the sequence of machine language instruction sequences. Machine language instruction string area 46, address storage area for storing addresses used for referencing data stored in the heap area 43 generated and managed by the interpreter 41 from machine language instructions in the machine language instruction string area 46. 47
It has a format that includes. Here, when referring to data on the heap area 43 from within the compiler build code object 44, since the address of the data on the heap area 43 cannot be determined when compiling the source program, the interpreter 41 uses the compiled code object 44 into the storage space 40, the address of the data on the heap area 43 is determined, and the determined address is stored in a predetermined location in the address storage area 47. Therefore, at the time of compilation, the compiler 42 provides an address storage area 47 in the compiled code object 44 for the interpreter 41 to store the address when the address on the heap area 43 is determined, and also It is determined in advance in which location in the storage area 47 the address of data to be referenced by which machine language instruction is to be stored, and a machine language instruction having a structure such that the data is referenced via that location is generated.

For example, data 4 on the heap area 43 in the source program corresponding to the compiled code object 44 is
9 (character string data “abc”), the compiler 42 sets the address of the data 49 on the heap area 43 to, for example, the third (third word) location in the address storage area 47. 48 and generates an instruction that refers to the data via the location 48 as a machine language instruction, and when the interpreter 4I loads the compiled code object 44,
The address on the heap area 43 of data 49 is set to location 4.
8. As a result, the pace register R used when interpreting and executing the interpreter 41 points to the beginning of the compiled code object 44, and the size of the header area 45 + machine language instruction string area 46 is set to α
If it is a byte, the relative position from the pace register R is (
The address stored in the area 48 (αhide+3rd word) becomes pointer data pointing to the data 49 of the character string “abc”.

(Problem to be Solved by the Invention) By the way, this type of language processor is executed as one process in parallel with other processes in an information processing device, and depending on the information processing device, such a language processor In such cases, in the conventional compiled code object management method, in order to be able to refer to the data on the heap 6N area from the compiled code object, When a compiled code object is allocated to a storage space, the address of the data in the heap area is determined and the address is stored in the address storage area integrated with the compiled code object. There was a problem in that compiled code objects could not be shared among multiple interpreters executed as processes.Therefore, it was difficult to construct a system that effectively utilized storage space.

The present invention has been made in view of these circumstances,
Its purpose is to allow compiled code objects to be shared between each interpreter.

[Means for Solving the Problems] In order to achieve the above object, the inter-process shared code management method of the present invention has an inter-process shared space that enables parallel execution of multiple processes and that can be shared among the processes. ,
Information processing that executes multiple language processors as one process, including a compiler that outputs a compiled code object containing machine language instructions that refer to data each time a source program is translated, and an interpreter that interprets and executes the compiled code object. In the apparatus, a compiled code object shared between processes is allocated to the inter-process shared space, and an interpreter that interprets and executes the allocated shared compiled code object recognizes that the machine language instruction in the shared compiled code object is The address of the data on the own heap area corresponding to the data to be referenced is stored in the address storage area generated on the own heap area, and this address storage area is used to advance the interpretation and execution of the shared compiled code object.

[Effect]

In the inter-process shared code management method of the present invention, a compiled code object shared between processes is allocated to an inter-process shared space, so that a plurality of interpreters interpret and execute the shared compiled code object. It becomes possible to refer to machine language instructions, etc. in the shared compiled code object, and each interpreter stores the address of the data in its own heap area that corresponds to the data referenced by the @compound instruction in the shared compiled code object, in its own heap area. By storing in the generated address storage area, data on the own heap area can be individually referenced by machine language instructions in the referenced shared compiled code object.

〔Example〕

Next, embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram of an embodiment of the present invention. In the figure, an interpreter 4-1 and a compiler 5-1 constitute one language processor, and an interpreter 4-2 and a compiler 5-2 constitute another language processor.

The language processor including the interpreter 4-1 and the language processor including the interpreter 4-2 are each a process l.
, as process 2, are executed in parallel by the information processing device to which the present invention is applied. The process 1 has a heap area 9-1 that is generated and managed by the interpreter 4-1, and there exists data 11-1 and the like that are generated and managed by the interpreter 4-1. Similarly, the process 2 has a heap area 9-2 generated and managed by the interpreter 4-2, in which data 11-2 and the like generated and managed by the interpreter 4-2 exist. Inter-process shared space 3 is a storage space shared between process 1 and process 2.

In such a configuration, when a compiled code object is shared between the interpreter 4-1 operating as process 1 and the interpreter 4-2 operating as process 2, the shared compiled code object 6 is shared as shown in the figure. is allocated to the inter-process shared space 3, and its own data (in the interpreter 4-1, the heap area 9
-1, data 11-1, etc. on interpreter 4-2, data 11-2, etc. on heap area 9-2)
Address storage area 10-1.10 that stores the address of
-2 is generated in each of the slope areas 9-1 and 9-2. That is, the address storage area that was conventionally integrated with the compiled code object is separated from the object body containing the machine language instruction sequence, the object body is allocated to the inter-process shared space 3 as the compiled code object 6, and the address storage area is The contents are individually provided in each heap area 9-1, 9-2 with contents commensurate with the existing addresses of data on the heap areas 9-1, 9-2, which are generated and managed by each interpreter. in this way,
By allocating the main body containing machine language instructions to the inter-process shared space 3, it can be referenced from multiple interpreters 4-1.4-2, and by providing individual address storage areas, the machine language instructions mentioned above can be Reference data can be accessed correctly, and compiled code objects can be shared by multiple interpreters. Note that the data reference means 8 indicated by the broken line in FIG.
-1.8-2 is generated by the interpreter 4-1.4-2 on each process from the compiled code object 6,
Data 11 on managed heap area 9-1.9-2
-1.11-2 etc. is constituted.

The configuration and operation of this embodiment will be explained in more detail below.

FIG. 2 shows the compiler 5-1. As shown in the figure, which shows an example of the logical structure of a shared compiled code object output by the compiler 5-2, a compiled code object has a header that includes a name, size, etc. for identifying the compiled code object. As exemplified by a header area 21 for storing information and a machine language instruction 24,
a machine language instruction string area 22 that stores a sequence of machine language instructions that refer to data on the tap area;
and an address generation data area 23 that stores data in a predetermined order that can identify the data on the heap area referenced by the machine language instructions inside, for example, data in the same external format as the format in the source program. configured. Note that the machine language instruction 24 is, for example, m, which indicates that the start address of the character string "abc" is to be transferred to the register Rx.

It is a compilation of the source format vc abc, Rx, and the address of "abc" is determined to be stored in the first element of the address storage area described later, so it is O(R), and abc ” is stored at the beginning of the address generation data area 23. The address generation data area 23 is used when an interpreter that interprets and executes the compiled code object performs address storage area generation processing, which will be described later.

FIG. 3 shows the compiled code object allocation of the interpreter ll-1 and 4-2 shown in FIG.
1.7-2 is shown, and FIG. 4 shows an example of the processing of 3.7-2 in the inter-process shared space of FIG. Next, with reference to FIGS. 3 and 4, each interpreter 4-1. The compiled code object allocation that 4-2 has explains the operation of means 7-1.72.

Compiled code object allocation is performed by means 7-1.
7-2, when a request to load a compiled code object occurs, the compiled code object to be loaded (this is output by the compiler 5-1 or 5-2 and is stored in a file, etc. not shown) is Check whether the compiled code object coexists between processes (S1). If it is a compiled code object that is not shared between processes, allocate it to its own process space (S2).
In the case of a compiled code object shared between processes, it is checked whether the compiled code object has already been allocated to the interprocess shared space 3 (S3).

If it has not yet been allocated to the inter-process shared space 3, the shared compiled code object is allocated to the inter-process shared space 3 (S4), and the self-heap area 9 is allocated from the machine language instruction sequence in the compiled code object.
In order to resolve the data reference on -1.9-2, address storage area generation processing is performed (S5). This address storage area generation processing will be described in detail later. Also, if the shared compiled code object is already in the inter-process shared space 3
, only the address storage area generation processing is performed (S6). Therefore, for example, if a load request for a shared compiled code object occurs first in the interpreter 4-1, the interpreter 4-1 A shared compiled code object is allocated to the inter-process shared space 3, and an address storage area 10-1 is generated in the own heap area 9-1.Then, the interpreter 4-2 loads the shared compiled code object. When a request occurs, the interpreter 4-2 stores the address storage area 1 in its own heap area 10-2 because it has already been allocated to the inter-process shared space 3.
It is sufficient to generate 0-2. This is a load process for the shared compiled code object already allocated to the inter-process shared space 3.

Next, address storage area generation processing S5. S6 will be explained. This address storage area generation process is performed using data stored in the address generation data area 63 in the shared comparator build code object 6 shown in FIG. 4. First, in the address storage area generation process,
Address generation data area 63 in the compatible code object 6 allocated to the inter-process shared space 3
Address storage area 10-1 and address storage area 10-2 of a size commensurate with the number of data stored in own heap area 9-1
．． Next, the data stored in the address generation data area 63 is evaluated sequentially from the beginning, and the own heap area 9-1.9-2 corresponding to the data is evaluated.
Find the address of the above data and write the address to the address storage area 10-1.10-2 generated above in order from the first element.0For example, as shown in FIG. Assuming that there is data related to the character string "abc" referred to by the machine language instruction 64 at the beginning of the area 63, and that data 11-1 exists at address α on the heap area 9-1 of process l, the interpreter In the address storage area generation process according to 4-1,
The address α is written into the first element (first byte) 100-1 of the address storage area 10-1. Also, in the heap area 9-2 of process 2, the same data 11
-2 exists at address β, in the address storage area generation process of interpreter 4-2, the address β is stored in the first element (first byte) too-2 of address storage area 10-2. It is something. In this way, an address storage area for storing a group of addresses corresponding to the address where data exists on the own heap area is independently generated.

Now, as described above, address storage areas 10-1, 10-2 dedicated to the own process are created in each heap area 9-1 and 9-2.
Once completed, each interpreter 4-1.4-2 can use it to proceed with the interpretation and execution of the shared compiled code object 6. For example, as shown in FIG. Machine language instruction rmove O(R) in machine language instruction string area 62
RXJ (As explained in Part 2, this is the string a
b c ” move abc, which indicates to move the start address of the area to register Rx (this is a machine language instruction compiled from the source format of Rx),
abc", register R is in its own address storage area 10-1.10- on any process.
2, the address pointing to "abc" will be stored in the first element 100-1, 100-2 of each address storage area 10-1, 10-2, so the register abc” from the O-th area relative to the location pointed to by R, that is, elements 100 to 1,100-2
You can get the address pointing to .

This is common to both process 1 and process 2, so
By using move O(R) and Rx, it can be made common between processes.

〔Effect of the invention〕

As explained above, in the inter-process coexistence code management method of the present invention, compiled code objects shared by each process are allocated to the inter-process shared space,
The compiled code This has the effect of allowing objects to be shared by interpreters running on each process. As a result, when multiple language processors consisting of interpreters and compilers are executed in parallel, compiled code objects can be shared among the language processors, resulting in efficient use of storage space. , it is possible to reduce the consumption of storage space.

[Brief explanation of the drawing]

Fig. 1 is a block diagram of an embodiment of the present invention; Fig. 2 is a diagram showing the logical structure of a shared compiled code object output by the compiler 5-1.5-2; Fig. 3 is a compiled code Object allocation is a flowchart of a processing example of means 7-'1.7-2, and FIG. 4 is an inter-process shared space 6. A diagram showing the heap area of each process in more detail and FIG. 5 are configuration diagrams of the conventional system. In the figure, 1.2...Process 3...Inter-process shared space 4-1.4-2...Interpreter 5-1 5-2...Compiler 6...Compiled code object 7-1 .7-
2... Compiled code object allocation means 8-1.8-2... Data reference means 9-1.9-2... Heap area 1 (1-1, 10-2... Address Storage area 11-1
．． 11-2...Data

Claims (1)

[Claims] A computer that can execute multiple processes in parallel, has an inter-process shared space that can be shared between processes, and outputs a compiled code object that includes machine language instructions that refer to data by translating a source program. In an information processing device that executes a plurality of language processors as one process, each including a compiler that interprets and executes the compiled code object, and an interpreter that interprets and executes the compiled code object, the compiled code object that is shared between processes is allocated to the interprocess shared space, The interpreter that interprets and executes the allocated shared compiled code object generates in its own heap area the address of the data in its own heap area that corresponds to the data referenced by the machine language instruction in the shared compiled code object. An inter-process shared code management method characterized in that the shared compiled code object is stored in an address storage area, and the shared compiled code object is interpreted and executed using the address storage area.