JPH03246746A - Parallel execution method, compiler, and parallel process schedule supporting tool - Google Patents

Abstract

PURPOSE:To efficiently attain the minimization of execution time by applying such control that a process can be taken out from a queue in sequence of higher execution cost in each parallel process in a series of parallel processes. CONSTITUTION:The execution cost can be obtained from an execution cost field in a parallel process execution information indicated to the parallel process execution information address field 72 of each process information table 70 by tracing the process information table 70 registered sequentially from a temporary queue leading pointer. Then, it is compared with the execution cost of the parallel process in a new process information table 70, and the new process information table 70 is inserted to a position just before and already registered process information table 70 in which the former is less than the latter first. In such a way, since parallel processing is started in sequence of higher execution cost in each parallel process in the scheduling of the parallel process, execution processing time can be shortened, and the parallel processing can be efficiently performed.

Description

[Detailed Description of the Invention] [Industrial Application Field] The present invention relates to a parallel execution method, a compiler, and a parallel process scheduling support tool, and more particularly, to a method for efficiently executing parallel processes on a tightly coupled multiprocessor system. The present invention relates to a parallel execution method, a compiler that supports the parallel execution method, and a parallel process schedule support tool.

[Prior Art] As a conventional technology for allocating parallel processes (program parallelization process units) to each processor of a multiprocessor system, for example, rParallel P
programming and compilers
: KluwerAcademicPublish
rs, 1988. There are techniques discussed in pp97-pp107J. They are as follows.

(i) Dynamic task schedule When a parallel process becomes parallel executable, it is registered in a parallel executable queue, and free processors sequentially look through the queue in a first-in, first-out manner and pick up and execute the parallel process. This is a method to do so.

(ii) Loop schedule When the parallel process is a DO loop, this method divides the loop repetition and executes the process in parallel.

Self-scheduling in which one loop iteration is treated as one parallel process
and chunk scheduling (chunk sc
guided self-scheduling, which calculates one parallel process using a simple formula depending on the number of remaining loops.
ing).

The paper states that, based on a theoretical analysis of parallel processing time, the guided self-scheduling is the best in consideration of both processor load balance and division overhead.

[Problem to be solved by the invention] The above conventional technology has the following problems.

First, in the prior art (i) above, a vacant processor is
Parallel processes are taken out and executed on a first-come, first-served basis in the queue, but if there is a large difference in execution time between multiple parallel processes, efficiency will deteriorate.

Next, in the above-mentioned known technology (ii), when there is a branch in the Do loop and the processing time per loop varies depending on the conditions, or for general parallel processes (parallel between DO loops), Not valid.

SUMMARY OF THE INVENTION In order to solve the above-mentioned problems, it is an object of the present invention to implement a simple and practical parallel program that can efficiently minimize execution time, is applicable to general parallel programs, and The purpose of the present invention is to provide an execution method, a compiler for the same, and a parallel process scheduling support tool.

[Means for Solving the Problems] According to a first aspect, the present invention provides an object program that when an object program including parallel processes is executed on a multiprocessor system, when the parallel process becomes executable during the execution of the object program. In the parallel execution method, the parallel processes are registered in a queue, and the parallel processes are taken out from the queue and assigned to each processor, and a series of parallel processes are controlled so that they are taken out from the queue in descending order of the execution cost of each parallel process. A parallel execution method is provided.

In addition, "Register parallel process queue" or "
"Retrieving a parallel process from a queue" specifically means "performing a queue registration or retrieval operation on a process information table representing a parallel process."

In a second aspect, the present invention detects whether or not the execution cost value of a parallel process is specified in the source program in a compiler that converts a source program into an object program, and if it is specified, Set the specified value in the execution cost field in the object program, and if it is not specified, calculate the amount of computation in the parallel process section by focusing on the number of corresponding intermediate words in the compiler and the number of DO loop repetitions. When the calculation result is a constant, it is detected whether or not the calculation result is a constant. If it is a constant, the calculation result is set in the execution cost field in the object program, and if it is not a constant, the calculation result is The present invention provides a compiler characterized in that it generates a code for performing the calculation and a code for setting the calculation result in an execution cost field.

In a third aspect, the present invention compiles and executes an input source program with a dynamic profile option, and provides dynamic profile information indicating the number of machine language instructions and the number of executions corresponding to each statement of the source program. Provided is a parallel process schedule support tool that is characterized in that it calculates the sum of execution costs of statements belonging to each parallel process from the dynamic profile information, and outputs a source program with the sum added as execution cost value information. do.

[Operation] In the parallel execution method of the present invention, a series of parallel processes are taken out of the queue in descending order of execution cost, and
Assigned to each processor and executed.

