JP2576659B2 - Task common area allocation method - Google Patents

Description

Description: BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for allocating a common area in a task, and more particularly to allocating a common area in a task to a computer system that executes each task in parallel on a plurality of processors. About the method.

[Conventional technology]

In the conventional method of allocating a common area in a task, the operator does not want to use a common area between tasks, but assigns a data area to be referred to as a common area between subroutines within a task. Either the task is assigned in consideration of the structure of the task or the number of tasks, or the task is dynamically assigned at the time of task generation and the address reference is resolved by a dynamic linker or the like.

[Problems to be solved by the invention]

In the above-described conventional method of allocating a common area in a task, in the former method of allocating a task in consideration of the structure and the number of tasks at the time of linking a program, the area is dynamically generated at the time of execution according to the number and conditions of data processed by the program. It is difficult to change the number of tasks and the like, and when the number of tasks actually used is smaller than that specified at the time of linking, there is a disadvantage that a useless area is occupied.

Further, the latter method of dynamically allocating at the time of program execution requires the use of a dynamic linker or the like to resolve address references to dynamically allocated areas, which has the disadvantage of increasing overhead.

[Means for solving the problem]

The method for allocating a common area in a task according to the present invention is a method for allocating a common area in a task to a computer system that divides one program into a plurality of tasks and executes each task in parallel on a plurality of processors. A compiler having a parallelizing unit for generating a target program capable of parallel processing from a source program, a linker for combining the target programs to generate a runtime program capable of parallel processing, and controlling execution of the runtime program Task control means for dividing the run-time program for each task and executing the program in parallel, and the parallelizing section of the compiler refers to only the subroutines used in one task. At the start of execution of each subroutine. The target program to add the start address of the common area in all tasks, which is the area including all the common areas in the tasks included in the program being executed in parallel, and the relative address, which is the allocation position of the common area in the task to be referred to. Including a task common area address solving purpose program generating means for generating a common area within the task, setting all common areas within the task included in the input target program in the linker, and setting a common area within all tasks. An intra-task common area address resolving means for embedding an allocation position of the intra-task common area as an address relative to the beginning of all task common areas in an address reference location in the runtime program; An area equivalent to the size of the common area is secured at the start of the task, and the start address is assigned to each subroutine. Including Tasusu the common region allocating means to pass to Chin, is constituted by.

〔Example〕

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

FIG. 1 is a block diagram showing one embodiment of a method of allocating a common area in a task according to the present invention.

As shown in FIG. 1, the compiler 2 has a parallelizing unit 21 and includes therein a task common area address solving purpose program generating means 211, and the linker 3 includes a task common area address solving means 31. , The task control means 4
It includes an intra-task common area allocation means 41.

Then, the compiler 2 receives the source program 1 and generates a target program 6 that can be processed in parallel by the parallelizing unit 21.

FIG. 2 is a program explanatory diagram showing an example of a source program used in this embodiment. FIGS. 3 and 4 are program explanatory diagrams showing a partial example of a target program generated from the source program of FIG.

The in-task common area address solving purpose program generation means 211 in the parallelization unit 21 includes, for example, the local COMM in FIG.
When referring to an area that can be defined / referenced only between subroutines included in the task defined by the declarations shown in ON / A / AA (1000) and / B / BB (1000), for example, the second
The target program shown in FIG. 3 is generated for XX = AA (I) in FIG.

Thus, the local COMMON / A / AA (100
0), / B / BB (1000) is an example of declaring that the common areas A and B are areas that can be defined / referenced only between subroutines within a task.

The global COMMON / C / CC (100000) is an example in which the common area C is declared as an area that can be defined / referenced from all tasks in the program. In addition,
XX = AA (I) represents the element AA (I) in the common area A as
YY = BB (I) represents the element BB (I) in the common area B as
ZZ = CC (I) is an example in which each element CC (I) in the common area C is referred to.

Then, the instruction S _a ← relative address (A) in FIG.
Shows that storing the relative address from the head is assigned a position in the common area A in the region gathered all tasks in the common area in the register S _a. However, since this assignment is made by the linker 3, this value cannot be determined at the time of compilation.

Further, the next instruction S _aa ← S _a + S _{base in} FIG. 3 is obtained by adding the start address S _{base of the} area where all the in-task common areas are collected and the relative address S _a of the in-task common area A. This shows that the absolute address of the intra-task common area A is obtained and stored in the register _Saa .