Therefore, compared to the case where the parallel processes are taken out of the queue on a first-come, first-served basis (in the order in which parallel processes appear in the program) and assigned to each processor for execution, execution starts from the parallel process that is closer to the critical path. This will greatly improve execution speed.

In the compiler of the present invention, if an execution cost value of a parallel process is specified in the source program, that value is set as the execution cost in the object program. If no execution cost value is specified in the source program, the amount of computation of the parallel process is calculated, and if the calculation result is a constant, that constant is set as the execution cost in the execution cost field in the object program. If the calculation result does not become a constant, a code for performing the calculation and a code for storing the calculation result in the execution cost field of the object program is generated in the object program.

Therefore, the above parallel execution method can be applied to general parallel programs.

In the parallel process schedule support tool of the present invention, when a source program without a parallel process execution cost value is manually written, the execution cost of each parallel process is calculated, and the source program with a parallel process execution cost value specification is calculated. Output.

Therefore, the above parallel execution method can be applied to general parallel programs.

[Example] Hereinafter, an example of the present invention will be described with reference to the drawings. Note that the present invention is not limited thereby.

FIG. 6 shows an example of a source program written in FORTRAN.

This source program consists of a program section A of a single Do loop, a program section B of a double Do loop, and a program section C that calls a subroutine SUB.

The parallelization directive rpoption paracaseJ specifies that each of the program section A, program section B, and program section C can be executed in parallel. Therefore, these program part A, program part B
, program portion C are called parallel process A, parallel process B, and parallel process C, respectively.

In this way, the parallelization directive rpoption parac
Is it possible to write aseJ in the source program to notify the compiler of the parallelizability? In addition, is it possible to determine the parallelizability by the compiler itself using the technology disclosed in JP-A-1-108638? You can also do it.

The compiler generates an object module 9 as shown in FIG. 7 from the source program.

This object module 9 includes a command word area 10,
It consists of a data area 20 and parallel process execution information 30. Of this configuration, the components other than the parallel process object instruction sequence 14 and parallel process information 30 are the same as the configuration in the conventional sequential execution method (rHITAc
VO33 optimization FORTRAN770FORT77 E
2. J for TR using HAP FORTRAN77 (80
90-3765-30) See page 476 "Object module configuration").

The parallel process object instruction sequence 14 is a portion storing object instruction sequences of the parallel process A, parallel process B, and parallel process C, respectively. The details are shown in FIG. 9 (however, the instruction sequence is expressed in a FORTRAN-like manner to the extent that the operations related to parallel control can be understood).

The parallel process execution information 30 is provided corresponding to parallel process A, parallel process B, and parallel process C. The parallel process execution information 30 for one parallel process has five fields, as shown in FIG.

■Parallel process object start address field...The start address of the corresponding parallel process in the parallel process object instruction sequence 14 ■Parallel process execution cost field...Estimated execution cost of the corresponding parallel process ■External within the parallel process Reference address field - If there is a reference to an external procedure or external function within a parallel process, the entry address for each of them - Size of work area required for a parallel process: Temporary variables required for execution of a parallel process.

Size of work area required for variables and arrays ■ Initial value information required in the work area required for parallel processes... For example, work area size when the size of the work area cannot be reached by one pace register. For convenience of explanation, such as the base address value of , the parallel process execution information 30 of the parallel process A is appended with raJ and is referred to as 30a.

Each field 31, 32, 33, 34.35 also has raJ
31a, 32a, 33a, 34a, and 35a. Similarly, parallel process B is distinguished by "b", and parallel process C is distinguished by rcJ. When explaining generally, raJ rbJ rcJ will not be added. The details of the parallel process execution information 30a, the parallel process execution information 30b, and the parallel process execution information 30c are
Shown in Figure 0.

In FIG. 10, object start address fields 31a, 31b, and 31C of parallel processes contain start labels LABIO, LABII of parallel processes A, B, and C.
, LAB12 addresses are set. Execution cost field 32a.

32b has not yet been set to a valid value, and the execution cost field 32c has a value of 1010. Since parallel processes A and B have no external references, the external reference address field 33a in the parallel processes
, 33b are not set, and the external reference address field 33c in the parallel process is set to the address "5UB2". Also, a work area size field 34a required for parallel processes.

34b and 34c have 20 bytes, 16 bytes, and 1
2 bytes are set.

Now, the parallel process object instruction sequence 1 shown in FIG.
4, code 261. code 264, code 26
Part 6 is a process for calling the parallel process registration library\DISP, which is one of the runtime libraries, in order to register parallel process A, parallel process B, and parallel process C in the parallel process holding queue. The first argument is the start address of the process execution information of the corresponding parallel process. The second argument is the parallel process registration library\D
This is the address of the process information table generated by the ISP. The third argument is S if the corresponding parallel process is registered at the beginning of a series of parallel processes (parallel process A, parallel process B, parallel process C in the case of Figure 9), and M if it is in the middle. If it is the last one, it will be E.

The method by which the compiler generates a code that calls such a parallel process registration library \DISP is a known technique.

Next, parallel process object instruction string 1 shown in FIG.
4, code 260 and code 263 calculate the execution cost of parallel process A and set that value to the first
Processes stored in the execution cost field 32a of the parallel process A execution information 30a shown in FIG.
The execution cost field 32b of the parallel process A execution information 30b shown in FIG.
This is the process of storing the

The method by which the compiler generates code for calculating and storing such execution costs will be explained with reference to FIG.

In step 501, all parallel processes in the source program (that is, program parts A, B, and C of the source program shown in FIG. 6) are
Step 510 is performed.

In step 502, it is determined whether there is an execution cost specification for a parallel process in the source program. If there is an execution cost designation, the process advances to step 503; otherwise, the process advances to step 504.

The execution cost specification is when the user has written it in the source program, or when it has been set in the source program using a parallel process schedule support tool, which will be described later.

The case where there is no execution cost designation is a case like the source program shown in FIG.

In step 503, the execution cost specification value is set in the corresponding execution cost field of the parallel process execution information 30.

On the other hand, in step 504, all intermediate words in the parallel process are traced while performing the processing in steps 505 to 507.

In step 505, one of the intermediate words is selected depending on the type of the intermediate word.
Set the unit price Tc per execution. For example, if the intermediate word is an external procedure or function call, Tc=1000. For mathematical functions, T c = 100°; for other cases, T c
Set =1. This is set to a relatively large value because, empirically, external procedures and function calls often have high execution costs. Regarding mathematical functions, it is desirable to set execution costs separately for each type of function.

In step 506, a variable indicating the loop length or loop repetition number of the DO loop within the parallel process to which the intermediate word belongs is determined. Since DO loop processing always requires an intermediate word that holds a variable indicating the loop length, it is easy to obtain the variable.

When there are multiple loops as in program part B of the source program shown in FIG. 6, the total number of loop repetitions is determined.

In this example, it is N*M.

In step 507, the unit price Tc of the intermediate word is multiplied by the variable ri to calculate the execution cost for this intermediate word,
This is added to the variable T for calculating the execution cost of the parallel process. That is, TT+TcXL is calculated.

The execution cost T of the parallel process is calculated through steps 504 to 507 above.

For example, in the case of program portion C shown in FIG. 6, if there is one procedure call intermediate word and 10 other intermediate words, T=1000X1+1X10=1010 is calculated.

In step 508, it is determined whether the execution cost T is a constant. If it is a constant, proceed to step 509; if not, proceed to step 510.

In step 509, the value of the execution cost T, which is a constant, is set in the execution cost field of the parallel process execution information 30 of the object module.

The value of the execution cost T becomes a constant when the loop length is a constant or when there is no loop.

For example, in the case of the program portion C shown in FIG. 6, the calculated value of T, 11010J, is set in the execution cost field 32c of the parallel process C execution information 30c shown in FIG.

In step 510, an intermediate word for calculating the execution cost T and storing it in the execution cost field in the parallel process execution information is generated, and
Insert just before the intermediate word that calls SP.

For example, in the case of program section B shown in FIG.
And the number of intermediate words in the double loop of DO30 is 4, and D
Assuming that the number of intermediate words in the single loop of O20 is 5 and the number of intermediate words outside the loop is 10, then T=4XNXM+5
Insert immediately before the intermediate word for calculating XN+10 and storing it in the execution cost field 32b of the parallel process B execution information 30b shown in FIG. 10, or the intermediate word for calling the parallel process registration library\DISP for parallel process B. be done.

As a result of the above processing, after compilation, a code 260 for calculating and storing the execution cost is inserted immediately before the code 261 that calls the parallel process registration library\DISP, and A code 263 for calculating and storing the execution cost is inserted immediately before the code 264 that calls the registered library\DISP.

Next, the parallel execution method will be explained.

When the operating system accepts a processing request (job step) from a user, the operating system executes the user space (address space control block) ASC as shown in FIG.
A BO is generated, a task (task control block) TCBO is generated in the user space ASCBO, and execution of the object module 9 is started.

A user program controlled by the operating system calls the subtask generation library\ATTACH, which is one of the runtime libraries, at the beginning of prologue processing 12, which is the start of the main program.

The subtask generation library \ATTACH is
As disclosed in No. 3-285643, the number of subtasks specified by the user is generated using the PARAM operand of the EXEC statement of the job control language.

As a result, as shown in FIG. 11, subtasks (task control blocks) TCBI, TCB2°, . . . are generated. Note that these subtasks TCB1, TCB2 .・
... is for executing the parallel process extraction execution library\PRC8, which is one of the runtime libraries. Parallel process extraction execution library\PRC
3 will be explained in detail later.