Note that the start address S _base stores the start address of an area unique to each task assigned by the intra-task common area assignment unit 41 in the task control unit 4 at the start of the task.

Further, the last instruction XX ← (S _aa ) in FIG. 3 is an area where S _aa is increased, that is, a head element AA of the common area A in the task.
(I) is stored in XX, and a desired dynamically allocated intra-task common area A can be referenced.

On the other hand, FIG. 4 is a partial example of the target program in referring to the inter-task common area C. The instruction S _c ← addr in FIG.
ess (C) shows an instruction for storing an address of the common region C between tasks register S _c, the next instruction ZZ ← (S _c) is S _c
, The head element CC of the inter-task common area C
(1) is stored in ZZ.

Further, only one inter-task common area C exists in the program, and the address is statically determined at the time of linking.

Next, the linker 3 shown in FIG. 1 inputs the target program 6 to generate a runtime program 7 which can be processed in parallel, and at the same time, uses the intra-task common area address resolution means 31 to change the address of the common area in the task. And is embedded in the runtime program 7 as a relative address in the entire common area group.

On the other hand, the task control means 4 in FIG. 1 inputs the runtime program 7 and executes the parallel execution program 5. Tasks T1 and T2 in FIG. 1 indicate tasks included in the program 5 during parallel execution, and there is only one instruction code and an inter-task common area in the program 5 during parallel execution. Shared between T2. The intra-task common area is allocated by the intra-task common area allocating means 41 for each task at the start of the task, and the start address is passed to each subroutine included in the task.

Thus, each subroutine can obtain desired data by executing an instruction sequence as shown in FIG.

FIG. 5 is an explanatory diagram of an area showing an example of assignment of an inter-task / intra-task common area to the source program of FIG.

As shown in FIG. 5, the intra-task common areas A and B exist for each task, and only one inter-task common area C exists in the program and is shared between the tasks.

〔The invention's effect〕

As described above, according to the method of allocating a common area in a task according to the present invention, areas to be commonly defined / referenced only among subroutines included in a certain task are collectively allocated at the start of each task, and a dynamic linker or the like is used. By resolving an address reference without a task, it becomes possible to dynamically allocate a common area in a task without being aware of the task structure and the number of tasks, and to resolve the address reference with low overhead. It has the effect that it can be done.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an embodiment of a method of allocating a common area in a task according to the present invention, FIG. 2 is a program explanatory diagram showing an example of a source program usable in this embodiment, and FIG.
FIG. 4 is a program explanatory diagram showing a partial example of a target program generated from the source program of FIG. 2,
FIG. 5 shows the tasks / tasks for the source program of FIG.
FIG. 9 is an explanatory diagram of an area showing an example of assignment of a common area in a task. 1 ... source program, 2 ... compiler, 21 ... parallelizing section, 211 ... task internal area address solving purpose program generating means, 3 ... linker, 31 ... task internal area address solving means, 4 ... … Task control means, 41 ……
Task common area allocating means, 5... Parallel execution program, 6... Target program, 7.

Claims (1)

(57) [Claims] In a method for allocating a common area in a task to a computer system which divides one program into a plurality of tasks and executes each task in parallel on a plurality of processors, parallel processing is possible from a source program. A compiler having a parallelizing unit for generating a target program, a linker for generating a runtime program capable of performing parallel processing by combining the target programs, and a runtime program for controlling execution of the runtime program. And a task control unit that divides each task into tasks and executes the tasks in parallel. The task is a common area that is referred to only among subroutines used in one task by the parallelizing unit of the compiler. In order to obtain the start address of the common area at the start of execution of each subroutine, The common area in the task for generating the target program, which adds the start address of the common area in the task, which is an area including the common area in the task included in the RAM, and the relative address, which is the allocation position of the common area in the task to be referenced An address resolution purpose program generating means, wherein the linker collectively sets all the task common areas included in the input target program and sets a common area within all tasks, and allocates the common area within each task And a task common area address resolving means which embeds in the address reference location in the run-time program as a relative address from the beginning of the common area in all tasks. Area within the task that secures the start address of the task and passes the start address to each subroutine Against comprising means, tasks in the common area of the assignment scheme, characterized in that.