The execution of the instruction sequence is executed by the parallel process object instruction sequence 14
When reaching , the code 260 shown in FIG. 9 is executed to calculate the execution cost of the parallel process A and store it in the execution cost field 32a.

Next, in code 261, the object parallel process registration library\DISP is called.

The parallel process registration library\DISP is shown in Figure 1 (a
) This is the process of the flowchart shown in (b).

In step 101, an area for the process information table 70 as shown in FIG. 12 is secured.

This process information table 70 includes a chain field 71 that serves as a pointer for connecting with other process information tables, and a parallel process execution information address field 72 that holds the start address of process execution information of the corresponding parallel process. ECB (Event Control) is a communication area for notifying the completion of parallel processes.
Block) field 73.

For convenience of explanation, the process information table 70 secured by calling the parallel process registration library \DISP using the code 261 is designated as 70a by adding raJ. Also add raJ to each field 71, 72, 73, 7
1 a, 72 a, and 73 a. Similarly, process information table 70 secured by code 264
For the process information table 70 secured by the code 261, rcJ is added for distinction.

When explaining generally, raJ rbJ rcJ will not be added.

In step 102, O is set as an initial value in each field 71 of the process information table 70, the value of the first argument is set in the parallel process execution information address field 72, and the ECB field 7 for parallel process termination notification is set.
3 is set to O as the initial value.

Parallel process registration library with code 261\DI
When calling the SP, INF is set in the parallel process execution information address field 72a of the process information table 70a.
a is set.

In step 103, it is determined from the third argument whether this is the first registration in a series of parallel processes, and if it is the first registration, the process advances to step 104, and if it is not the first registration, the process advances to step 106.

Parallel process registration library with code 261\DI
When calling SP, the third argument is "S", that is, the first, so the process advances to step 104.

In step 104, the parallel process registration library\DISP is used to temporarily hold the generated process information table 70 for the batch registration of a series of parallel processes.
The address of the process information table 70 is set in the temporary holding queue head pointer TQH of the local data area for execution tasks.

Parallel process registration library with code 261\DI
When calling the SP, as shown in FIG. 13, the address of the process information table 70a is set in the temporary holding queue head pointer TQH.

In step 105, it is determined from the third argument whether the registration is the last in the series of parallel processes, and if it is the last, step 107
Proceed to , and if it is not the last, exit.

Parallel process registration library with code 261\DI
In the SP call, since it is "S", that is, it is not the last, execution of the parallel process registration library\DISP is ended.

In FIG. 9, when the processing of coat 261 is completed, the process proceeds from code 262 to code 263.

Code 263 calculates the execution cost of parallel process B and stores it in the execution cost field 292.

In the next code 264, the parallel process registration library\DISP is called again.

Parallel process registration library with code 264\DI
To call the SP, in step 101 of the flowchart in FIG. 1(a), the process information table 70b is called.
or guaranteed. Further, in step 102, 0 is set in the chain field 71b, INFb is set in the parallel process execution information address field 72b,
ECB field 73b for parallel process termination notification
is set to 0.

Parallel process registration library by coat 264\DI
When SP is called, the third argument is "M", that is, it is not the first, so the process advances from step 103 to step 106.

In step 106, the process information tables 70 registered in order from the time queue head pointer are followed, and the execution cost is determined from the execution cost field in the parallel process execution information pointed to by the parallel process execution information address field 72 of each process information table 70. is compared with the execution cost of the parallel process in the new process information table 70, and the new process information table 70 is first inserted immediately before the registered process information table 70 for which the former is smaller than the latter. That is, a new process information table 70 is inserted into a column of the process information table 70 so that it is arranged in descending order of execution cost.

This will be explained generally with reference to FIG.

Now, in FIG. 14, - time queue head pointer TQ
H, the process information table 70i of the parallel process i, and the process information table 70j of the parallel process j are connected. The execution cost of the parallel process is determined by the parallel process i execution information 30 indicated in the parallel process execution information address field 721 of the process information table 70i.
r set in the execution cost field 32i in i
This is looOJ. The execution cost of parallel process j is r500J set in the execution cost field 32j in the parallel process j execution information 30j pointed to the parallel process execution information address field 72j of the process information table 70j. Here, when connecting the new process information table 70k, assuming that the execution cost for the parallel process is r700J, the registered process information table 70i and the registered process information table 70j
A new process information table 70k is inserted between
The process information tables 70 are arranged in descending order of execution cost.

Parallel process registration library with code 264\DI
In step 106 in calling the SP, the execution cost for the already registered process information table 70a and the execution cost for the new process information table 70b are compared, and if the former is greater than the latter, the new process information is placed after the already registered process information table 70a. table 7
0b are connected, and if the former is smaller than the latter, a new process information table 70b is inserted before the registered process information table 70a.

Next, in step 105, when the parallel process registration library \DISP is called by the code 264, the third argument is "M", that is, it is not the last, so the execution of the parallel process registration library \DISP is ended.

In FIG. 9, when the processing of code 264 is completed, the process proceeds from code 265 to code 266.

In code 266, again the parallel process registration library\
Call DISP. Note that the execution cost of the parallel process C has already been calculated and stored at the time of compilation, as described above.

Parallel process registration library with code 266\DI
When calling the SP, in step 101 of the flowchart of FIG. 1(a), the process information table 70c is
is ensured. Further, in step 102, 0 is set in the chain field 71c, lNFc is set in the parallel process execution information address field 72c,
ECB field 73c for parallel process termination notification
is set to 0.

Parallel process registration library with code 266\DI
When SP is called, the third argument is rEJ, that is, it is not the first argument, so the process advances from step 103 to step 106.

Parallel process registration library with code 266\DI
When calling the SP, in step 106, the execution cost for the registered process information table 70a, the execution cost for the registered process information table 70b, and the execution cost for the new process information table 70c are compared, and the execution costs are ranked in descending order of execution cost. The new process information table 70c is connected as shown in FIG.

Next, in step 105, in the call of the parallel process registration library\DISP by code 266, the third argument is "E", that is, the last argument, so step 1
Proceed to 07.

In step 107, the temporary holding queue that has been created and held so far is exclusively inserted at the head of the parallel process holding queue. Exclusive control is necessary because the parallel process holding queue may be updated simultaneously by other processors. Exclusive control is, for example, HITA
In CM-series, CS (compare a
This can be realized using the nd swap) instruction.

This will be explained generally with reference to FIG.

Now, in FIG. 15, the parallel process holding queue head pointer QH, process S, and process T.

There is a parallel process holding queue that connects process U,
In addition to this, there is a time holding queue head pointer TQH.

Process information table 701. Process information table 7
When registering all the temporary holding queues connected to the process information table 70j in the process information table 70j, the command sequence is as follows.

＊＊＊＊＊＊＊＊＊＊ L R3, TQH L R1, QH LOOP ST R1, Process information team 7'
Le j chain field CS RI R3,
QH BNZ LOOP LR1=O 5T R1,TQH **** * * * Book * * Note that the instruction rLJ loads the operand specified by the second address into the general-purpose register specified by the first address. The instruction rSTJ stores the operand in the general-purpose register specified by the first address in the storage area specified by the second address. The instruction "S" compares the first operand in the general-purpose register specified by the first address and the second operand in the main memory specified by the third address, and if they are equal, the second operand is
Stores the contents of the general-purpose register specified by the address in the second operand location. If they are not equal, the second operand is loaded into the general-purpose register specified by the first address. If the condition code is not O, the instruction rBNZJ branches to the instruction specified by the branch destination address. If the condition code is 0,
No branching.

In the above instruction sequence, if the parallel process holding queue is updated in another processor by rBNZ LOOPJ, the instruction at address LOOP will be re-executed.

Returning to FIG. 1(b), in step 108, the parallel process extraction execution library\PRC8, which will be explained later, is
When there are no parallel processes on the parallel process holding queue, a WAIT macro is issued to put the task in a waiting state in order to make effective use of CPU resources. In this case, WA
The wait bit in the ECH corresponding to the task specified by the IT macro is on. EC for each task
When the weight bit of B is on, PO8T
Issue a macro and release the wait state.

When the processing in step 108 is completed, the execution of the parallel process registration library\DISP is ended.

In FIG. 9, when the processing of code 266 is completed, the process proceeds from court 267 to court 268.

Code 268 calls the parallel process completion waiting library \WAIT, which is one of the runtime libraries. The first argument is the number of parallel processes in the series. The second argument and subsequent arguments are the addresses of the process information table 70a, process information table 70b, and process information table 70c corresponding to parallel process A, parallel process B, and parallel process C.

Waiting for parallel process completion library\WAIT is the process of the flowchart shown in FIG.

In step 151, in order to generate an ECB list for waiting for multiple events, an area of (4 x number of series of parallel processes) bytes is allocated to the parallel process completion waiting library\WA.
Reserved in the local data area for IT execution tasks.

In step 152, a series of process information tables 70
ECB field 7 for parallel process termination notification in
3 addresses are stored in the ECB list in order.

In step 153, the ECB list is used to issue a WAIT macro that waits for the completion of all the series of parallel processes.

The instruction sequence for realizing the above steps 152 and 153 is as follows.

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊L G
Rl, number of 17° recesses LRGR2GRI LGR4=O LOOP L GR3, 17° recess E
CB address ST GR3, ECBL(GR4)A
GR4=4 BCT GR2LOOP S GR4=4 L GR5, ECBL (GR4) OGR5=X-
80000000- 3T GR5, ECBL (GR4) WAIT G
RI ECBLIST=ECBLECBL... ＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
LRJ transfers the operand specified by the second address to the first
Loads the general-purpose register specified by the address. command r
AJ adds the operand specified by the first address to the operand specified by the second address, stores the result in the general-purpose register specified by the first address, and sets a condition code according to the result. The instruction rBCTJ decrements the contents of the general-purpose register specified by the first field, and if the result is not O, branches to the instruction specified by the branch destination address. If it is 0, there is no branch. The instruction "S" subtracts the operand specified by the second address from the operand specified by the first address, stores the result in the general-purpose register specified by the first address, and sets a condition code corresponding to the result. Instruction "0" performs a bit-to-bit OR of two operands and stores the result in the storage area specified by the first address. A condition code is set depending on the result.

The macro instruction "WAITJ" puts the task that issued this macro in a wait state until it receives notification of the occurrence of a specified number of events.

When contacted, control is transferred to this macro issuer task.

In the above instruction sequence, ECBL is a data area for the ECB list.

In step 154, the data area of the ECB list is released after all the series of parallel processes are completed.

The code for parallel process A, the code for parallel process B, and the code for parallel process C are based on the user-specified number of subtasks TCB1, TCB2 . ...
It is called and executed from the parallel process extraction execution library \PRCS, which is executed under .

The processing of the parallel process extraction execution library \PRC8 will be explained with reference to FIG.

In step 201, it is determined whether the parallel process holding queue head pointer QH is 0 or not. If it is 0, step 201
If the value is not 0, the process proceeds to step 202.

When the parallel process holding queue head pointer is QH or O, it means that there are no executable parallel processes remaining. If the parallel process holding queue head pointer QH is not O, it means that there remain executable parallel processes.

In step 202, the process information table 70 is exclusively retrieved from the parallel process holding queue head pointer QH.

In step 203, if the exclusive access fails due to an update of the parallel process holding queue by another processor, the process returns to step 201, and if the exclusive access is successful, the process proceeds to step 204.

\PRC3 can be realized by the following instruction sequence.

＊＊＊＊＊＊＊＊＊ LOOP L RIQH LTRRI RI BZ Processing 208 L R3, (R1) C3R1, R3QH BE Processing 204 B LOOP ＊＊＊＊＊＊＊＊＊ Note that the instruction rLTRJ uses the second operand Load into the location of the first operand. Sets a condition code according to the second operand. If the condition code is 0, instruction r BZJ branches to the instruction specified by the branch destination address. If the condition code is not O, do not branch. If the condition code is O, the instruction BEJ branches to the instruction specified by the branch destination address. If the condition code is not 0, do not branch.

Instruction rBJ unconditionally branches to the instruction specified by the branch destination address.

To explain this with reference to FIG. 16, the result is that the first process information table 70i is extracted from 70j to a series of process information tables 70i, 70 connected to the parallel process holding queue head pointer QH. In this case, in the above instruction sequence, the address of the first process information table 701 is set in register R1. Register R3
, the address of the next process information table 70 after the process information table 70i is set. The B instruction returns to address LOOP when another processor updates the parallel process holding queue.

In step 204, the size field 34 of the work area required for the parallel process in the parallel process execution information 30 pointed to by the parallel process execution information address field 72 of the retrieved process information table 70 is read out, and the work area of that size is read out. , parallel process extraction execution library\PRC3 is secured in the local data area for execution tasks.

In step 205, the start address of the secured work area is set in a register used as a work area pace register. Next, the value of the object start address field 31 of the parallel process in the parallel process execution information 30 pointed to by the parallel process execution information address field 72 of the process information table 70 is read, and the process branches to the address of that value. This runs parallel processes.

In step 206, the work area secured in step 204 is released.

In step 207, a PO3T macro is issued to notify the parent process of the termination of the process. The corresponding ECB field is the ECB field 73 in the process information table 70 for parallel process termination notification.

Now, in step 208, from the viewpoint of effective utilization of CPU resources, a WAIT macro is issued for this task using the ECB corresponding to the execution task, and the task is placed in a waiting state.
Parallel process is parallel process registration library\DISP
When the task is registered, the PO8T macro by the parallel process registration library\DISP is used to control the task to wake up.

In step 209, the ECB corresponding to this task is initialized.

Now, returning to FIG. 7, in the epilogue process 15, which is the end of the main program, the subtask extinction library\DETACH is called, and the subtasks TCBI, TC
B2. ... and terminate the program.

Note that when executed in a multi-user environment, other user space tasks also exist, but the schedule processing in this case is a known operating system control processing, so a description thereof will be omitted.

Furthermore, in the above embodiment, the LIFO (last in, first out) method was used for managing the parallel process holding queue, but the present invention can be similarly applied to cases where the FIFO (first in, first out) method is used. I can do it.

Next, a description will be given of a parallel process schedule support tool that converts a source program without execution cost designation into a source program with execution cost designation added.

FIG. 5 shows the processing of the parallel process schedule support tool.

In step 521, the human source program 526 is
Compile with dynamic profile option, run,
Dynamic profile information 527 of the program is obtained. Compiling and executing with dynamic profile options is a known technique (e.g. rHITAc VO5
3 optimization FORTRAN770FORT77E2 H
For TR using AP FORTRAN77 (8090-3-
765-30) "C0UNT option" on page 42).

As shown in FIG. 17, the dynamic profile information 527 outputs the number of executions, the number of object instructions, and the total number of execution steps (number of executions x number of object instructions) corresponding to each statement of the input source program 526. This shows the load status of the program.

In step 522, the processing of steps 523 to 525 is performed for all parallel processes in the input source program 526.

In step 523, the statement number belonging to one parallel process is determined. This is a parallel directive option para that indicates the start of a parallel process in the input source program.
Parallel directive p indicating the start of the next parallel process from case
This is the number of the statement up to option paracase. Or, from the parallel directive ``portion paracase'' indicating the start of a parallel process to the parallel directive ``portion paracase'' indicating the end of parallel processing.
This is the number of the sentence up to the end.

In step 524, the total number of execution steps of the statement with the statement number obtained in step 523 is calculated using the dynamic profile information 52.
7 and add them to find the total number of all execution steps of the statements belonging to the parallel process.

In step 525, the above-mentioned sum is added as an execution cost to the parallel directive ``option paracase'' indicating the start of the parallel process. In other words, the parallel directive portion paracase (cost='
Convert to the sum value l).

Finally, all parallel directives portion parac
The source program obtained by converting ase is output as an output source program 528.

For example, in the input source program 526 of FIG.
Since the statement with statement number 10.11 constitutes one parallel process, statement number 10.11 in the dynamic profile information 527
The total number of execution steps [500J and r8000J are added to obtain the sum "8500", and this is added to the corresponding parallel directive 531 as the execution cost. Therefore, an output source program 528 having a parallel directive 539 is obtained.

As another example, when the source program shown in FIG. 9 is manually entered into the parallel process schedule support tool, a source program with an execution cost specification as shown in FIG. 18 is obtained.

When a source program with this execution cost specification is compiled under the parallelization compilation option, the 19th
An object module having the parallel process object instruction string shown in the figure and the parallel process execution information shown in FIG. 20 is obtained.

Now, FIGS. 21(a), (b), and (c) are explanatory diagrams showing the effects of the present invention.

As shown in FIG. 21(a), a series of parallel processes a,
b and c, and their execution time is 20.1030.

It is also assumed that parallel processes a, b, and c are written in the order of the source program.

Assume that two CPUs are always given.

If a parallel process holding queue is created in the order of appearance in the source program as shown in the right diagram of FIG. 21(b), processing will start in the order of parallel processes a, b, and c, so
The time chart is shown in the left diagram of FIG. 1(b).

On the other hand, according to the present invention, as shown in the right diagram of FIG. 21(c), a parallel process holding queue is created for the execution costs of parallel processes a, b, and c.
Since the processing is started in the order of , b, the time chart shown in the left diagram of FIG. 21(C) is obtained.

As is clear from a comparison of the time chart shown in the left diagram of FIG. 21(b) and the time chart shown in the left diagram of FIG. 21(c), the present invention has the effect of shortening the processing time.

[Effects of the Invention] According to the parallel execution method of the present invention, in scheduling parallel processes, parallel processing is started in descending order of the execution cost of each parallel process, so execution processing time can be shortened, and efficient parallel processing can be achieved. It has the effect of realizing processing. In particular, if there is a nest of parallel processing in which a parallel process generates further parallel processes, the effects of the present invention will be greater because the execution costs of the parallel processes will vary widely.

Furthermore, according to the compiler of the present invention, an execution cost specification is added to the object at the time of compilation, and if the execution cost is not known at the time of compilation, a code for calculating the execution cost is added to the object, so that it can be used for general source programs. This has the effect of making it possible to apply the above parallel execution method to the above.

Furthermore, according to the parallel process schedule support tool of the present invention, since the program is actually executed and the execution cost is reflected in the program, the execution cost can be estimated more accurately even when the parallel process part has external calls. This has the effect of enabling efficient parallel execution.

[Brief explanation of drawings]

FIGS. 1(a) and (b) are flowcharts of main parts of the processing of the parallel process registration library according to an embodiment of the parallel execution method of the present invention, and FIG. FIG. 3 is a flowchart of the main part of the process of the process completion waiting library, FIG. 3 is a flowchart of the main part of the process of the parallel process extraction execution library according to an embodiment of the parallel execution method of the present invention, and FIG. 4 is an implementation of the compiler of the present invention. A main part flowchart of the execution cost calculation process according to the example,
FIG. 5 is a flowchart of a main part of processing of an embodiment of the parallel process schedule support tool of the present invention, FIG. 6 is an exemplary diagram of a source program, FIG. 7 is a conceptual diagram of an object module according to the present invention, and FIG. 8 9 is a conceptual diagram of parallel process execution information according to the present invention, FIG. 9 is an exemplary diagram of a parallel process object instruction sequence, FIG. 10 is an exemplary diagram of parallel process execution information, FIG.
Figure 2 is a conceptual diagram of a process information table, Figure 13 is a conceptual diagram of a temporary holding queue, Figure 14 is a conceptual diagram of updating a temporary holding Kinney, and Figure 15 is a conceptual diagram of registering a temporary holding queue in a parallel process holding queue. Conceptual diagram, Figure 16 is a conceptual diagram of updating the parallel process holding queue, Figure 17 is a conceptual diagram showing the relationship between the source program and dynamic profile information, and Figure 18 is the output source by the parallel process schedule support tool of the present invention. An example diagram of a program, FIG. 19 is an example diagram of a parallel process object instruction sequence of an object module corresponding to the source program of FIG. 18, and FIG. 20 is parallel process execution information of an object module corresponding to the source program of FIG. 18. An illustrative diagram of FIG. 21 (
a) (bHc) is a conceptual diagram explaining the present invention in detail; (Explanation of symbols) \DISP...Parallel process registration library\WA
IT...Parallel process completion waiting library\PRC
S...Parallel process extraction execution library 501-5
10...Compiler execution cost calculation processing 521-525...Parallel process schedule support tool processing 30
...Parallel process execution information 32...Parallel process execution cost field 260.
263...Code for calculating and storing execution costs.

Claims (1)

[Claims] 1. When an object program including parallel processes is executed on a multiprocessor system, the parallel process is registered in a queue when the parallel process becomes executable during execution of the object program; A parallel execution method in which parallel processes are taken out from the queue and assigned to each processor, characterized in that a series of parallel processes are controlled so that each parallel process is taken out from the queue in descending order of execution cost. 2. In the parallel execution method according to claim 1, in order to register the parallel process in the queue, a runtime library for parallel process queue registration is called, and interface information to the runtime library is set in the execution cost field of the object program. The runtime library connects a series of parallel processes in descending order of execution cost, and uses a first-in, first-out method for queue management when requesting queue registration for the last parallel process in the series of parallel processes. connect the process pointed to by the pointer that holds the end of the queue and the parallel process with the maximum execution cost of the series of parallel processes;
Furthermore, the pointer holding the end of the queue is rewritten to point to the parallel process with the lowest execution cost of the series of parallel processes, the series of parallel processes are collectively registered in the queue, and the parallel processes are removed from the queue. In order to take out the queue, the queue is monitored, and when a parallel process exists on the queue, the parallel process indicated by a pointer holding the head of the queue is taken out from the queue. . 3. In the parallel execution method according to claim 1, in order to register the parallel process in the queue, a runtime library for parallel process queue registration is called, and interface information to the runtime library is set in the execution cost field of the object program. The runtime library connects a series of parallel processes in descending order of execution cost, and uses last-in-first-out as queue management when requesting queue registration for the last parallel process in the series of parallel processes. connect the process pointed to by the pointer holding the end of the queue to the parallel process with the minimum execution cost of the series of parallel processes,
Furthermore, the pointer holding the end of the queue is rewritten to point to the parallel process with the highest execution cost of the series of parallel processes, the series of parallel processes are collectively registered in the queue, and the parallel processes are removed from the queue. In order to take out the queue, the queue is monitored, and if there is a parallel process on the queue, the parallel process indicated by the pointer holding the end of the queue is taken out from the queue. . 4. A compiler that converts a source program into an object program detects whether a parallel process execution cost value is specified in the source program, and if so, converts the specified value into an object program. If set in the execution cost field in the program, but not specified, the calculation result will be Detect whether it is a constant or not. If it is a constant, set the calculation result in the execution cost field in the object program. If it is not a constant, write the code that performs the calculation and the execution cost in the object program. A compiler that generates a code for setting the calculation result in a field. 5. Compile the input source program with the dynamic profile option, execute it, obtain dynamic profile information indicating the number of machine language instructions and the number of executions corresponding to each statement of the source program, and calculate the dynamic profile information. A parallel process schedule support tool characterized by calculating the sum of execution costs of statements belonging to each parallel process from , and outputting a source program with the sum added as execution cost value information.