WO2008041442A1 - Procédé de création de programme par parallélisation, dispositif de création de programme par parallélisation, et programme de création de programme par parallélisation - Google Patents

Procédé de création de programme par parallélisation, dispositif de création de programme par parallélisation, et programme de création de programme par parallélisation Download PDF

Info

Publication number
WO2008041442A1
WO2008041442A1 PCT/JP2007/067310 JP2007067310W WO2008041442A1 WO 2008041442 A1 WO2008041442 A1 WO 2008041442A1 JP 2007067310 W JP2007067310 W JP 2007067310W WO 2008041442 A1 WO2008041442 A1 WO 2008041442A1
Authority
WO
WIPO (PCT)
Prior art keywords
procedure
program
vertex
dependency
vertices
Prior art date
Application number
PCT/JP2007/067310
Other languages
English (en)
French (fr)
Inventor
Makiko Ito
Hideo Miyake
Atsuhiro Suga
Original Assignee
Fujitsu Limited
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Fujitsu Limited filed Critical Fujitsu Limited
Publication of WO2008041442A1 publication Critical patent/WO2008041442A1/ja

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/45—Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions
    • G06F8/456—Parallelism detection
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/43—Checking; Contextual analysis
    • G06F8/433—Dependency analysis; Data or control flow analysis

Definitions

  • the present invention generally relates to a program generation method, apparatus, and program, and more particularly to a parallelized program generation method, apparatus, and program.
  • Patent Document 1 data dependency in a loop is analyzed, the array is divided, and the processing of the loop is executed by a plurality of processors. This method is effective when there are many regular loops such as numerical calculations! /.
  • Patent Document 2 shows a method of replacing speculative thread execution by focusing on branching in a sequential program. This method parallelizes the program based on the flow of control. Therefore, it cannot be said that the potential parallelism of the program has been sufficiently extracted. In addition, it has no speculative thread execution mechanism! Because of the high cost of the callback when a prediction failure occurs in a multiprocessor! /, The branch prediction hit rate is low! /. Not suitable.
  • a method for controlling the execution of each thread of a parallelized program for example, a method for executing a thread in parallel by calling a procedure as an asynchronous remote call, or by sending a message for starting execution to a procedure
  • a method of executing threads in parallel, a method of executing threads in parallel by transferring shared I / O variables between threads using a shared memory, etc. are conceivable.
  • an instruction that waits for the end of the first procedure and an instruction that executes the second procedure that follows are sent. Estimate the time required to execute other procedures and place it in an appropriate place in the program. In this case, when the first procedure is completed earlier than expected, an unnecessary waiting time is generated before the second procedure is executed.
  • FIG. 1 is a diagram for explaining the occurrence of useless waiting time.
  • processor 0 executes the thread control program 1 (a program for controlling the execution and completion waiting of the procedure corresponding to each thread).
  • processor 0 first requests processor 1 to processor 3 to execute procedures A to C in order (start A () to start C ()).
  • Processor 0 then waits for procedure A to end (wait AO), and requests execution of procedure D using the execution result of procedure A (start D ()).
  • start D execution result of procedure A
  • start D start D
  • start D start D
  • start D execution result of procedure A
  • start E start E
  • start E start E
  • start E start E
  • Such an instruction arrangement is based on an estimate that procedure B will finish execution earlier than procedure C. If procedure C is known to finish earlier than procedure B, place procedure C completion request and procedure F execution request ahead of procedure B termination request and procedure E execution request. It is possible to do. In practice, however, it is impossible to accurately estimate the end time because the time required for executing the procedure depends on the contents of the processing data. Therefore, the above-mentioned methods such as simple remote procedure call, shared memory thread, and message transmission cannot eliminate the waiting time shown in Fig. 1.
  • the use of the asynchronous remote procedure call method with dependency wait described above can prevent the occurrence of unnecessary wait time during the execution of the parallelized program. Therefore, when creating a non-speculative parallel program that operates effectively on a multiprocessor by parallelizing sequential programs for large-scale software, the above-described asynchronous with wait for dependency relationship is used. It would be desirable to generate a parallelized program applicable to the remote procedure call method.
  • Patent Document 1 Japanese Patent No. 3028821
  • Patent Document 2 Japanese Patent No. 3641997
  • Non-patent text Il U David W. Wall. Limits of Instruction-Level Parallelism. Proceedings of the fourth international conference on Architectural support for programming langu ages pp. 176-188 May. 1991.
  • Non-Patent Literature 2 S. Horwitz, J. Prins, and T. Reps, "Integrating non-interfering versio ns of programs, ACM Transactions on Programming Languages and Systems, vol. 1 1, no. 3, pp. 345-387, 1989.
  • Non-Patent Document 3 Jeanne Ferrante, Karl J. Ottenstein, Joe D. Warren, "The Program D ependence raph and Its Use in Optimization, ACM Transactions on Programming
  • Non-Patent Document 4 Susan Horwitz, Jan Prins, Thomas Reps, "On the adequacy of progra m dependence graphs for representing programs' Proceedings of the 15th Annual A
  • Non-Patent Document 5 Ikuo Nakata: “Compiler construction and optimization", Asakura Shoten, 1999
  • the present invention is a method, apparatus, and program for generating a parallel program based on non-speculative and dependency waiting that effectively operates on a multiprocessor for large-scale software
  • the purpose is to provide.
  • the parallelized program generation method has a sequential program as an input, has each sentence constituting the sequential program as vertices, and has a relation between the sentences as sentences between the vertices. And generating a degenerate program dependency graph in which the number of vertices is reduced by fusing the vertices of the program dependency graph, calculating the execution order of the vertices of the degenerate program dependency graph, and The vertex sequences that are executed in order without including any branching or merging among the plurality of vertices given the execution order are collected as basic blocks, and procedures corresponding to the vertices of the degenerate program dependence graph are performed. Create and wait for the preceding procedure for procedures that have dependencies between the basic blocks.
  • Execute the procedure by placing an instruction to execute the subsequent procedure after the matching instruction, and generating an instruction to register the dependency of the subsequent procedure with respect to the preceding procedure for the procedure having the dependency within the same basic block.
  • Each step of generating a procedure control program for controlling the process is included.
  • the parallelized program generation device includes a memory that stores a sequential program and a parallelized program generation program, and the sequential program stored in the memory by executing the parallelized program generation program stored in the memory.
  • An arithmetic processing unit that generates a parallelized program from the program, and the arithmetic processing unit executes each of the parallelized program generating programs to have each sentence constituting the sequential program as a vertex, and A program dependence graph having the relation between the vertices as edges between the vertices, and generating a degenerate program dependence graph in which the number of vertices is reduced by fusing the vertices of the program dependence graph,
  • the execution order of the vertices of the degenerate program dependence graph is calculated, and the plurality of vertices given the execution order Among them, a sequence of vertices that are executed in order without including any branching or merging is collected as a basic block, and a procedure corresponding to each vertex of the degenerate program dependency graph is
  • an instruction that executes a subsequent procedure is placed after the instruction that waits for the preceding procedure, and for a procedure that has a dependency within the same basic block, an instruction that registers the dependency of the subsequent procedure with respect to the preceding procedure.
  • a procedure control program that controls the execution of the procedure is generated.
  • the parallelized program generation program has a sequential program as an input, has each sentence constituting the sequential program as a vertex, and has a program dependency depending on a relation between the sentences as an edge between the vertices.
  • Generate a graph merge the vertices of the program dependency graph, generate a degenerate program dependency graph with a reduced number of vertices, calculate the execution order of the vertices of the degenerate program dependency graph, and execute the execution Among the plurality of vertices given the order, the vertex sequences that do not include any branching or merging are collected as basic blocks, and a procedure corresponding to each of the vertices of the degenerate program dependence graph is generated.
  • a parallelized program is generated based on a program dependency graph that is a graph indicating a control dependency not in a control flow graph.
  • the parallelism of programs exceeding) can be extracted. Also, by reducing the scale of the graph by reducing the program dependence graph, it becomes possible to improve the efficiency and optimization of the subsequent parallel program generation process, and to achieve parallelization with a large granularity.
  • the subsequent procedure is executed after waiting for the completion of the preceding procedure.
  • the procedure is executed by an asynchronous remote procedure call with a dependency waiting.
  • an instruction that executes the subsequent procedure is placed after the instruction that waits for the preceding procedure, and the dependency is specified implicitly according to the order in which the instructions are placed. And control the procedure to satisfy the dependency.
  • a procedure that explicitly registers the dependency of the subsequent procedure on the preceding procedure is generated, and the procedure is controlled to satisfy the dependency.
  • FIG. 1 is a diagram for explaining the occurrence of useless waiting time.
  • FIG. 2 is a diagram for explaining procedure execution control by an asynchronous remote procedure call method with dependency waiting. 3] It is a diagram showing an outline of a parallelized program generation method according to the present invention.
  • FIG. 5 is a diagram showing a procedure program generated by the procedure program generation method of FIG.
  • FIG. 6 is a flowchart showing a method for generating a procedure control program.
  • FIG. 7 is a flowchart showing a method for determining an execution order relationship between vertices.
  • FIG. 8 is a flowchart showing a process (step S2 in FIG. 7) for reconfiguring the control flow below vertex V.
  • FIG. 9 is a flowchart showing a process for calculating the execution order relation of Regions.
  • FIG. 10 is a flowchart showing processing for obtaining inverse dependence and output dependence (step S4 in FIG. 9).
  • FIG. 13 is a flowchart showing an addition process of inverse dependence.
  • FIG. 14 is a flowchart showing an output-dependent addition process.
  • FIG. 15 is a flowchart showing processing for obtaining inverse dependence and output dependence (step S 5 in FIG. 9).
  • Fig. 17 is a diagram schematically showing a spanning tree.
  • FIG. 19 is a diagram for explaining the addition of an inverse dependence edge by the process of FIG.
  • FIG. 20 is a flowchart showing a modification of the method for determining the execution order relationship between vertices.
  • FIG. 21 is a diagram showing a flowchart of processing for extracting a basic block.
  • FIG. 22 is a diagram showing a flowchart of a process for generating a control program.
  • FIG. 23 is a flowchart showing a process for generating a procedure control program for element B and subsequent elements in set B ′ of basic blocks.
  • FIG. 24 is a diagram showing the structure of a procedure control program in the case of the first embodiment.
  • FIG. 25 (a) is a diagram showing the part of the input sequential program, and (b) is the corresponding degenerate program dependency.
  • FIG. 26 is a diagram showing a procedure control program generated according to the first embodiment from the degenerate program dependence graph of FIG. 25.
  • FIG. 27 is a schematic diagram showing the operation of the procedure control program together with the execution of the procedure program.
  • FIG. 28 is a diagram showing a flowchart of processing for generating a control program in the case of the second embodiment.
  • FIG. 29 is a flowchart showing a process for generating a procedure control program below element B of a set B ′ of basic blocks.
  • FIG. 30 is a diagram showing a structure of a procedure control program in the case of the second embodiment.
  • FIG. 31 is a diagram showing a procedure control program generated according to the second embodiment from the degenerate program dependence graph of FIG. 25.
  • FIG. 32 is a schematic diagram showing the operation of the procedure control program together with the execution of the procedure program.
  • FIG. 33 is a diagram showing a configuration of an apparatus for executing the parallelized program generation method according to the present invention.
  • FIG. 2 is a diagram for explaining control of procedure execution by the asynchronous remote procedure call method with dependency waiting.
  • the dependency on other procedures is specified as an execution condition for each procedure, each procedure is placed in the execution queue for each processor, and the procedure that satisfies the execution condition A method of executing the above is conceivable. This method is called the asynchronous remote procedure call method with dependency waiting.
  • processor 0 executes thread control program 2 (a program that controls the execution of the procedure corresponding to each thread and its dependency). At this time, the processor 0 executes the procedure call program 3 to manage each procedure defined in the thread control program 2 by using a queue for each processor.
  • thread control program 2 a program that controls the execution of the procedure corresponding to each thread and its dependency.
  • the processor 0 executes the procedure call program 3 to manage each procedure defined in the thread control program 2 by using a queue for each processor.
  • the procedure A is put into the execution queue 4 of the processor 1 in accordance with the instruction start A () of the control program 2.
  • the procedure B is put into the execution queue 5 of the processor 2.
  • the procedure C is input to the execution queue 6 of the processor 3.
  • procedures D, E, and F are input to execution queues 4 to 6, respectively, according to instructions start D (), start E (), and start F () of control program 2.
  • thread control product The d mark (x, y, ⁇ ) in column 2 is an instruction that specifies the dependency relationship, and indicates that the dependency destination of the procedure X is the procedure Y, • ⁇ ⁇ ⁇ . That is, in order to execute procedure X, it is necessary that the execution of procedure ⁇ , ... must be completed.
  • the instruction d (D, A) of the control program 2 it is registered that the dependent procedure is A for the procedure D in the execution queue 4 of the processor 1.
  • the procedure put in the execution queue provided for each processor in this way is executed by the corresponding processor according to the order of the queue.
  • the procedure for which the dependency destination is not registered (the procedure indicated by NULL in Fig. 2) is executed unconditionally, and the procedure where the dependency destination is registered! /! Execute after detecting the end of the dependent procedure.
  • a queue is provided for each processor, and the waiting time as shown in Fig. 1 is eliminated by executing the procedures in the queue (executable procedures) that satisfy the execution conditions in order. That's the power S.
  • FIG. 3 is a diagram showing an outline of a parallelized program generation method according to the present invention.
  • step S1 a program dependency graph (PDG) is generated from the sequential program.
  • step S2 a degenerate program dependency graph with the procedure as a vertex is created by reducing the dependency until the amount of processing suitable for execution by another processor element as a procedure is reached.
  • step S3 a procedure control program that non-speculatively controls procedure activation and synchronization is generated from the generated degenerate program dependency graph.
  • step S4 a procedure program corresponding to each vertex is generated from the reduced program dependence graph.
  • step S1 in FIG. 3 the process of generating a program dependence graph from a sequential program (step S1 in FIG. 3) will be described.
  • the program dependence graph is a graph in which the sentence of the program is a vertex and the relationship between the sentences is represented by an edge.
  • the program dependence graphs described in Non-Patent Documents 2 to 4 are the following sets of vertex set V and edge set E: It can be generated by analyzing sequential programs.
  • Initial definition represents the definition of the initial value at the start of the program.
  • Predicate Indicates if-then-else or while-loop condition determination.
  • Assignment statement represents an assignment statement of a program.
  • Last use represents a reference to a variable at the end of the program.
  • step S2 in FIG. 3 the process for creating a degenerate program dependence graph
  • Degeneration of the dependency relationship is performed by obtaining a set of dependency relationships and vertices that can be degenerated in the following manner, deleting the dependency relationship, and merging the vertices into one vertex.
  • control structure of the program to be expressed is limited to i ⁇ , while statements, and assignment statements, and the control dependence subgraph of the program dependence graph (partial graph consisting only of vertices and control dependence edges) It is known that the flow of program control can be reconfigured when the shape of the tree is a tree structure (Non-patent Document 2). Therefore, by degenerating the entire control statement lock and non-while statements in the program and the dependency within the block into one vertex, a degenerate program dependency graph is created that can safely reconfigure the control flow.
  • the degree of coupling shall be calculated from the data-dependent edge and its size, the control-dependent edge, and the processing size. If vertices with a certain degree of connectivity or higher satisfy the contractible condition, the vertices are joined to reduce the dependency. Here, when the following two conditions are satisfied, reduction by combining vertices is possible. [0049] 1) On the CFG (Control Flow Graph) corresponding to the program dependence graph, the branch from outside the vertex set to inside the vertex set is only to the first vertex of the vertex set, and from the vertex set to the vertex The only branch out of the set is the last vertex in the vertex set.
  • degenerate program dependence graph in which the number of vertices is significantly reduced by "degeneration based on syntax rules" or "degeneration based on connectivity”.
  • the degenerate program dependence graph consists of the following elements.
  • Initial definition represents the definition of the initial value at the start of the program.
  • Predicate Indicates if-then-else or while-loop condition determination.
  • Set of sentences represents a set of sentences constituting a program.
  • Last use represents a reference to a variable at the end of the program.
  • the vertices of the degenerate program dependence graph generated as described above are a subset of the sentences of the input sequential program and have information on the flow of control between sentences. Therefore, one procedural program is generated for one vertex, taking as input the variable represented by the dataflow input edge to one vertex of interest and outputting the variable represented by the dataflow output edge.
  • the body of the procedure program is generated from the flow of control, and local variables necessary for the execution of the body are generated.
  • FIG. 4 is a diagram showing an outline of a procedure program generation method.
  • FIG. 5 is a diagram showing a procedure program generated by the procedure program generation method of FIG.
  • step S1 of Fig. 4 a program part for receiving the input variable as an argument is generated by using the variable represented by the data flow input side for the target vertex. As a result, the argument receiving part 10 of the input variable shown in FIG. 5 is generated. In step S2, the necessary variables are searched. In step S3, a variable declaration is generated for the variable found by the search. As a result, the variable declaration part 11 shown in FIG. 5 is generated.
  • step S4 the body of the program is generated based on the control flow information between the sentences at the vertex of interest. As a result, the program body 12 shown in FIG. 5 is generated.
  • step S5 a program part is generated for returning the variable represented by the data flow output edge of the target vertex as an output. As a result, the output variable set portion 13 shown in FIG. 5 is generated.
  • the procedure program is a procedure for executing a sentence / sentence set represented by a vertex. Also, create a procedure that takes an input variable as a procedure argument and an output variable as a return value or an address that stores the output variable as an argument.
  • Non-Patent Document 2 Based on the technology described in Non-Patent Document 2, it is possible to safely reconfigure the control flow from the degenerated program dependence graph. Specifically, the execution order relation of the program is calculated for the control dependence subtree of the reduced program dependence graph, and the basic block is obtained.
  • a basic block is a sequence of vertices that are executed in an order that does not include branching (IF, GOTO, LOOP, etc.) or confluence.
  • a parallel program can be generated by generating a program that calls the control structure represented by each intermediate node and the “procedure” represented by the child vertex. It also generates code to send and receive and wait for input and output data needed to execute the “procedure”. The dependency of the procedure call and data transfer in the basic block is controlled using the dependency waiting mechanism.
  • the first example is an example of realizing the asynchronous remote procedure call method with dependency waiting with a shared memory
  • the second example is an asynchronous remote procedure calling method with dependency waiting with a distributed memory. It is an example. First, parts common to the first embodiment and the second embodiment will be described.
  • FIG. 6 is a flowchart showing a procedure control program generation method.
  • step S1 the execution order relation between vertices is calculated.
  • the degenerate program dependency graph is a graph that expresses only the dependency relationship between data and control, and the execution order between vertices is not specified. Therefore, it is necessary to reconstruct the appropriate control flow from this. Therefore, the execution order of the child vertices of each intermediate node is calculated for the control dependency subtree of the reduced program dependency graph. As a result, a partial order relationship between the vertices can be obtained.
  • a control program is generated using this execution order relationship. In the course, inverse dependency and output dependency are extracted.
  • step S2 basic blocks are extracted from the obtained execution order (control flow).
  • step S3 control program variables and initial value assignment statements are generated.
  • parallelism may be improved by converting to a static single assignment form (Non-Patent Document 5, page 320).
  • a variable for transferring data is generated as a variable.
  • step S4 a control dependence subgraph is searched in the order of execution obtained in S1, and a control program is generated.
  • a control structure that the vertex represents is generated.
  • the control program of the subtree below the vertex is generated as the text of the control structure.
  • basic blocks generate a statement that performs asynchronous remote procedures based on dependencies. This will be described in detail below.
  • FIG. 7 is a flowchart showing a method for determining an execution order relationship between vertices.
  • the process in FIG. 7 corresponds to step S 1 in FIG.
  • the input of the process shown in Fig. 7 is the degenerated program dependence graph PDG, and the output is the degenerated program dependence graph PDG and its control flow.
  • step S1 the entry vertex (program start point) of the degenerated program dependence graph PDG is set to V.
  • step S2 the control flow below vertex V is reconfigured. This completes the process.
  • FIG. 8 is a flowchart showing a process of reconfiguring the control flow below vertex V (step S 2 in FIG. 7).
  • the inputs of the process in Fig. 8 are the degenerate program dependence graph PDG and vertex V.
  • V is a vertex set
  • E edge set
  • step S2 the execution order relation of Region (v, T) is calculated.
  • FIG. 9 is a flowchart showing a process of calculating the execution order relationship of Regions. This processing corresponds to each of step S2 and step S4 in FIG.
  • the input of the process in Fig. 9 is the degenerated program dependence graph PDG and V '(region of interest).
  • step S 1 a loop that repeats the processing in steps S 2 to S 3 is started for each vertex V of the region of interest V ′.
  • step S2 it is determined whether or not V is a predicate vertex (a vertex representing an If-then-else or while-loop condition determination).
  • step S3 only if V is a predicate vertex.
  • step S3 the execution order relation below vertex V is calculated.
  • step S4 inverse dependence and output dependence are obtained.
  • the data dependence (inverse dependence, output dependence) due to the flow of control is extracted.
  • the inverse dependence and output dependence in the attention area are expressed from the data dependence relation exceeding the attention area (Region).
  • step S 5 inverse dependence and output dependence are obtained.
  • the execution order in the region of interest (Region) is determined.
  • an appropriate execution order constraint is determined for the set of vertices in the Region whose execution order is not uniquely determined.
  • the execution order is determined by clarifying the reverse dependency relation and output dependency relation within the region based on the execution order constraints based on the obtained reverse dependence relation and output dependence relation. If the execution order is arbitrary, the reverse order and output dependency are obtained assuming the execution order, and the trial is repeated until an execution order that does not cause inconsistencies is obtained.
  • step S6 scheduling is performed in step S6. That is, the execution order of the vertices is determined based on the execution order relationship obtained above. This can be reduced to the general problem of scheduling graphs with partial order relations. Therefore, well-known scheduling methods such as topological “sorting” and “list with weighted approximation of vertex execution time” scheduling can be applied.
  • FIG. 10 is a flowchart showing a process for obtaining inverse dependence and output dependence (step S 4 in FIG. 9).
  • the input of the processing in Fig. 10 is the reduced program dependence graph PDG and V '(region of interest). .
  • step S1 a variable reference exceeding the region of interest V 'is extracted and set to V. Def in step S2
  • step S3 variable substitution exceeding the region of interest V 'is extracted as V.
  • step S3 add an inverse dependency edge to V and V 'based on use use.
  • step S4 def the output dependent edge based on V and V
  • FIG. 11 is a flowchart showing a process of extracting a variable reference that exceeds the region of interest.
  • Fig. 11 corresponds to step S1 in Fig. 10, and the degenerate program dependence graph PDG and V, (region of interest) are input.
  • step S1 the vertex set V is emptied.
  • step S2 use each flow in the area of interest V '
  • the flow-dependent edge includes a loop-independent flow-dependent edge and a loop carry-over flow-dependent edge.
  • Step S In step 3, u is the source vertex of the flow-dependent edge e, and V is the destination vertex of the edge e.
  • step S4 it is determined in step S4 whether or not the condition that the dependency destination vertex V is included in the attention area V ′ is satisfied. If it is a loop-independent flow dependent edge, it is checked in step S5 whether or not the condition that the dependency source vertex u is not included in the attention area V ′ and the dependency destination vertex V is included in the attention area V ′ is satisfied. judge. Only when this determination result power is yes, step S6 is executed. In step S6, the dependent vertex V is added to the vertex set V.
  • step S7 the vertex set V is returned as a value. The process ends here.
  • FIG. 12 is a flowchart showing processing for extracting variable substitution exceeding the region of interest.
  • Fig. 12 corresponds to step S2 in Fig. 10, and the degenerate program dependence graph PDG and V, (region of interest) are input.
  • step S1 the vertex set V is emptied.
  • step S2 each flow def in the region of interest V '
  • the flow-dependent edge includes a loop-independent flow-dependent edge and a loop carry-over flow-dependent edge.
  • u is the dependency source vertex of the flow-dependent edge e
  • V is the dependency destination vertex of the edge e.
  • step S4 it is determined in step S4 whether or not the condition that the dependency destination vertex V is included in the attention area V ′ is satisfied. If it is a loop-independent flow dependent edge, in step S5, the dependency source vertex u is not included in the attention area V 'and the dependency destination vertex V is not included in the attention area V'. Determine whether the condition is met. Only in the case of any judgment result power Syes, step S6 is executed. In step S6, the dependent vertex V is added to the vertex set V.
  • step S7 the vertex set V is returned as a value. The process ends here.
  • FIG. 13 is a flowchart showing the inverse-dependent addition process.
  • the process in Fig. 13 corresponds to step S3 in Fig. 10, and the degenerate program dependence graph PDG, V (region of interest), and vertex set V are input.
  • step SI use a loop to repeat the following processing for each vertex V of vertex set V
  • step S2 a loop that repeats the following processing is started for each variable X used at vertex V.
  • step S3 the following processing is repeated for each vertex u of the region of interest V ′. Start a loop that repeats.
  • step S4 it is determined whether or not the vertex u defines a variable X. Only when the judgment result is yes, execute step S5. In step S5, add an inverse dependence edge from V to u. The process ends here.
  • FIG. 14 is a flowchart showing an output-dependent addition process.
  • the process in FIG. 14 corresponds to step S4 in FIG. 10, and the reduced program dependence graph PDG, V (target region), and vertex set V are input.
  • step S I a loop that repeats the following processing is performed for each vertex u of the vertex set V.
  • step S2 a loop that repeats the following processing is started for each variable X used at vertex u.
  • step S3 a loop that repeats the subsequent processing is started for each vertex V of the region of interest V ′.
  • step S4 it is determined whether or not the vertex V defines a variable X. Only when the judgment result is yes, execute step S5. In step S5, an output dependent edge from V to u is added. The process ends here.
  • FIG. 15 is a flowchart showing a process for obtaining inverse dependence and output dependence (step S5 in FIG. 9).
  • the input of the processing in Fig. 15 is the degenerate program dependence graph PDG and V '
  • step S1 a spanning tree in the region of interest is obtained and set as S.
  • the spanning tree for variable X of vertex V is
  • FIG. 16 is a diagram for explaining a spanning tree.
  • variable X is defined at vertex V, and two vertices vl and v2 use variable X.
  • a spanning tree 21 is formed by vertices v, vl, and v2.
  • variable X is defined at vertex V, and two vertices v3 and v4 use variable X.
  • a spanning tree 22 is formed by vertices v, v3, and v4.
  • FIG. 17 is a diagram schematically showing a spanning tree. Spanning tree Span (v, X) and spanning tree Span (v, x) are constructed as shown in Fig.
  • step S2 a loop is started in which two arbitrary spanning trees whose execution order is undetermined are sequentially selected and the subsequent processing is repeated.
  • step S3 whether there are independent spanning trees Span (h, x) and Span (h, x) for the same variable X with a cycle in the region of interest.
  • step S4 the original R (Region) is saved to the stack.
  • step S5 h ⁇ h
  • step S6 the order relation between spanning trees is
  • step S7 it is determined whether or not there is a cycle in R (Region). If not, the subsequent processing steps S8 to S11 are skipped. If yes, go to step S8. In step S8, it is determined whether the stack is empty. If it is empty, the error ends. If not, in step S9, take R's original from the stack.
  • step S11 the order relation between spanning trees is calculated.
  • FIG. 18 is a flowchart showing a process for calculating the order relation between spanning trees.
  • the process in FIG. 18 corresponds to Step S6 and Step S11 in FIG.
  • the input of the processing in FIG. 18 is the degenerated program dependence graph PDG and V ′ (region of interest).
  • step S1 a loop that repeats the subsequent processing is started for each side e (vertex v ⁇ vertex w) in the region of interest.
  • step S2 each variable defined by vertex w and referenced by vertex V Start a loop that repeats the following processing for number x.
  • step S3 V — ⁇ u
  • step S4 a loop for repeating the subsequent processing is started for each vertex V of V.
  • step S5 a loop that repeats the subsequent processing is started for each vertex V of V. More b b
  • step S6 a loop is started in which the following processing is repeated for each vertex v that is a vertex of Span (v, x) and not a vertex of Span (v, x).
  • step S7 it is determined whether vc ⁇ vb is included in E (edge set).
  • Step S8 is executed only when the judgment result is ye s.
  • step S8 add an inverse dependence edge of V ⁇ v and select c b
  • FIG. 19 is a diagram for explaining the addition of an inverse dependence edge by the process of FIG.
  • FIG. 19 shows a spanning tree Span (v, x) for variable X at vertex V and a spanning tree Span (w, x) for variable X at vertex w.
  • spanning tree Span (v, x) for each vertex V (ie, v, 25, 26) of spanning tree Span (v, x) (ie, Span (v, x)) for variable X containing vertex V as an element, spanning tree Span (v, x) Cb of (ie Span (w, x))
  • FIG. 20 is a flowchart showing a modification of the method for determining the execution order relationship between vertices.
  • the process shown in the flowchart of FIG. 20 may be used instead of the process shown in the flowchart of FIG.
  • a process of applying SSA static single assignment form
  • the degenerate program dependence graph may be converted into a static single assignment format.
  • the processing of step S7 shown in FIG. 9 processing for obtaining reverse dependence and output dependence and determining the execution order in the region of interest: the flowchart of FIG. 15
  • step S1 in FIG. 6 the execution order relationship between the vertices can be determined, and the inverse / output dependency relationship can be extracted. That is, the process of step S1 in FIG. 6 is executed.
  • FIG. 21 is a diagram showing a flowchart of processing for extracting a basic block.
  • the process shown in FIG. 21 corresponds to the process of step S2 in FIG.
  • the input of the process in Figure 21 is the execution order. It is a degenerate program dependence graph in which the relationship is determined.
  • Vertices are searched in the order of the obtained control flow, and processing corresponding to the type of vertex is performed.
  • B is a set of basic blocks, and B is the i-th basic block.
  • V is the current vertex (the target vertex), and u is the vertex just before the current vertex.
  • step S2 the first basic block BO is generated as an empty set.
  • step S2 u is the entry vertex (program start point) and V is the next vertex of the entry vertex.
  • step S4 it is determined whether or not the current vertex V is the final vertex. If it is the final vertex, the processing is terminated and a set B of basic blocks is generated.
  • step S5 If the current vertex V is not the final vertex, the process proceeds to step S5, and whether or not the current vertex V is a predicate vertex (a vertex representing a conditional judgment of If-then-else or while-loop). Determine whether or not. If it is a predicate vertex, the process proceeds to step S6, and after incrementing i, the element after is set to V to form a new predicate-only basic block B. Thereafter, in step S7, i is further incremented to form a new empty set basic block B.
  • a predicate vertex a vertex representing a conditional judgment of If-then-else or while-loop.
  • step S8 If the current vertex V is not a predicate vertex (if S5 is No), in step S8, the current vertex V and the previous vertex u are controlled dependencies from the same predicate vertex. It is determined whether the control dependency relationship is based on the same condition determination flag. The determination result is NO, for example, when u and V correspond to the inside and outside of the IF statement, or to the THEN clause and ELSE clause of the IF statement. That is, in step S8, it is determined whether or not the two vertices are both executed according to the same condition determination!
  • step S8 If the determination in step S8 is YES, the current vertex V is added to the current basic block in step S9. If the determination in step S8 is NO, in step S10, i is incremented to form a new empty set basic block B. In step S11, the current vertex V is added to the newly generated basic block B. Thereafter, in step S12, u and V are respectively updated to the next vertex, and the process returns to step S4 and the subsequent processing is repeated.
  • each basic block B which is a sequence of vertices that is executed in an order that does not include branching (IF, GOTO, LOOP, etc.) or merging, is generated, and a base that uses these basic blocks as elements A set B of this block can be generated.
  • a sequence of vertices that does not include branching or merging is a sequence of vertices that are executed in order according to a fixed execution order.
  • each predicate vertex constitutes one basic block B by itself, and one basic block that is not a predicate vertex is ordered according to one execution order that is fixed without branching or merging. Will contain the sequence of vertices to be executed.
  • the subsequent procedure is executed after waiting for the completion of the preceding procedure.
  • the procedure is executed by an asynchronous remote procedure call with dependency waiting.
  • the procedure is controlled so that the dependencies are satisfied by placing an instruction that executes the subsequent procedure after the instruction that waits for the preceding procedure.
  • the procedure is controlled so that the dependency is satisfied by generating an instruction that explicitly registers the dependency of the subsequent procedure on the preceding procedure.
  • step S2 in FIG. 6 is executed.
  • a process for generating a control program, a specific example of the generated control program, and the like will be described below.
  • the following explanation is based on the first example in which the asynchronous remote procedure call method with dependency waiting is implemented in shared memory and the second example in which the asynchronous remote procedure call method with dependency waiting is implemented in distributed memory. Different.
  • FIG. 22 is a diagram showing a flowchart of processing for generating a control program.
  • the process shown in FIG. 22 corresponds to the process of step S4 (and S5) in FIG.
  • the input for the process in Figure 22 is A set B of degenerate program dependence graphs and basic blocks whose execution order relations are determined.
  • step S1 the child vertex V immediately below the entry vertex V representing the beginning of the program
  • step S2 Let B 'be the set of basic blocks whose elements are.
  • step S3 for each element B of B ', a loop that repeats the subsequent processing in ascending order of i is started.
  • step S3 a procedure control program for B is generated.
  • step S4 a procedure completion queue is generated.
  • FIG. 23 is a flowchart showing a process for generating a procedure control program below element B of the basic block set B ′.
  • the process in FIG. 23 corresponds to step S3 in FIG.
  • the inputs of the process shown in Fig. 23 are the degenerate program dependence graph PDG and basic block element B.
  • V ' ⁇ veV
  • step S 1 of FIG. 23 the type of element (vertex) of basic block B is determined. By determining the types of vertices that are elements of basic block B, it can be seen whether basic block B is a set of program blocks or a predicate vertex.
  • step S1 If the result of the determination in step S1 is that basic block B is a set of program.blocks, register the statements that call the vertex procedures belonging to basic block B and their dependencies Will generate a sentence. Specifically, first, in step S2, a wait for the preceding procedure of the basic block is generated. At this time, a procedure end wait is generated for the flow dependency from outside the block to inside the block. At the same time, a procedure end wait is generated for the definition order relation, reverse dependence relation, and output dependence relation. This is a wait to guarantee the order in which data is read and written for the same variable in the shared memory.
  • a procedure completion queue for the output source vertex is generated.
  • step S3 for each vertex V of basic block B, a loop that repeats the subsequent processing in the order of execution is started.
  • step S4 an asynchronous remote procedure call for vertex V is generated.
  • step S5 a statement for registering the dependency relationship for the loop independent flow dependency relationship from the vertex belonging to the basic block B to the vertex V is generated. After these processes are repeated for all vertices V of basic block B, a statement that indicates the start of execution is generated in step S6.
  • step S7 a waiting for the preceding procedure of element V of basic block B is generated.
  • a statement that waits for the preceding procedure call is generated for the input flow dependent edge.
  • the flow-dependent edge that carries forward the loop outside the vertex and the loop-independent flow-dependent edge to the vertex a procedure end wait for the output source vertex is generated.
  • step S8 the type of predicate of vertex V is determined. If the predicate is a loop, go to step S9. If the predicate is an if statement, Go to SI 4.
  • step S8 If the determination result in step S8 indicates a loop, a for or while statement corresponding to! / Is generated in the input sequential program in step S9.
  • step S11 for each element B ′ of B ′, a loop is repeated that repeats the subsequent processing in ascending order of i.
  • step S12 a procedure control program for B is generated.
  • This step S12 has a nested structure, and executing step S12 for B corresponds to executing the entire flowchart of FIG.
  • step S13 an end queue for the preceding procedure that carries over the loop to vertex V is generated. This is because the condition is judged by carrying over the loop, so a sentence that waits for input data to the conditional expression (input flow dependent side that carries over the own loop) is added at the end of the text.
  • step S8 If the determination result in step S8 indicates an if statement, an if statement is generated in step S14.
  • step S15 a then clause is generated.
  • step S 17 for each element B ′ of B ′, a loop that repeats the subsequent processes in ascending order of i is started.
  • step S18 a procedure control program for B is generated.
  • This step S 18 has a nested structure, and executing step S 18 for B corresponds to executing the entire flowchart of FIG.
  • the sentence generated in steps S17 and S18 constitutes the body of the then clause.
  • step S20 it is determined whether or not the set B ′ of basic blocks is an empty set. If it is an empty set, the process ends. If the basic block set B ′ is not an empty set, an else clause is generated in step S21.
  • step S22 for each element B of B ′, a loop that repeats the subsequent processing in ascending order of i is started.
  • step S23 a procedure control program for B is generated. This step S23 has a nested structure, and executing step S23 for B is the same as the flow of FIG. This is equivalent to executing one chart. Note that the sentence generated in steps S22 and S23 constitutes the body of the else clause.
  • FIG. 24 is a diagram showing the structure of the procedure control program in the case of the first embodiment.
  • the control program in the first embodiment of the present invention includes a variable declaration initialization part 41, a predicate input data waiting part 42, and a predicate control structure.
  • Generation part 43 input data to the basic block 'dependency waiting part 44, thread activation and dependency registration part 45 in the basic block, and waiting end processing part 46 for procedure end.
  • the input data to the basic block 'dependency waiting part 44 starts asynchronous remote procedure calls, registers dependencies, and dispatches procedures (starts execution).
  • a shared memory common to a plurality of processors is used.
  • the result of the preceding procedure may not be obtained at the stage of instructing the asynchronous remote procedure call, and the value may not be passed as an argument. Therefore, the input / output data of the procedure shall be stored in an appropriate location on the shared memory, and the address shall be passed.
  • the procedure is configured so that the address where the value of the input variable is stored and the address where the output result is stored are used as arguments of the procedure. Furthermore, variables that are used or defined by the vertex part program other than the input variables are obtained, and a declaration part for these variables is generated. In addition, a partial program is output, and finally a statement that assigns the value of the output variable to the address received as an argument is generated.
  • FIG. 25 is a diagram showing (a) the input sequential program portion and (b) the corresponding degenerate program-dependent dialog.
  • a program dependence graph is generated from the input sequential program shown in Fig. 25 (a), and the reduced program dependence graph shown in (b) is generated by combining the vertices and degenerating. Vertex V force, et al. V exists, and vertex V is a set of sentences due to degeneracy.
  • FIG. 26 is a procedure control program generated according to the first embodiment from the degenerate program dependence graph of FIG. There is a variable declaration first, and the variables X, y, z, a, b, and p to be used are declared. After that, first register the start of procedure ⁇ corresponding to vertex V (sentence 51). So
  • the procedure ⁇ which is an executable procedure, is executed by the dispatch instruction (dispatch) after the command.
  • V must wait for V according to the definition order relation
  • FIG. 27 is a schematic diagram showing the operation of the above procedure control program together with the execution of the procedure program.
  • processor 0 and processors corresponding to procedures vO and v2 to v6 are used.
  • the procedure control program is executed by the processor 0.
  • the procedure program 61 for the procedure ⁇ is executed by the corresponding processor. If the condition of the whi le statement is satisfied, the procedure ⁇ is being executed, so wait for the end of ⁇ .
  • the procedure vl belongs to the first basic block
  • the procedures v2 to v5 belong to the second basic block
  • the procedure v3 belongs to the third basic block.
  • the subsequent procedure is executed after waiting for the completion of the preceding procedure.
  • the procedure is executed by calling an asynchronous remote procedure with dependency waiting.
  • FIG. 28 is a flowchart of a process for generating a control program in the case of the second embodiment.
  • the process shown in FIG. 28 corresponds to the process of step S4 (and S5) in FIG.
  • the input of the processing in FIG. 28 is a set B of a degenerate program dependence graph and basic blocks whose execution order relationship is determined.
  • step S1 the child vertex V immediately below the entry vertex V representing the beginning of the program
  • step S2 Let B 'be the set of basic blocks whose elements are.
  • step S3 for each element B of B ', a loop that repeats the subsequent processing in ascending order of i is started.
  • step S3 a procedure control program for B is generated.
  • step S4 a procedure output data transfer queue is generated.
  • FIG. 29 is a flowchart showing a process for generating a procedure control program below element B of the set B 'of basic blocks.
  • the process in FIG. 29 corresponds to step S3 in FIG.
  • the inputs for the processing shown in Fig. 29 are the degenerate program dependence graph PDG and basic block element B.
  • step S 1 of FIG. 29 the type of element (vertex) of basic block B is determined.
  • basic block B is a set of program blocks or a predicate vertex.
  • step S1 If the result of the determination in step S1 is that basic block B is a set of program blocks, a statement that calls a vertex procedure belonging to basic block B and a statement that registers the dependency between them are generated. . Specifically, first, in step S2, a wait for input to basic block B is generated. At this time, a wait for data transfer is generated for the flow dependency relationship from outside the block to inside the block. Data transfer waits are also generated for definition order relationships, reverse dependency relationships, and output dependency relationships. In other words, the following 5 types of edges are generated!
  • step S3 for each vertex V of basic block B, a loop that repeats the subsequent processing in the order of execution is started.
  • step S4-1 an input data transfer instruction to the vertex V exceeding the basic block and an output data transfer instruction of the execution result are generated. Specifically, if there is a data dependency relationship that exceeds the block, there is data in the variable on the control processor, so this data is transferred to the processor that executes the procedure. Specifically, it generates the control processor power and data transfer to the remote processor for the following two types of edges.
  • step S4-2 a statement for calling the remote procedure of vertex V is generated.
  • step S5-1 a statement for registering dependency on input data transfer is generated.
  • step S5-2 a statement instructing the data transfer of the execution result from the vertex V is generated.
  • the data is directly transferred to the processor that executes the subsequent procedure.
  • the data is transferred to the control processor.
  • step S5-2 a statement for registering the dependency from the data transfer instruction to the procedure call is also generated.
  • step S6 After the above processing is repeated for all the vertices V of the basic block B, a statement instructing the start of execution is generated in step S6.
  • step S7 a data transfer queue to element V of basic block B is generated.
  • a statement that waits for the input flow dependent edge is generated.
  • outside the vertex Waits are generated for two types of edges: a flow-dependent edge that carries over the loop and a loop-independent flow-dependent edge to that vertex!
  • step S8 the type of predicate of vertex V is determined. If the predicate is a loop, go to step S9. If the predicate is an if statement, go to step S14.
  • step S9 If the determination result in step S8 indicates a loop, a for or while statement corresponding to! / In the input sequential program is generated in step S9.
  • step S11 for each element B ′ of B ′, a loop is repeated that repeats the subsequent processing in ascending order of i.
  • step S12 a procedure control program for B is generated.
  • This step S12 has a nested structure, and executing step S12 for B corresponds to executing the entire flowchart of FIG.
  • step S13 a data transfer wait to predicate vertex V is generated. This is because the condition is determined by carrying over the loop, so a sentence that waits for input data to the conditional expression (input flow dependent side that carries over the own loop) is added at the end of the text.
  • step S8 If the determination result in step S8 indicates an if statement, an if statement is generated in step S14.
  • step S15 a then clause is generated.
  • step S 17 for each element B ′ of B ′, a loop that repeats the subsequent processes in ascending order of i is started.
  • step S18 a procedure control program for B is generated.
  • This step S 18 has a nested structure, and executing step S 18 for B is equivalent to executing the entire flowchart of FIG.
  • the sentence generated in steps S17 and S18 constitutes the body of the then clause.
  • step S20 it is determined whether or not the set B ′ of basic blocks is an empty set. If it is an empty set, the process ends.
  • Basic block set B ' is empty If not, an else clause is generated in step S21.
  • step S22 for each element B of B ′, a loop that repeats the subsequent processing in ascending order of i is started.
  • step S23 a procedure control program for B is generated.
  • This step S23 has a nested structure, and executing step S23 for B is equivalent to executing the flowchart of FIG. Note that the sentence generated in steps S22 and S23 constitutes the body of the else clause.
  • FIG. 30 is a diagram showing the structure of the procedure control program in the case of the second embodiment.
  • the control program in the second embodiment of the present invention includes a variable declaration initialization part 71, a predicate input data waiting part 72, and a predicate control structure.
  • In the input data waiting section 74 for the basic block a procedure input data transfer instruction, a remote procedure call start instruction, a procedure output data transfer instruction, and a dependency relation are registered.
  • waiting between procedures is waiting for data transfer.
  • a distributed memory which is an individual memory provided in each processor is used.
  • procedure input data shall be transferred from the control processor to the executing processor, and output data shall be transferred from the remote processor to the control processor.
  • data is transferred directly between the processors executing the procedure.
  • a data area for input / output variables is prepared in advance, and input data is transferred to a processor that executes in advance.
  • the execution result is stored on the executing processor, and the value is appropriately transferred to the processor required by the control program.
  • the part of the input sequential program and the degenerate program dependence graph used in this example are the same as those in the first embodiment, and are shown in FIGS. 25 (a) and 25 (b), respectively.
  • a program dependence graph is generated from the input sequential program shown in Fig. 25 (a), and the reduced program dependence graph shown in Fig. 25 (b) is generated by combining the vertices and degenerating.
  • Vertex V force V is
  • vertex V becomes a set of sentences due to degeneration.
  • FIG. 31 is a diagram showing a procedure control program generated from the degenerate program dependence graph of FIG. 25 according to the second embodiment.
  • control structure of the program is the same as in FIG. 26 except that it includes a data transfer instruction and its dependency instructions! /. Therefore, detailed description is omitted.
  • FIG. 32 is a schematic diagram showing the operation of the above procedure control program together with the execution of the procedure program.
  • processor 0 and processors corresponding to procedures vO and v2 to v6 are used.
  • data transfer units DTU # 0 to DTU # 3 are used.
  • the procedure control program is executed by the processor 0.
  • the data a is transferred to the processor of procedure ⁇ by the data transfer unit DTU # 0. Accordingly, procedure program 91 of procedure ⁇ is executed by the corresponding processor. Is done. If the condition of the while statement is satisfied, the transfer of the execution result of the procedure ⁇ is incomplete. Wait for the data transfer from ⁇ .
  • procedure program 93 of procedure v3 is executed by the corresponding processor.
  • procedure v5 procedure program 95 is executed by the corresponding processor in response to the transfer of procedure v4 output data y via data transfer unit DTU # 3 based on the registered dependencies. .
  • procedure vl belongs to the first basic block
  • procedures v2 to v5 belong to the second basic block
  • procedure v3 belongs to the third basic block.
  • the subsequent procedure is executed after waiting for the data transfer from the preceding procedure.
  • the procedure is executed by calling an asynchronous remote procedure with dependency waiting.
  • an apparatus for executing the parallelized program generation method according to the present invention is realized by a computer such as a personal computer or an engineering workstation.
  • 33 includes a computer 510, a display device 520 connected to the computer 510, a communication device 523, and an input device.
  • the input device includes a keyboard 521 and a mouse 522, for example.
  • the computer 510 includes a CPU 511, a RAM 512, a ROM 513, a secondary storage device 514 such as a hard disk, a replaceable medium storage device 515, and an interface 516.
  • the keyboard 521 and the mouse 522 provide an interface with the user, and various commands for operating the computer 510, user responses to requested data, and the like are input.
  • the display device 520 displays the results processed by the computer 510, and displays various data to enable interaction with the user when operating the computer 510.
  • the communication device 523 is for performing communication with a remote place, and includes, for example, a modem or a network interface.
  • the parallelized program generation method according to the present invention is provided as a computer program executable by the computer 510.
  • This computer program is stored in the storage medium M that can be mounted on the replaceable medium storage device 515, and is loaded from the storage medium M to the RAM 512 or the secondary storage device 514 via the replaceable medium storage device 515.
  • this computer program is stored in a remote storage medium (not shown), and loaded from this storage medium to the RAM 512 or the secondary storage device 514 via the communication device 523 and the interface 516. Is done.
  • the CPU 511 When there is a program execution instruction from the user via the keyboard 521 and / or the mouse 522, the CPU 511 loads the program from the storage medium M, the remote storage medium, or the secondary storage device 514 to the RAM 512.
  • the CPU 511 uses the free storage space of the RAM 512 as a work area, executes the program loaded in the RAM 512, and proceeds with the process while appropriately talking to the user.
  • the ROM 513 stores a control program for controlling basic operations of the computer 510! /. [0196]
  • the computer 510 executes the parallelized program generation method as described in the above embodiments.

Landscapes

  • Engineering & Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Devices For Executing Special Programs (AREA)

Description

明 細 書
並列化プログラム生成方法、並列化プログラム生成装置、及び並列化プ ログラム生成プログラム
技術分野
[0001] 本発明は、一般にプログラム生成方法、装置、及びプログラムに関し、詳しくは並列 化プログラム生成方法、装置、及びプログラムに関する。
背景技術
[0002] 近年、シングル ·プロセッサでのプログラム性能には限界があることが知られてきた。
従来、性能を上げるためには、プロセッサの動作周波数を高くすることで単位時間あ たりの処理量を増やす方法と、命令を並列に実行することで同時に実行できる処理 を増やす方法とがとられてきた。
[0003] し力 動作周波数を高くすると消費電力が大きくなるという問題があるとともに、動作 周波数の向上には物理的な限界があるという問題がある。また、命令レベルの並列 性は高々 2〜4程度であり（非特許文献 1)、投機的な実行などを導入することにより 多少並列性を上げることはできる力 S、それにも限界があることが知られている。
[0004] そこで、命令レベルよりも大きな粒度でプログラムを並列化し、複数のプロセッサに て実行することにより、処理性能を向上させる方法が注目されている。しかしながら、 制御による分岐が多い逐次プログラムを効果的な並列プログラムへ変換する画一的 な方法は、これまでのところ知られていない。
[0005] 逐次プログラムを分割して複数のプロセッサ上で並列に実行するプログラムを生成 する手法として、ループに着目したデータ'レベル並列化という方法と、制御に着目し た投機的なスレッド実行とレ、う方法が知られて!/、る。
[0006] 特許文献 1では、ループの中におけるデータの依存関係を解析し、配列を分割して 、ループの処理を複数のプロセッサで実行させる。この手法は、数値計算等の規則 的なループの処理が多!/、場合に有効である。
[0007] また特許文献 2は、逐次プログラムにおける分岐に着目して、投機的なスレッド実行 に置換する手法を示す。この手法では、制御の流れに基づいてプログラムを並列化 するので、プログラムの潜在的な並列性を充分に抽出できているとはいえない。また 、投機的スレッド実行機構を持たな!、マルチプロセッサにおレ、ては予測失敗時の口 ールバックのコストが大き!/、ので、分岐予測ヒット率が低!/、アプリケーションにはこの 手法は適さない。
[0008] 従って、大規模なソフトウェアを対象として、逐次プログラムを並列化することにより、 マルチプロセッサ上で効果的に動作する非投機的なマルチ ·スレッド '·プログラム（並 列化プログラム）を生成する方法を提供することが必要になる。但し、このようにして生 成する並列化プログラムにおいては、以下に説明するように、スレッド間の依存関係 に基づく待ち時間の発生という問題について考慮する必要がある。
[0009] 並列化プログラムの各スレッドの実行を制御する方式としては、例えば、手続を非 同期の遠隔呼び出しとして呼び出すことにより並列にスレッドを実行する方式、手続 に実行開始するメッセージを送信することにより並列にスレッドを実行する方式、スレ ッド間で共有メモリを利用して入出力変数の受け渡しを行なうことにより並列にスレツ ドを実行する方式等が考えられる。し力もこれらの方式では、第 1の手続 (スレッド）の 実行結果を利用する第 2の手続がある場合、第 1の手続の終了を待つ命令とそれに 続く第 2の手続を実行する命令とを、他の手続の実行に要する時間などを見積もって 、プログラム中の適当な場所に配置しておくことになる。この場合、第 1の手続が予想 以上に早く終了した場合などに、第 2の手続を実行するまでに、不必要な待ち時間 が発生してしまう。
[0010] 図 1は、無駄な待ち時間の発生について説明するための図である。図 1において、 プロセッサ 0乃至プロセッサ 3の 4つのプロセッサが用いられる。プロセッサ 0でスレッド 制御プログラム 1 (各スレッドに対応する手続の実行及び終了待ちを制御するプログ ラム）を実行する。図 1の例では、まずプロセッサ 0から、プロセッサ 1乃至プロセッサ 3 に対して手続 A乃至 Cの実行を順番に要求する（start A()〜start C())。その後プロ セッサ 0は、手続 Aの終了を待って (wait AO)、手続 Aの実行結果を利用する手続 D の実行を要求する（start D())。その後、手続 Bの終了を待って (wait B())、手続 Bの 実行結果を利用する手続 Eの実行を要求する（start E())。更にその後、手続 Cの終 了を待って (wait CO)、手続 Cの実行結果を利用する手続 Fの実行を要求する（start F())。
[0011] この例では、手続 Cが終了してから手続 Fの実行を要求するまでに待ち時間が発生 している。これは、スレッド制御プログラム中において、手続 Bの終了待ち合わせ（wait B0)と手続 Eの実行要求（start E0)が、手続 Cの終了待ち合わせ (wait C())と手続 F の実行要求（start F0)よりも前に配置されているからである。このような命令配置順の ために、手続 Bが終了しないと、手続 Cの終了待ち合わせ及び手続 Fの実行要求が 実行されないことになる。
[0012] このような命令配置は、手続 Bが手続 Cよりも早く実行が終了するであろうという見積 もりに基づくものである。手続 Cの方が手続 Bよりも早く終了することが分かっていたな らば、手続 Cの終了待ち合わせ及び手続 Fの実行要求を、手続 Bの終了待ち合わせ 及び手続 Eの実行要求よりも前に配置することが考えられる。し力も実際には、手続 の実行に力、かる時間は処理データの内容等にも依存するので、終了時間を正確に 見積もることは不可能である。従って、単純な遠隔手続呼び出し、共有メモリによるス レッド、メッセージ送信等の上記方式では、図 1に示すような待ち時間を無くすことは できない。
[0013] 以上説明したように、上記の依存関係待ち合わせ付き非同期遠隔手続呼び出し方 式を用いれば、並列化プログラムの実行時における不要な待ち合わせ時間の発生を 防ぐこと力 Sできる。従って、大規模なソフトウェアを対象として、逐次プログラムを並列 化することにより、マルチプロセッサ上で効果的に動作する非投機的な並列化プログ ラムを生成する際には、上記の依存関係待ち合わせ付き非同期遠隔手続呼び出し 方式に適用可能な並列化プログラムを生成することが望ましレ、。
特許文献 1：特許第 3028821号公報
特許文献 2：特許第 3641997号公報
非特許文 Il U： David W. Wall. Limits of Instruction-Level Parallelism. Proceedings o f the fourth international conference on Architectural support for programming langu ages pp. 176-188 May. 1991.
非特許文献 2 : S. Horwitz, J. Prins, and T. Reps, "Integrating non- interfering versio ns of programs, ACM Transactions on Programming Languages and Systems, vol. 1 1， no. 3， pp. 345—387， 1989.
非特許文献 3 : Jeanne Ferrante, Karl J. Ottenstein, Joe D. Warren, "The Program D ependence raph and Its Use in Optimization, ACM Transactions on Programming
Languages and Systems, pp. 319-419， vol. 9 no. 3， July 1987.
非特許文献 4 : Susan Horwitz, Jan Prins, Thomas Reps, "On the adequacy of progra m dependence graphs for representing programs ' Proceedings of the 15th Annual A
CM Symposium on the Principles of Programming Languages, pp. 146-157， Jan., 19
88.
非特許文献 5 :中田育男著:"コンパイラの構成と最適化"，朝倉書店， 1999
発明の開示
発明が解決しょうとする課題
[0014] 以上を鑑みて、本発明は、大規模なソフトウェアを対象として、マルチプロセッサ上 で効果的に動作する非投機的かつ依存関係待ち合わせに基づく並列化プログラム を生成する方法、装置、及びプログラムを提供することを目的とする。
課題を解決するための手段
[0015] 逐次実行プログラムにおける複数のスレッドの実行順及び複数のスレッドの依存関 係を登録し、登録した依存関係に基づいて複数のスレッドの実行状態を管理し、実 行可能なスレッドを判定して、順次プロセッサに割当てて実行することを特徴とする依 存関係待ち合わせ方式により実行される並列化プログラムを生成することを特徴とす
[0016] 並列化プログラム生成方法は、逐次プログラムを入力として、該逐次プログラムを構 成する各文を頂点として有するとともに、文と文の間の関係を該頂点間の辺として有 するプログラム依存グラフを生成し、該プログラム依存グラフの該頂点同士を融合す ることにより該頂点の数を減少させた縮退プログラム依存グラフを生成し、該縮退プロ グラム依存グラフの頂点の実行順序を計算し、該実行順序を与えられた該複数の頂 点のうちで分岐及び合流の何れも含まずに順番に実行される頂点列を基本ブロック として纏め、該縮退プログラム依存グラフの頂点の各々に相当する手続きを生成し、 該基本ブロック間をまたいでの依存関係がある手続きについては先行手続きを待ち 合わせる命令の後に後続手続きを実行する命令を配置し、同一の基本ブロック内部 で依存関係がある手続きについては先行手続きに対する後続手続きの依存関係を 登録する命令を生成するようにして、該手続きの実行を制御する手続き制御プロダラ ムを生成する各段階を含むことを特徴とする。
[0017] 並列化プログラム生成装置は、逐次プログラムと並列化プログラム生成プログラムと を格納するメモリと、該メモリに格納された該並列化プログラム生成プログラムを実行 することで該メモリに格納された該逐次プログラムから並列化プログラムを生成する演 算処理ユニットを含み、該演算処理ユニットは、該並列化プログラム生成プログラムを 実行することにより、該逐次プログラムを構成する各文を頂点として有するとともに、 文と文の間の関係を該頂点間の辺として有するプログラム依存グラフを生成し、該プ ログラム依存グラフの該頂点同士を融合することにより該頂点の数を減少させた縮退 プログラム依存グラフを生成し、該縮退プログラム依存グラフの頂点の実行順序を計 算し、該実行順序を与えられた該複数の頂点のうちで分岐及び合流の何れも含まず に順番に実行される頂点列を基本ブロックとして纏め、該縮退プログラム依存グラフ の頂点の各々に相当する手続きを生成し、該基本ブロック間をまたいでの依存関係 がある手続きについては先行手続きを待ち合わせる命令の後に後続手続きを実行 する命令を配置し、同一の基本ブロック内部で依存関係がある手続きについては先 行手続きに対する後続手続きの依存関係を登録する命令を生成するようにして、該 手続きの実行を制御する手続き制御プログラムを生成することを特徴とする。
[0018] 並列化プログラム生成プログラムは、逐次プログラムを入力として、該逐次プロダラ ムを構成する各文を頂点として有するとともに、文と文の間の関係を該頂点間の辺と して有するプログラム依存グラフを生成し、該プログラム依存グラフの該頂点同士を 融合することにより該頂点の数を減少させた縮退プログラム依存グラフを生成し、該 縮退プログラム依存グラフの頂点の実行順序を計算し、該実行順序を与えられた該 複数の頂点のうちで分岐及び合流の何れも含まない頂点列を基本ブロックとして纏 め、該縮退プログラム依存グラフの頂点の各々に相当する手続きを生成し、該基本 ブロック間をまたいでの依存関係がある手続きについては先行手続きを待ち合わせ る命令の後に後続手続きを実行する命令を配置し、同一の基本ブロック内部で依存 関係がある手続きについては先行手続きに対する後続手続きの依存関係を登録す る命令を生成するようにして、該手続きの実行を制御する手続き制御プログラムを生 成する各段階を計算機に実行させるコードを含むことを特徴とする。
発明の効果
[0019] 本発明の少なくとも 1つの実施例によれば、制御の流れグラフではなぐ制御の依 存関係を示すグラフであるプログラム依存グラフに基づいて並列化プログラムを生成 するので、制御の流れ (分岐）を超えたプログラムの並列性を抽出することができる。 また、プログラム依存グラフを縮退してグラフの規模を削減することで、その後の並列 化プログラム生成処理の効率化及び最適化が可能になるとともに、大きな粒度での 並列化を実現することができる。
[0020] また更に、異なる基本ブロックをまたいでの手続き間の依存関係については、先行 手続きの終了待ち合わせを行ってから、後続手続きを実行するようにする。また同一 の基本ブロック内部で依存関係がある手続きの実行にっレ、ては、依存関係待ち合わ せ付き非同期遠隔手続呼び出しにより手続きを実行する。即ち、基本ブロック間をま たいでの依存関係がある手続きについては先行手続きを待ち合わせる命令の後に 後続手続きを実行する命令を配置して、この命令の配置順により依存関係を非明示 的に規定して、依存関係を満たすように手続き制御する。また同一の基本ブロック内 部で依存関係がある手続きについては後続手続きの先行手続きへの依存関係を明 示的に登録する命令を生成するようにして、依存関係を満たすように手続き制御する 。このような構成とすることで、複雑な制御の依存関係が存在する基本ブロック間に っレ、ては、手続きの実行を待ち合わせにより実現することで制御プログラムの生成を 容易なものとし、実行順が固定である同一基本ブロック内については、依存関係待ち 合わせ付き非同期遠隔手続呼び出しにより無駄な待ち合わせ時間をなくすことがで きる。
図面の簡単な説明
[0021] [図 1]無駄な待ち時間の発生について説明するための図である。
[図 2]依存関係待ち合わせ付き非同期遠隔手続呼び出し方式による手続実行の制 御について説明するための図である。 園 3]本発明による並列化プログラム生成方法の概略を示す図である。
園 4]手続きプログラム生成方法の概要を示す図である。
園 5]図 4の手続きプログラム生成方法により生成される手続きプログラムを示す図で ある。
[図 6]手続き制御プログラムの生成方法を示すフローチャートである。
園 7]頂点間の実行順序関係を決定する方法を示すフローチャートである。
[図 8]頂点 V以下の制御の流れを再構成する処理（図 7のステップ S2)を示すフロー チャートである。
[図 9]Regionの実行順序関係を計算する処理を示すフローチャートである。
[図 10]逆依存及び出力依存を求める処理（図 9のステップ S4)を示すフローチャート である。
園 11]着目領域を越える変数参照を抽出する処理を示すフローチャートである。 園 12]着目領域を越える変数代入を抽出する処理を示すフローチャートである。
[図 13]逆依存の追加処理を示すフローチャートである。
[図 14]出力依存の追加処理を示すフローチャートである。
[図 15]逆依存及び出力依存を求める処理（図 9のステップ S 5)を示すフローチャート である。
園 16]全域木を説明するための図である。
園 17]全域木を模式的に示す図である。
園 18]全域木間の順序関係を計算する処理を示すフローチャートである。
[図 19]図 18の処理による逆依存辺の追加について説明する図である。
[図 20]頂点間の実行順序関係を決定する方法の変形例を示すフローチャートである
[図 21]基本ブロックを抽出する処理のフローチャートを示す図である。
[図 22]制御プログラムを生成する処理のフローチャートを示す図である。
[図 23]基本ブロックの集合 B'の要素 B以下の手続き制御プログラムを生成する処理 を示すフローチャートである。
園 24]第 1の実施例の場合の手続き制御プログラムの構造を示す図である。 [図 25] (a)は入力逐次プログラムの部分を示す図、（b)は対応する縮退プログラム依
Figure imgf000010_0001
[図 26]図 25の縮退プログラム依存グラフから第 1の実施例に従い生成される手続き 制御プログラムを示す図である。
[図 27]手続き制御プログラムの動作を手続きプログラムの実行とともに示す模式図で ある。
[図 28]第 2の実施例の場合の制御プログラムを生成する処理のフローチャートを示す 図である。
[図 29]基本ブロックの集合 B'の要素 B以下の手続き制御プログラムを生成する処理 を示すフローチャートである。
[図 30]第 2の実施例の場合の手続き制御プログラムの構造を示す図である。
[図 31]図 25の縮退プログラム依存グラフから第 2の実施例に従い生成される手続き 制御プログラムを示す図である。
[図 32]手続き制御プログラムの動作を手続きプログラムの実行とともに示す模式図で ある。
[図 33]本発明による並列化プログラム生成方法を実行する装置の構成を示す図であ
符号の説明
10 入力変数の引数受信部分
11 変数宣言部分
12 プログラム本体部分
13 出力変数の送信部分
21 , 22 全域木
31 出力依存辺
32, 33 逆依存辺
510 コンピュータ
511 CPU
512 RAM 513 ROM
514 二次記憶装置
515 可換媒体記憶装置
516 インターフェース
520 ディスプレイ装置
521 キーボード
522 マウス
523 通信装置
発明を実施するための最良の形態
[0023] 以下に、本発明の並列化プログラム生成方法の概略及び実施例を添付の図面を 用いて詳細に説明する。
[0024] 図 2は、依存関係待ち合わせ付き非同期遠隔手続呼び出し方式による手続実行の 制御について説明するための図である。並列化プログラムの各スレッドの実行を制御 する際に、各手続毎に他の手続に対する依存関係を実行条件として指定し、各手続 をプロセッサ毎の実行キューに投入し、実行条件が満たされた手続を実行していくと いう方式が考えられる。このような方式を、依存関係待ち合わせ付き非同期遠隔手続 呼び出し方式と呼ぶ。
[0025] 図 2において、プロセッサ 0乃至プロセッサ 3の 4つのプロセッサが用いられる。プロ セッサ 0でスレッド制御プログラム 2 (各スレッドに対応する手続きの実行及び依存関 係を制御するプログラム）を実行する。この際プロセッサ 0は、手続き呼出しプログラム 3を実行することにより、スレッド制御プログラム 2に規定される各手続きを各プロセッ サ毎のキューを用いて管理する。
[0026] 図 2の例では、まず制御プログラム 2の命令 start A()に従って、プロセッサ 1の実行 キュー 4に手続 Aが投入される。また制御プログラム 2の命令 start B()に従って、プロ セッサ 2の実行キュー 5に手続 Bが投入される。更に制御プログラム 2の命令 start C() に従って、プロセッサ 3の実行キュー 6に手続 Cが投入される。
[0027] 同様に、制御プログラム 2の命令 start D()、 start E()、及び start F()に従って、実行 キュー 4乃至 6にそれぞれ手続 D、 E、及び Fが投入される。またスレッド制御プロダラ ム 2中の d印 (x， y, · · ·)は依存関係を指定する命令であり、手続 Xの依存先が手続 Y、 • · ·であることを示す。即ち、手続 Xを実行するためには、手続 Υ、 · · ·の実行が終了 している必要があることを示す。制御プログラム 2の命令 d印 (D， A)に従って、プロセッ サ 1の実行キュー 4中の手続 Dに対して、依存先の手続が Aであることが登録される。 また制御プログラム 2の命令 d印 (E， A, B)に従って、プロセッサ 2の実行キュー 5中の 手続 Eに対して、依存先の手続が A及び Bであることが登録される。更に、制御プログ ラム 2の命令 d印 (F， A, C)に従って、プロセッサ 3の実行キュー 6中の手続 Fに対して 、依存先の手続が A及び Cであることが登録される。
[0028] このようにして各プロセッサ毎に設けた実行キューに投入されている手続を、キュー の順番に従って対応するプロセッサで実行する。この際、依存先が登録されていない 手続（図 2において NULLで示されている手続）については無条件に実行し、依存先 が登録されて!/、る手続につ!/、ては、依存先の手続の終了を検出してから実行する。 このようにプロセッサ毎にキューを設け、実行条件が満たされたキュー内の手続き（実 行可能手続き）から順番に実行して!/、くことで、図 1に示したような待ち時間を無くす こと力 Sでさる。
[0029] 図 3は、本発明による並列化プログラム生成方法の概略を示す図である。
[0030] ステップ S1で逐次プログラムからプログラム依存グラフ（PDG： Program Dependenc e Graph)を生成する。次に、ステップ S2で、手続きとして他のプロセッサエレメントで 実行するに適した処理量となるまで依存関係を縮退することにより、手続きを頂点と する縮退プログラム依存グラフを作成する。ステップ S3で、作成した縮退プログラム 依存グラフから、非投機的に手続きの起動と同期を制御する手続き制御プログラムを 生成する。またステップ S4で、縮退プログラム依存グラフから、その各頂点に相当す る手続きプログラムを生成する。
[0031] まず逐次プログラムからプログラム依存グラフを生成する処理（図 3のステップ S1) について説明する。
[0032] プログラム依存グラフとは、例えば非特許文献 2乃至 4等に説明されるように、プロ グラムの文を頂点とし、文と文の間の関係を辺で表現したグラフである。非特許文献 2 乃至 4に記載されるプログラム依存グラフは、次のような頂点集合 Vと辺集合 Eの組で 表現されるものであり、逐次プログラムを解析することにより生成できる。
[0033] [V:頂点集合]
エントリ:プログラムの開始ポイントを表す。
[0034] 初期定義:プログラム開始時の初期値の定義を表す。
[0035] プリディケート： If-then-elseまたは while-loopの条件判定を表す。
[0036] 代入文:プログラムの代入文を表す。
[0037] 最終使用:プログラム終了時の変数の参照を表す。
[0038] [E:辺集合]
[制御依存辺： v→ L w]プリディケート頂点 vに対して、その条件判定結果により、 頂点 wに到達するか否かが決まることを表す。 Lは条件判定のフラグを表し、 L=Tのと きは条件判定結果が真の場合に頂点 wを実行し、 L=Fのときは結果が偽の場合に頂 点 wを実行する。
[0039] [データ依存辺]
[ループ独立フロー依存辺： v→ x W]頂点 Vで代入された変数 Xの値を、頂点 Wで
li
参照するような場合のデータ依存関係を表す。ここでは、ループを繰り越さない場合 のみを表す。
[0040] [ループ繰り越しフロー依存辺： v→ x w]頂点 Vで代入された変数 Xの値を、頂点
lc(L)
wで参照するような場合のデータ依存関係を表す。ループ Lを繰り越す場合を表す。
[0041] [定義順序関係： v→ x w]頂点 V及び頂点 wが変数 Xの値を代入し、頂点 uで参
do(u)
照するような場合の、頂点 Vと頂点 Wの順序関係を表す。制御の流れによっては、 V, W ， U,あるいは、 V, Uの順に実行される可能性がある場合に、 V， Wの実行順序を表すも のである。
[0042] 以下において、縮退プログラム依存グラフを作成する処理（図 3のステップ S2)につ いて説明する。
[0043] 上記のような一般的なプログラム依存グラフでは、文または代入式を頂点としたダラ フとなっている。文または代入式を頂点とした場合、大規模なソフトウェアではグラフ の頂点数が数千〜数万となってしまう。一般的に、コンパイラのグラフを用いた最適 化の問題の計算量は、グラフの規模に対して指数関数的に増大することが知られて いる。したがって、例えば数個の手続きなどを対象とした頂点数が数十程度のグラフ の場合には、解析が可能である力 現実的な規模のソフトウェア全体に対する最適 化は困難といえる。
[0044] そこで、プログラム依存グラフの頂点数及び辺数を低減すベぐプログラム依存ダラ フの依存関係を縮退して頂点を融合し、粗粒度のプログラム依存グラフを作成する。 依存関係を縮退することによりグラフの規模を 1/10〜 1/100とすることで、現実的な時 間にて、プログラムの最適化を可能にする。
[0045] 依存関係の縮退は、次のような方法で、縮退可能な依存関係及び頂点の集合を求 め、依存関係を削除して頂点を 1つの頂点に融合することにより実行される。
[0046] 1.構文規則に基づく縮退
一般にプログラム依存グラフから等価な逐次プログラムの制御の流れを再構成する ことは、困難と言われている。これは、制御の依存関係のみの表現となっているため、 依存関係を満足する制御の流れは一意に決定できな!/、上に、グラフを変形するよう な最適化を行なった場合、依存関係を満足するような制御の流れが存在しな!、ような 場合も出てくるためである。
[0047] しかし、表現するプログラムの制御構造を、 i戊、 while文、及び、代入文に限定し、 プログラム依存グラフの制御依存部分グラフ (頂点と制御依存辺のみで構成される部 分グラフ)の形が木構造となる場合は、プログラムの制御の流れを再構成できることが 知られている（非特許文献 2)。そこで、プログラムにおける i戊、 while文でない制御文 ロック全体とブロック内部の依存関係を 1つの頂点に縮退することで、安全に制御の 流れを再構成可能な範囲の縮退プログラム依存グラフを作成する。
[0048] 2.結合度に基づく縮退
プログラム依存グラフを探索して、頂点間の結合の強さを求める。結合度は、データ 依存辺とその大きさ、及び、制御依存辺、処理の大きさから計算されるものとする。あ る結合度以上の頂点に対して、縮約可能な条件を満足する場合は、頂点を結合し依 存関係を縮約する。ここで、次の 2つ条件を満たすときに、頂点を結合しての縮約が 可能となる。 [0049] 1)プログラム依存グラフに対応する CFG(Control Flow Graph：制御フローグラフ） 上で頂点集合外から頂点集合内への分岐は頂点集合の先頭頂点へのみであり、頂 点集合内から頂点集合外への分岐は頂点集合の最後の頂点のみである。
[0050] 2)頂点間のデータ依存パスに外部の頂点が含まれない。
[0051] 以上のようにして、「構文規則に基づく縮退」又は「結合度に基づく縮退」により、頂 点数が大幅に削減された縮退プログラム依存グラフを生成することができる。縮退プ ログラム依存グラフは、次の要素から構成される。
[0052] [V:頂点集合]
エントリ:プログラムの開始ポイントを表す。
[0053] 初期定義:プログラム開始時の初期値の定義を表す。
[0054] プリディケート： If-then-elseまたは while-loopの条件判定を表す。
[0055] 文の集合：プログラムを構成する文の集合を表す。
[0056] 最終使用:プログラム終了時の変数の参照を表す。
[0057] [E:辺集合]
[制御依存辺： v→ L w]プリディケート頂点 vに対して、その条件判定結果により、 頂点 wに到達するか否かが決まることを表す。 Lは条件判定のフラグを表し、 L=Tのと きは条件判定結果が真の場合に頂点 wを実行し、 L=Fのときは結果が偽の場合に頂 点 wを実行する。
[0058] [データ依存辺]
[ループ独立フロー依存辺： v→ x w]頂点 Vで代入された変数 Xの値を、頂点 wで
li
参照するような場合のデータ依存関係を表す。ここでは、ループを繰り越さない場合 のみを表す。
[0059] [ループ繰り越しフロー依存辺： v→ x w]頂点 Vで代入された変数 Xの値を、頂点
lc(L)
wで参照するような場合のデータ依存関係を表す。ループ Lを繰り越す場合を表す。
[0060] [定義順序関係： v→ x w]頂点 V及び頂点 wが変数 Xの値を代入し、頂点 uで参
do(u)
照するような場合の、頂点 Vと頂点 Wの順序関係を表す。制御の流れによっては、 V, W ， U,あるいは、 V, Uの順に実行される可能性がある場合に、 V， Wの実行順序を表すも のである。 [0061] 以下において、手続き制御プログラムを生成する処理（図 3のステップ S3)及び手 続きプログラムを生成する処理（図 3のステップ S4)について説明する。
[0062] まず手続きプログラムの生成について説明する。上記のようにして生成された縮退 プログラム依存グラフの頂点は、入力逐次プログラムの文の部分集合であって、文の 間の制御の流れの情報を有している。従って、着目する 1つの頂点へのデータフロー 入力辺が表す変数を入力とし、データフロー出力辺が表す変数を出力とする、 1つの 手続きプログラムを 1つの頂点に対して生成する。また、制御の流れより手続きプログ ラムの本文を、また、本文の実行に必要な局所変数をそれぞれ生成する。
[0063] 図 4は、手続きプログラム生成方法の概要を示す図である。図 5は、図 4の手続きプ ログラム生成方法により生成される手続きプログラムを示す図である。
[0064] 図 4のステップ S 1において、着目頂点についてデータフロー入力辺が表す変数を 入力として、入力変数を引数として受信するためのプログラム部分を生成する。これ により、図 5に示す入力変数の引数受信部分 10が生成される。ステップ S2において 必要な変数を探索する。更にステップ S3において、探索により見つかった変数につ いて変数宣言を生成する。これにより、図 5に示す変数宣言部分 11が生成される。
[0065] ステップ S4において、着目頂点の文の間の制御の流れの情報に基づいて、プログ ラムの本文を生成する。これにより、図 5に示すプログラム本体部分 12が生成される。 ステップ S5において、着目頂点のデータフロー出力辺が表す変数を出力として返す ためのプログラム部分を生成する。これにより、図 5に示す出力変数のセット部分 13 が生成される。
[0066] このように、手続きプログラムとしては、頂点が表す文/文の集合を実行する手続き とする。また、入力変数を手続きの引数とし、出力変数を復帰値あるいは、出力変数 を格納するアドレスを引数として受け取るような手続きを作成する。
[0067] 次に手続き制御プログラムの生成について説明する。非特許文献 2に記載される技 術に基づ!/、て、縮退したプログラム依存グラフから制御の流れを安全に再構成するこ と力できる。具体的には、縮退したプログラム依存グラフの制御依存部分木について 、プログラムの実行順序関係を計算し、基本ブロックを求める。基本ブロックとは、分 岐（IF、 GOTO, LOOP等）や合流を含まない順番に実行される頂点の列のことを言 う。各中間節点が表す制御構造と子頂点が表す「手続き」の呼び出しを行なうプログ ラムを生成することで、並列プログラムを生成することができる。「手続き」を実行する 上で必要となる入力および出力データの送受信と待ち合わせを行なうコードも生成 する。基本ブロック内の手続き呼び出しおよびデータ転送の依存関係に関しては、 依存関係待ち合わせのメカニズムを用いて制御する。
[0068] 以下に、本発明の実施例について詳細に説明する。第 1の実施例は、依存関係待 ち合わせ付き非同期遠隔手続き呼び出し方式を共有メモリで実現する例であり、第 2 の実施例は、依存関係待ち合わせ付き非同期遠隔手続き呼び出し方式を分散メモリ で実現する例である。まず第 1の実施例と第 2の実施例に共通な部分について説明 する。
[0069] 図 6は、手続き制御プログラムの生成方法を示すフローチャートである。まずステツ プ S1で、頂点間の実行順序関係を計算する。縮退したプログラム依存グラフは、デ ータ及び制御の依存関係のみを表現したグラフであつて頂点間の実行順序は明示 されていないので、これから適切な制御の流れを再構成する必要がある。そこで、縮 退したプログラム依存グラフの制御依存部分木について、各中間節点の子頂点の実 行順序を計算する。この結果、頂点間の半順序関係を求めることができる。この実行 順序関係を用いて、制御プログラムを生成することとなる。またその課程において、逆 依存関係、出力依存関係が抽出される。
[0070] 次にステップ S2で、求めた実行順序 (制御の流れ)から、基本ブロックを抽出する。
[0071] 次にステップ S3で、制御プログラムの変数と初期値代入文を生成する。この際、静 的単一代入形式 (非特許文献 5、 320頁）に変換することで、並列性を向上されること も考えられる。ここで変数としては、データの受け渡しを行うための変数を生成する。
[0072] 次にステップ S4で、 S1で求めた実行順序順に制御依存部分グラフを探索し、制御 プログラムを生成する。プリディケート頂点については、その頂点が表す制御構造を 生成する。そして、制御構造の本文として、当該頂点の下位の部分木の制御プロダラ ムを生成する。基本ブロックについては依存関係に基づく非同期遠隔手続きを行う 文を生成する。これについては以下に詳細に説明する。
[0073] 更にステップ S5で、手続きの終了の待ち合わせを行う文を生成する。 [0074] 図 7は、頂点間の実行順序関係を決定する方法を示すフローチャートである。図 7 の処理は、図 6のステップ S 1に相当する。図 7に示す処理の入力は縮退したプロダラ ム依存グラフ PDGであり、出力は縮退したプログラム依存グラフ PDG及びその制御 の流れである。
[0075] ステップ S 1で、縮退したプログラム依存グラフ PDGのエントリ頂点（プログラムの開 始ポイント）を Vとする。ステップ S2で、頂点 V以下の制御の流れを再構成する。以上 で処理を終了する。
[0076] 図 8は、頂点 V以下の制御の流れを再構成する処理（図 7のステップ S 2)を示すフロ 一チャートである。図 8の処理の入力は、縮退したプログラム依存グラフ PDG及び頂 点 Vである。
[0077] ステップ S 1で、 Region(v， Ύ) = {u \ u ≡ V, v→ Tu ≡ E}が空集合であるか否かを判 断する。空集合であれば処理を終了し、空集合でなければステップ S 2に進む。ここ で Region(v， T)とは、頂点 uの集合であって、頂点 vから頂点 uへの L=Fの制御依存関 係が存在するものである。ここで Vは頂点集合、 Eは辺集合、 v→ Tuは L=Fの制御依 存辺を示すものである。
[0078] ステップ S2で、 Region(v， T)の実行順序関係を計算する。ステップ S3で、 Region(v， F) = {u | u e V, v→ Fu e E}が空集合であるか否かを判断する。空集合であれば処 理を終了し、空集合でなければステップ S4に進む。ここで Region(V， F)とは、頂点 uの 集合であって、頂点 Vから頂点 uへの L=Fの制御依存関係が存在するものである。以 上で処理を終了する。
[0079] 図 9は、 Regionの実行順序関係を計算する処理を示すフローチャートである。この 処理は、図 8のステップ S2及びステップ S4の各々に対応する。図 9の処理の入力は 、縮退したプログラム依存グラフ PDG及び V' (着目 Region)である。
[0080] ステップ S 1で、着目領域 V'の各頂点 Vについて、ステップ S2乃至 S 3の処理を繰り 返すループを開始する。ステップ S 2で、 Vがプレディケート頂点（If-then-else又は whi le-loopの条件判定を表す頂点）であるか否かを判断する。 Vがプレディケート頂点で ある場合のみ、ステップ S3を実行する。ステップ S3で、頂点 V以下の実行順序関係 を計算する。 [0081] 次に、ステップ S4で、逆依存及び出力依存を求める。ここでは制御の流れに起因 するデータ依存関係 (逆依存、出力依存)を抽出する。具体的には、着目領域 (Regio n)を越えるデータ依存関係から、着目領域内の逆依存及び出力依存を表出する。
[0082] 次に、ステップ S 5で、逆依存及び出力依存を求める。ここでは着目領域 (Region) 内の実行順序を決定する。即ち、実行順序が一意に定まらない Region内頂点の集合 について適切な実行順序制約を決定する。具体的には、求められた逆依存関係や 出力依存関係などによる実行順序制約をもとに、 Region内の逆依存関係や出力依存 関係を明らかにして、実行順序を決定する。実行順序が任意となる場合は、実行順 序を仮定して逆依存関係、出力依存関係を求め、矛盾が起きない実行順序が得ら れるまで試行を繰返す。
[0083] 最後にステップ S6でスケジューリングを行う。即ち、上で求めた実行順次関係に基 づいて頂点の実行順を決定する。これは、半順序関係の成立するグラフのスケジュ 一リングという一般的な問題に帰着できる。従って、トポロジカル 'ソートや、頂点の実 行時間の概算を重みとしたリスト'スケジューリングなどのよく知られたスケジユーリン グ手法を適用することができる。
[0084] 図 10は、逆依存及び出力依存を求める処理（図 9のステップ S4)を示すフローチヤ ートである。図 10の処理の入力は、縮退したプログラム依存グラフ PDG及び V' (着目 Region)でめ。。
[0085] ステップ S1で、着目領域 V'を越える変数参照を抽出して V とする。ステップ S2で def
、着目領域 V'を越える変数代入を抽出して V とする。ステップ S3で、 V 及び V'に use use 基づいて逆依存辺を追加する。ステップ S4で、 V 及び V，に基づいて出力依存辺を def
追加する。以上で処理を終了する。
[0086] 図 11は、着目領域を越える変数参照を抽出する処理を示すフローチャートである。
図 11の処理は図 10のステップ S 1に相当し、縮退したプログラム依存グラフ PDG及 び V， (着目 Region)を入力とする。
[0087] ステップ S1で、頂点の集合 V を空にする。ステップ S2で、着目領域 V'内の各フロ use
一依存辺について以降の処理を繰り返すループを開始する。ここでフロー依存辺と しては、ループ独立フロー依存辺とループ繰り越しフロー依存辺とを含む。ステップ S 3で、フロー依存辺 eの依存元頂点を uとするとともに、辺 eの依存先頂点を Vとする。
[0088] ループ繰り越しフロー依存辺である場合には、ステップ S4で、依存先頂点 Vが着目 領域 V'に含まれるという条件が満たされるか否かを判定する。またループ独立フロー 依存辺である場合には、ステップ S5で、依存元頂点 uが着目領域 V'に含まれず且つ 依存先頂点 Vが着目領域 V'に含まれるという条件が満たされるか否かを判定する。こ の判定結果力yesの場合のみ、ステップ S6を実行する。ステップ S6で、頂点の集合 V に依存先頂点 Vを追加する。
use
[0089] 最後に、ステップ S7で、頂点の集合 V を値として返す。以上で処理を終了する。
use
[0090] 図 12は、着目領域を越える変数代入を抽出する処理を示すフローチャートである。
図 12の処理は図 10のステップ S2に相当し、縮退したプログラム依存グラフ PDG及 び V， (着目 Region)を入力とする。
[0091] ステップ S1で、頂点の集合 V を空にする。ステップ S2で、着目領域 V'内の各フロ def
一依存辺について以降の処理を繰り返すループを開始する。ここでフロー依存辺と しては、ループ独立フロー依存辺とループ繰り越しフロー依存辺とを含む。ステップ S 3で、フロー依存辺 eの依存元頂点を uとするとともに、辺 eの依存先頂点を Vとする。
[0092] ループ繰り越しフロー依存辺である場合には、ステップ S4で、依存先頂点 Vが着目 領域 V'に含まれるという条件が満たされるか否かを判定する。またループ独立フロー 依存辺である場合には、ステップ S5で、依存元頂点 uが着目領域 V'に含まれ且つ依 存先頂点 Vが着目領域 V'に含まれなレ、と!/、う条件が満たされるか否かを判定する。 何れかの判定結果力 Syesの場合のみ、ステップ S6を実行する。ステップ S6で、頂点 の集合 V に依存先頂点 Vを追加する。
def
[0093] 最後に、ステップ S7で、頂点の集合 V を値として返す。以上で処理を終了する。
def
[0094] 図 13は、逆依存の追加処理を示すフローチャートである。図 13の処理は図 10のス テツプ S3に相当し、縮退したプログラム依存グラフ PDG、 V (着目 Region)、及び頂 点集合 V を入力とする。
use
[0095] ステップ SIで、頂点集合 V の各頂点 Vに対して以降の処理を繰り返すループを use
開始する。ステップ S2で、頂点 Vで使用する各変数 Xに対して以降の処理を繰り返す ループを開始する。ステップ S3で、着目領域 V'の各頂点 uに対して以降の処理を繰 り返すループを開始する。
[0096] ステップ S4で、頂点 uが変数 Xを定義するか否かを判定する。判定結果が yesの場 合のみ、ステップ S5を実行する。ステップ S5において、 Vから uへの逆依存辺を追加 する。以上で処理を終了する。
[0097] 図 14は、出力依存の追加処理を示すフローチャートである。図 14の処理は図 10の ステップ S4に相当し、縮退したプログラム依存グラフ PDG、 V (着目 Region)、及び頂 点集合 V を入力とする。
def
[0098] ステップ S Iで、頂点集合 V の各頂点 uに対して以降の処理を繰り返すループを
def
開始する。ステップ S2で、頂点 uで使用する各変数 Xに対して以降の処理を繰り返す ループを開始する。ステップ S3で、着目領域 V'の各頂点 Vに対して以降の処理を繰 り返すループを開始する。
[0099] ステップ S4で、頂点 Vが変数 Xを定義するか否かを判定する。判定結果が yesの場 合のみ、ステップ S5を実行する。ステップ S5において、 Vから uへの出力依存辺を追 加する。以上で処理を終了する。
[0100] 図 15は、逆依存及び出力依存を求める処理（図 9のステップ S5)を示すフローチヤ ートである。図 15の処理の入力は、縮退したプログラム依存グラフ PDG及び V' (着目
Region)でめ。。
[0101] ステップ S 1で、着目領域内の全域木を求め Sとする。変数 Xを定義する頂点 Vとその 変数 Xを使用する RegionR内の頂点との集合として、頂点 Vの変数 Xに関する全域木 が、
Span(v, x) = {v} U {u| v→ u ^ E }
li R
と定義される。図 16は、全域木を説明するための図である。図 16に示されるプロダラ ム依存グラフにおいて、頂点 Vにおいて変数 Xが定義され、 2つの頂点 vl及び v2が 変数 Xを使用する。この場合、頂点 v、 vl、及び v2で全域木 21を形成する。また頂点 Vにおいて変数 Xが定義され、 2つの頂点 v3及び v4が変数 Xを使用する。この場合、 頂点 v、 v3、及び v4で全域木 22を形成する。図 17は、全域木を模式的に示す図で ある。全域木 Span(v， X)及び全域木 Span(v， x)が、データ依存グラフとして図 17に示 されるように構成される。 [0102] 図 15に戻り、ステップ S2で、実行順が未決定である 2つの任意の全域木を順次選 択して以降の処理を繰り返すループが開始される。ステップ S3で、着目領域に閉路 がなぐ同一変数 Xに対する独立した全域木 Span(h，x)及び Span(h，x)が存在するか
0 1
否かを判定する。ここで、「独立した」とは、 2つの全域木 Span(h，x)及び Span(h，x)に
0 1 ついて、 Span(h，x)に含まれる頂点と Span(h，x)に含まれる頂点との間に辺（依存関係
0 1
)がないことを言う。
[0103] ステップ S4で R (Region)のオリジナルをスタックに退避させる。ステップ S5で、 h→h
o の出力依存辺を追加し、推移閉包を求める。ステップ S6で、全域木間の順序関係を
1
計算する。
[0104] ステップ S7で、 R (Region)に閉路が存在するか否かを判定する。存在しない場合 には、以降の処理ステップ S8〜ステップ S 11をスキップする。存在する場合には、ス テツプ S8に進む。ステップ S8で、スタックが空か否かを判断する。空の場合にはエラ 一終了する。空でない場合には、ステップ S9で、 Rのオリジナルをスタックから取り出 す。
[0105] 以上の処理は、頂点 hから hへの出力依存関係をグラフに追加したときに、巡回グ
0 1
ラフとならない場合には追加した依存関係を確定させ、巡回グラフになった場合には 元のグラフに戻すことに相当する。元のグラフに戻した後は、以降に示すように、頂点 h力も hへの出力依存関係をグラフに追加する。即ち、ステップ s ioで、 h→hの出
1 0 1 0 力依存辺を追加し、推移閉包を求める。ステップ S 11で、全域木間の順序関係を計 算する。
[0106] 以上の処理により、 2つの全域木 Span(h，x)及び Span(h，x)に対する実行順序が決
0 1
定する。更に、実行順が未決定である 2つの任意の全域木を順次選択して同様の処 理を繰り返し、全ての全域木間の順序関係が決定されたところで終了する。
[0107] 図 18は、全域木間の順序関係を計算する処理を示すフローチャートである。図 18 の処理は、図 15のステップ S6及びステップ S 11に相当する。図 18の処理の入力は 、縮退したプログラム依存グラフ PDG及び V' (着目 Region)である。
[0108] ステップ S1で、着目領域内の各辺 e (頂点 v→頂点 w)について以降の処理を繰り 返すループを開始する。ステップ S 2で、頂点 wで定義され、頂点 Vで参照される各変 数 xについて以降の処理を繰り返すループを開始する。
[0109] ステップ S3で、 V — { u
a I V e Span(u, x) }とするとともに、 V — { u | w e Span(u, x b
) }とする。これは、頂点 Vを要素として含む変数 Xに関する全域木における変数 Xを定 義する頂点の集合を求めるとともに、頂点 Wを要素として含む変数 Xに関する全域木 における変数 Xを定義する頂点の集合を求めることである。
[0110] ステップ S4で、 Vの各頂点 Vについて以降の処理を繰り返すループを開始する。
ステップ S 5で、 Vの各頂点 Vについて以降の処理を繰り返すループを開始する。更 b b
にステップ S6で、 Span(v， x)の頂点であって Span(v， x)の頂点でない各頂点 vにつ a b c いて以降の処理を繰り返すループを開始する。
[0111] ステップ S7で、 vc→vbが E (辺集合）に含まれるか否かを判定する。判定結果が ye sの場合のみステップ S8を実行する。ステップ S8で、 V→vの逆依存辺を追加し、推 c b
移閉包を求める。以降、各ループの処理を繰り返す。
[0112] 図 19は、図 18の処理による逆依存辺の追加について説明する図である。図 19に は、頂点 Vの変数 Xに関する全域木 Span(v，x)と頂点 wの変数 Xに関する全域木 Span(w ，x)とが示される。頂点 Vを要素として含む変数 Xに対する全域木 Span(v， x) (即ち Span (v，x))の各頂点 V (即ち v、 25、 26)に対して、全域木 Span(v， x) (即ち Span(w，x))の c b
ヘッド V (変数を定義している頂点 w)への逆依存辺 32、 33を追加する。
b
[0113] 図 20は、頂点間の実行順序関係を決定する方法の変形例を示すフローチャートで ある。図 20のフローチャートに示す処理を、図 7のフローチャートに示す処理の代わ りに用いてもよい。即ち、頂点間の実行順序関係を決定する処理において、前段階 のステップ SOとして、 SSA (静的単一代入形式）を適用する処理を実行してもよい。 即ち、縮退プログラム依存グラフを静的単一代入形式に変換してもよい。この場合、 図 9に示すステップ S 7の処理（逆依存、出力依存を求め着目領域内の実行順序を 決定する処理：図 15のフローチャート）を省略することができる。
[0114] 以上により、頂点間の実行順序関係を決定し、逆/出力依存関係を抽出すること カできる。即ち、図 6のステップ S 1の処理が実行される。
[0115] 図 21は、基本ブロックを抽出する処理のフローチャートを示す図である。図 21に示 す処理は、図 6のステップ S2の処理に相当する。図 21の処理の入力は、実行順序 関係が決定された縮退したプログラム依存グラフである。
[0116] 求めた制御の流れの順に頂点を探索し、頂点の種類に応じた処理を行なう。以下 の説明において Bは基本ブロックの集合であり、 Bは i番目の基本ブロックである。ま た Vは現在の頂点（着目頂点）であり、 uは現在の頂点の 1つ前の頂点である。
[0117] まずステップ S2で、最初の基本ブロック BOを空集合として生成する。次にステップ S2で、 uをエントリ頂点（プログラムの開始ポイント）として、 Vをエントリ頂点の次の頂 点とする。ステップ S4で、現在の頂点 Vが最終頂点であるか否力、を判断する。最終頂 点である場合には、処理を終了して基本ブロックの集合 Bが生成される。
[0118] 現在の頂点 Vが最終頂点でない場合には、ステップ S5に進み、現在の頂点 Vがプ レディケート頂点（If-then-else又は while-loopの条件判定を表す頂点）であるか否か を判断する。プリディケート頂点である場合には、ステップ S6に進み、 iをインクリメント してから の要素を Vとすることで、新たなプリディケートのみの基本ブロック Bを形成 する。その後ステップ S 7で、更に iをインクリメントして、新たな空集合の基本ブロック B を形成する。
[0119] 現在の頂点 Vがプレディケート頂点でない場合（S 5で Noの場合）には、ステップ S8 で、現在の頂点 Vと 1つ前の頂点 uとが、同一のプレディケート頂点からの制御依存関 係を有し、且つその制御依存関係が同一の条件判定フラグに基づくものであるか否 かを判定する。この判定結果が NOとなるのは、例えば uと Vとが、 IF文の内部と外部 とに対応する場合や、 IF文の THEN節と ELSE節とに対応する場合等である。即ち 、ステップ S8においては、同一の条件判定に応じて双方共に実行される 2つの頂点 であるか否かが判定されて!/、る。
[0120] ステップ S8の判定が YESの場合には、ステップ S9で、現在の基本ブロックに現在 の頂点 Vを追加する。ステップ S8の判定が NOの場合には、ステップ S10で、 iをイン クリメントして新たな空集合の基本ブロック Bを形成する。その後ステップ S11で、この 新たに生成された基本ブロック Bに現在の頂点 Vを追加する。その後ステップ S 12で uと Vとをそれぞれ次の頂点に更新し、ステップ S4に戻り以降の処理を繰り返す。
[0121] 以上の処理により、分岐（IF、 GOTO, LOOP等）や合流を含まない順番に実行さ れる頂点の列である各基本ブロック Bを生成し、これらの基本ブロックを要素とする基 本ブロックの集合 Bを生成することができる。分岐や合流を含まない頂点の列とは、固 定の 1つの実行順に従い順番に実行される頂点の列のことである。図 21のフローチ ヤートから分かるように、各プレディケート頂点は単独で 1つの基本ブロック Bを構成し 、プレディケート頂点でない 1つの基本ブロック には、途中で分岐も合流もなく固定 の 1つの実行順に従い順番に実行される頂点の列が含まれることになる。
[0122] 本発明では、異なる基本ブロックをまたいでの手続き間の依存関係については、先 行手続きの終了待ち合わせを行ってから、後続手続きを実行するようにする。また同 一の基本ブロック内部で依存関係がある手続きの実行につ!/、ては、依存関係待ち合 わせ付き非同期遠隔手続呼び出しにより手続きを実行する。即ち、基本ブロック間を またいでの依存関係がある手続きについては先行手続きを待ち合わせる命令の後に 後続手続きを実行する命令を配置することにより、依存関係を満たすように手続き制 御する。また同一の基本ブロック内部で依存関係がある手続きについては後続手続 きの先行手続きへの依存関係を明示的に登録する命令を生成するようにして、依存 関係を満たすように手続き制御する。このような構成とすることで、複雑な制御の依存 関係が存在する基本ブロック間については、手続きの実行を待ち合わせにより実現 することで制御プログラムの生成を容易なものとし、実行順が固定である同一基本ブ ロック内については、依存関係待ち合わせ付き非同期遠隔手続呼び出しにより無駄 な待ち合わせ時間をなくすことができる。
[0123] 以上により、基本ブロックを抽出することができる。即ち、図 6のステップ S2の処理が 実行される。
[0124] 以下にお!/、て、制御プログラムを生成する処理や生成した制御プログラムの具体例 等について説明する。以下の説明は、依存関係待ち合わせ付き非同期遠隔手続き 呼び出し方式を共有メモリで実現する第 1の実施例と、依存関係待ち合わせ付き非 同期遠隔手続き呼び出し方式を分散メモリで実現する第 2の実施例とで異なる。
[0125] まず依存関係待ち合わせ付き非同期遠隔手続き呼び出し方式を共有メモリで実現 する第 1の実施例について説明する。
[0126] 図 22は、制御プログラムを生成する処理のフローチャートを示す図である。図 22に 示す処理は、図 6のステップ S4 (及び S5)の処理に相当する。図 22の処理の入力は 、実行順序関係が決定された縮退したプログラム依存グラフ及び基本ブロックの集合 Bである。
[0127] ステップ S1において、プログラムの先頭を表すエントリ頂点 V の直下の子頂点 V
Entry
を要素とする基本ブロックの集合を B'とする。ステップ S2において、 B'の各要素 Bに ついて、 iの昇順に以降の処理を繰り返すループを開始する。ステップ S3で、 Bにつ いての手続き制御プログラムを生成する。ステップ S4で、手続きの終了待ち合わせを 生成する。
[0128] 図 23は、基本ブロックの集合 B'の要素 B以下の手続き制御プログラムを生成する 処理を示すフローチャートである。図 23の処理は、図 22のステップ S3に相当する。 図 23に示す処理の入力は縮退したプログラム依存グラフ PDG及び基本ブロック要 素 Bである。
[0129] なおここでは、全ての手続き呼び出しを待ち合わせる方法と、制御の流れによって 、待ち合わせが行なわれな!/、可能性がある全ての手続き呼び出しを待ち合わせる方 法の 2つが考えられる。制御の流れによらず必ず待ち合わせが行なわれる頂点 V'の 集合は次のように表現できる。
國
V'={veV |つョ u Bi ν→ω uEE 且つ ve≡Bi 且つ
(uが vの祖先 或いは 「ョ w w→cLUEE 且つ w→cLxe≡E (x=v又は vの祖先)）
従って、待ち合わせが行なわれない頂点の集合 V"は、プログラム ·ブロック頂点の集 合 VPBと頂点集合 V'の差分 V"=VPB-V'として表現できる。
[0130] 図 23のステップ S 1で、基本ブロック Bの要素（頂点）の種類を判定する。基本ブロッ ク Bの要素である頂点の種類を判定することによって、基本ブロック Bがプログラム' ブロックの集合である力、、プレディケート頂点であるかが分かる。
[0131] ステップ S1の判定の結果、基本ブロック Bがプログラム.ブロックの集合の場合は、 基本ブロック Bに属する頂点の手続きを呼び出す文とその間の依存関係を登録する 文とを生成することとなる。具体的には、まずステップ S2において、基本ブロック の 先行手続きに対する待ち合わせを生成する。この際、ブロック外からブロック内への フロー依存関係に関して、手続きの終了待ち合わせを生成する。また同時に、定義 順序関係及び逆依存関係、出力依存関係に関しても、手続きの終了待ち合わせを 生成する。これは、共有メモリ上の同一変数に対して、データが読み書きされる順を 保証するための待ち合わせである。ここでは、次の 5種類の依存関係について、出力 元頂点の手続き終了待ち合わせを生成する。
[0132] 1. Bへのループ繰越フロー依存辺
2. Bから B (i≠x)へのループ独立フロー依存辺
3. Bへの定義順序関係、
4. Bへの逆依存関係、
5. Bへの出力依存関係
なお同一頂点への待ち合わせが複数ある場合は、 1つの待ち合わせに集約する。
[0133] 次にステップ S3で、基本ブロック Bの各頂点 Vについて、実行順序の順番で以降の 処理を繰り返すループを開始する。ステップ S4で、頂点 Vの非同期遠隔手続き呼び 出しを生成する。ステップ S5で、基本ブロック Bに属する頂点から頂点 Vへのループ 独立フロー依存関係に関して依存関係を登録する文を生成する。基本ブロック Bの 全ての頂点 Vについてこれらの処理を繰り返した後に、ステップ S6で、実行開始を指 示する文を生成する。
[0134] ステップ S1の判定の結果、基本ブロック Bがプリディケート頂点 Vの場合は、頂点 V の表す制御構造を生成する。まずステップ S7で、基本ブロック Bの要素 Vの先行手続 きに対する待ち合わせを生成する。即ち、条件式で参照する変数の値を確定するた めに、入力フロー依存辺について、先行する手続き呼び出しを待ち合わせる文を生 成する。ここでは、当該頂点の外のループを繰り越すフロー依存辺と、当該頂点への ループ独立フロー依存辺との 2種類のデータ依存入力辺について、出力元頂点の 手続き終了待ち合わせを生成する。
[0135] 次にステップ S8で、頂点 Vのプレディケートの種類を判定する。プレディケ一トがル ープである場合には、ステップ S9に進む。プレディケートが if文である場合には、ステ ップ S I 4に進む。
[0136] ステップ S8の判定結果がループを示す場合には、ステップ S9において、入力逐次 プログラムにお!/、て相当する for文或いは while文を生成する。次にステップ S 10に ぉレ、て、頂点 Vへの L=Tの制御依存関係がある頂点 uを要素とする基本ブロックの集 合を B'とする。ステップ S11において、 B'の各要素 Bについて、 iの昇順に以降の処 理を繰り返すループを開始する。ステップ S 12で、 Bについての手続き制御プロダラ ムを生成する。このステップ S 12は入れ子構造となっており、 Bについてステップ S12 を実行することは、この Bについて図 23全体のフローチャートを実行することに相当 する。
[0137] ループの終了後、ステップ S13で、頂点 Vへのループを繰り越す先行手続きの終了 待ち合わせを生成する。これは、ループを繰り越して条件を判定するので、本文の末 尾に、条件式への入力データ待ち合わせ（自ループを繰り越す入力フロー依存辺） を行なう文を追加するものである。
[0138] ステップ S8の判定結果が if文を示す場合には、ステップ S14において、 if文を生成 する。次にステップ S 15で、 then節を生成する。ステップ S 16で、頂点 vへの L=Tの制 御依存関係がある頂点 uを要素とする基本ブロックの集合を B'とする。ステップ S 17 において、 B'の各要素 Bについて、 iの昇順に以降の処理を繰り返すループを開始 する。ステップ S 18で、 Bについての手続き制御プログラムを生成する。このステップ S 18は入れ子構造となっており、 Bについてステップ S 18を実行することは、この Bに ついて図 23全体のフローチャートを実行することに相当する。なおステップ S17及び S 18で生成された文が、 then節の本文を構成することになる。
[0139] 次にステップ S 19で、頂点 Vへの L=Fの制御依存関係がある頂点 uを要素とする基 本ブロックの集合を B'とする。ステップ S20で、基本ブロックの集合 B'が空集合である か否かを判定し、空集合の場合には処理を終了する。基本ブロックの集合 B'が空集 合でない場合、ステップ S21で、 else節を生成する。ステップ S22で、 B'の各要素 B について、 iの昇順に以降の処理を繰り返すループを開始する。ステップ S23で、 B についての手続き制御プログラムを生成する。このステップ S23は入れ子構造となつ ており、 Bについてステップ S23を実行することは、この Bについて図 23全体のフロ 一チャートを実行することに相当する。なおステップ S22及び S23で生成された文が 、 else節の本文を構成することになる。
[0140] 以上の処理を実行することで、基本ブロック B以下の手続き制御プログラムが生成 される。図 24は、第 1の実施例の場合の手続き制御プログラムの構造を示す図であ
[0141] 図 24に示されるように、本発明の第 1の実施例の場合の制御プログラムは、変数の 宣言初期化部分 41、プレディケートへの入力データ待合わせ部分 42、プレディケ一 トの制御構造の生成部分 43、基本ブロックへの入力データ'依存関係の待ち合わせ 部分 44、基本ブロック内のスレッド起動と依存関係登録部分 45、及び手続きの終了 の待ち合わせ終了処理部分 46を含む。基本ブロックへの入力データ'依存関係の待 ち合わせ部分 44では、非同期遠隔手続き呼び出しの起動、依存関係の登録、手続 きのディスパッチ（実行開始）を行う。
[0142] なお第 1の実施例においては、複数のプロセッサに共通の共有メモリを用いる。共 有メモリを用いる場合、非同期遠隔手続き呼び出しを指示した段階では、先行する 手続きの結果が得られていない可能性があり、引数として値を渡すことができない場 合がある。そこで、手続きの入出力データは、共有メモリ上の適切な場所に格納され るものとし、そのアドレスを渡すこととする。
[0143] 即ち、手続きの生成においては、入力変数の値が格納されるアドレスと出力結果を 格納するアドレスとを手続きの引数とするように、手続きを構成する。更に、頂点の部 分プログラムが使用したり定義したりする変数であって、入力の変数以外の変数を求 め、それらの変数に対する宣言部を生成する。更に、部分プログラムを出力し、最後 に、引数として受け取ったアドレスに対して、出力する変数の値を代入する文を生成 する。
[0144] このように共有メモリの場合は、特定のメモリ領域への値の書き込み/参照という形 で、入出力データを受け渡す。そのため、データの依存関係から、値を書き込む手 続きの完了を待ち合わせて、後続の値を参照する手続きを実行することとなる。
[0145] 以下に、第 1の実施例により生成された手続きプログラム及び手続き制御プログラム につ!/、て、その構成及び動作を具体的な例を用いて説明する。 [0146] 図 25は、（a)入力逐次プログラムの部分及び (b)対応する縮退プログラム依存ダラ フを示す図である。図 25 (a)に示す入力逐次プログラムからプログラム依存グラフを 生成し、頂点を結合して縮退することにより、（b)に示す縮退プログラム依存グラフが 生成される。頂点 V力、ら Vが存在し、頂点 Vは縮退により文の集合となっている。
0 6 4
[0147] 図 26は、図 25の縮退プログラム依存グラフから第 1の実施例に従い生成される手 続き制御プログラムである。最初に変数の宣言があり、使用する変数 X, y, z , a, b, p を宣言する。その後、まず頂点 Vに対応する手続き νθの開始を登録する（文 51)。そ
0
の後のディスパッチ命令（dispatch)により、実行可能手続きである手続き νθが実行 される。
[0148] 図 25 (a)に示す逐次プログラムの while文の中は、（b)に示す縮退プログラム依存 グラフの頂点 V乃至 Vに対応し、 1つの基本ブロックに相当する。この基本ブロック中
2 5
の頂点 V乃至 Vのうちで、 Vは定義順序関係に従い Vを待ち合わせる必要があり、 V
2 5 3 0
はループ繰越フロー依存に従い Vを待ち合わせる必要がある。従って、文 52でこれ
2 5
らの待ち合わせを実現する。
[0149] 基本ブロック中のグラフの頂点 V乃至 Vについては、手続きと依存関係の登録文 5
2 5
3により、手続きと依存関係とを登録する。即ち、頂点 V乃至 Vに対応する手続き v2
2 5
乃至 v5を登録すると共に、 Vが Vに依存し、 Vが Vに依存することが登録される。即
3 2 5 4
ち、 a = C (x)は x = B (z)が終了しないと実行できないし、 z = F (y)は y=E (p)が終 了しないと実行できない。なお手続き及び依存関係の登録と手続きの実行とについ ては、図 2に示した仕組みと同様であり、手続き呼出しプログラム 3が管理する各プロ セッサ毎のキューに手続きと依存関係を登録し、実行可能状態となった手続きを順 次実行していく。具体的に、これらの手続きと依存関係の登録文 53の後に、ディスパ ツチ文 54により実行を指示する。このディスパッチ命令により、上記頂点 V乃至 Vに
2 5 対応する手続き v2乃至 v5は、各々実行可能状態となると直ちに実行される。
[0150] whileループの最後で、 vの終了待ち合わせを設定する。これは vにより while文
4 4
の条件の変数 Pが計算されるためである。
[0151] whileループの後、 Vに対応する手続き v6を実行する前には、 vに対する手続き
6 3
終了待ち合わせが設定される（文 56)。これは Vが Vに依存し、且つ Vと Vとが異なる 基本ブロックに属するからである。
[0152] 図 27は、以上の手続き制御プログラムの動作を手続きプログラムの実行とともに示 す模式図である。図 27では、プロセッサ 0と手続き vO、 v2乃至 v6にそれぞれ対応す るプロセッサとが用いられる。プロセッサ 0により手続き制御プログラムを実行する。
[0153] まず手続き νθの手続きプログラム 61が、対応するプロセッサにより実行される。 whi le文の条件が成立すると、手続き νθが実行中であるので、 νθの終了を待ち合わせす
[0154] 手続き νθが終了し、手続きと依存関係が登録され、ディスパッチ命令が実行される と、手続き v2と v4とにそれぞれ対応する手続きプログラム 62及び 64が、対応するプ 口セッサにより実行される。また登録された依存関係に基づいて、 v2が終了すると直 ちに、手続き v3の手続きプログラム 63が対応するプロセッサにより実行される。同様 に、登録された依存関係に基づいて、 v4が終了すると直ちに、手続き v5の手続きプ ログラム 65が対応するプロセッサにより実行される。
[0155] なお v2はループ繰越フロー依存に従い v5を待ち合わせる必要がある。従って、 wh ile文の次のループに入った際に、手続き v5の手続きプログラム 65が実行中の間は V 2や V4の手続きは実行されずに、手続き v5の終了を待ち合わせることになる。
[0156] while文のループが終了すると、手続き v3の終了を待ち合わせてから、手続き v6の 手続きプログラム 66が対応するプロセッサにより実行される。
[0157] この例において、手続き vlが第 1の基本ブロックに属し、手続き v2乃至 v5が第 2の 基本ブロックに属し、手続き v3が第 3の基本ブロックに属する。このように、異なる基 本ブロックをまたいでの手続き間の依存関係（例えば v3から νθへの依存関係）につ いては、先行手続きの終了待ち合わせを行ってから、後続手続きを実行するようにす る。また同一の基本ブロック内部で依存関係がある手続き v2乃至 v5の実行について は、依存関係待ち合わせ付き非同期遠隔手続呼び出しにより手続きを実行する。こ のような構成とすることで、複雑な制御の依存関係が存在する基本ブロック間につい ては、手続きの実行を待ち合わせにより実現することで制御プログラムの生成を容易 なものとし、実行順が固定である同一基本ブロック内については、依存関係待ち合わ せ付き非同期遠隔手続呼び出しにより無駄な待ち合わせ時間をなくすことができる。 [0158] 以下に、依存関係待ち合わせ付き非同期遠隔手続き呼び出し方式を分散メモリで 実現する第 2の実施例について説明する。図 28は、第 2の実施例の場合の制御プロ グラムを生成する処理のフローチャートを示す図である。図 28に示す処理は、図 6の ステップ S4 (及び S5)の処理に相当する。図 28の処理の入力は、実行順序関係が 決定された縮退したプログラム依存グラフ及び基本ブロックの集合 Bである。
[0159] ステップ S1において、プログラムの先頭を表すエントリ頂点 V の直下の子頂点 V
Entry
を要素とする基本ブロックの集合を B'とする。ステップ S2において、 B'の各要素 Bに ついて、 iの昇順に以降の処理を繰り返すループを開始する。ステップ S3で、 Bにつ いての手続き制御プログラムを生成する。ステップ S4で、手続きの出力データ転送 待ち合わせを生成する。
[0160] 図 29は、基本ブロックの集合 B'の要素 B以下の手続き制御プログラムを生成する 処理を示すフローチャートである。図 29の処理は、図 28のステップ S3に相当する。 図 29に示す処理の入力は縮退したプログラム依存グラフ PDG及び基本ブロック要 素 Bである。
[0161] 図 29のステップ S 1で、基本ブロック Bの要素（頂点）の種類を判定する。基本ブロッ ク Bの要素である頂点の種類を判定することによって、基本ブロック Bがプログラム' ブロックの集合である力、、プレディケート頂点であるかが分かる。
[0162] ステップ S1の判定の結果、基本ブロック Bがプログラム.ブロックの集合の場合は、 基本ブロック Bに属する頂点の手続きを呼び出す文とその間の依存関係を登録する 文とを生成することとなる。具体的には、まずステップ S2において、基本ブロック Bへ の入力の待ち合わせを生成する。この際、ブロック外からブロック内へのフロー依存 関係に関して、データ転送の待ち合わせを生成する。また定義順序関係及び逆依存 関係、出力依存関係に関しても、データ転送の待ち合わせを生成する。即ち、次の 5 種類の辺につ!/、て待ち合わせを生成する。
[0163] 1. Bの要素へのループ繰越フロー依存辺
2. Bの要素から Bの要素（i≠x)へのループ独立フロー依存辺
3. Bの要素への定義順序関係
4. Bの要素への逆依存関係 5. Biの要素への出力依存関係
なお逆依存関係がある場合は、先行頂点の手続きの終了待ち合わせを生成する。こ れは、制御プログラム上の同一変数に対して、データが転送される順を保証するため の待ち合わせである。
[0164] 次にステップ S3で、基本ブロック Bの各頂点 Vについて、実行順序の順番で以降の 処理を繰り返すループを開始する。ステップ S4— 1で、基本ブロックを越える頂点 V への入力データ転送指示及び実行結果の出力データ転送指示を生成する。具体的 には、ブロックを越えるデータ依存関係がある場合は、制御プロセッサ上の変数にデ ータがあるため、手続きを実行するプロセッサに対してこのデータを転送する。具体 的には、次の 2種類の辺について制御プロセッサ力、ら遠隔プロセッサへのデータ転 送を生成する。
[0165] 1.頂点 Vへのループ繰越フロー依存辺
2. Bの要素でな!/、uから頂点 Vへのループ独立フロー依存辺
次にステップ S4— 2で、頂点 Vの遠隔手続き呼び出しを行う文を生成する。
[0166] 更にステップ S5— 1で、入力データ転送への依存関係を登録する文を生成する。
ブロック内のデータ依存の場合は、先行する手続きから直接データが転送されるため 、これに対する依存関係を登録する。
[0167] 更にステップ S5— 2で、頂点 Vからの実行結果のデータ転送を指示する文を生成 する。この際、基本ブロック越えない手続きへのデータ依存の場合は、後続手続きを 実行するプロセッサに直接データ転送する。また基本ブロックを越えるデータ転送の 場合は、制御プロセッサへとデータを転送する。またステップ S5— 2では、これらのデ ータ転送指示から手続き呼び出しへの依存関係を登録する文も併せて生成する。
[0168] 基本ブロック Bの全ての頂点 Vについて上記の処理を繰り返した後に、ステップ S6 で、実行開始を指示する文を生成する。
[0169] ステップ S1の判定の結果、基本ブロック Bがプリディケート頂点 Vの場合は、頂点 V の表す制御構造を生成する。まずステップ S 7で、基本ブロック Bの要素 Vへのデータ 転送待ち合わせを生成する。即ち、条件式で参照する変数の値を確定するために、 入力フロー依存辺の待ち合わせを行なう文を生成する。ここでは、当該頂点の外の ループを繰り越すフロー依存辺と、当該頂点へのループ独立フロー依存辺との 2種 類の辺につ!/、て待ち合わせを生成する。
[0170] 次にステップ S8で、頂点 Vのプレディケートの種類を判定する。プレディケ一トがル ープである場合には、ステップ S9に進む。プレディケートが if文である場合には、ステ ップ S 14に進む。
[0171] ステップ S8の判定結果がループを示す場合には、ステップ S9において、入力逐次 プログラムにお!/、て相当する for文或いは while文を生成する。次にステップ S 10に ぉレ、て、頂点 Vへの L=Tの制御依存関係がある頂点 uを要素とする基本ブロックの集 合を B'とする。ステップ S11において、 B'の各要素 Bについて、 iの昇順に以降の処 理を繰り返すループを開始する。ステップ S 12で、 Bについての手続き制御プロダラ ムを生成する。このステップ S 12は入れ子構造となっており、 Bについてステップ S12 を実行することは、この Bについて図 29全体のフローチャートを実行することに相当 する。
[0172] ループの終了後、ステップ S13で、プレディケート頂点 Vへのデータ転送待ち合わ せを生成する。これは、ループを繰り越して条件を判定するので、本文の末尾に、条 件式への入力データ待ち合わせ（自ループを繰り越す入力フロー依存辺）を行なう 文を追加するものである。
[0173] ステップ S8の判定結果が if文を示す場合には、ステップ S14において、 if文を生成 する。次にステップ S 15で、 then節を生成する。ステップ S 16で、頂点 vへの L=Tの制 御依存関係がある頂点 uを要素とする基本ブロックの集合を B'とする。ステップ S 17 において、 B'の各要素 Bについて、 iの昇順に以降の処理を繰り返すループを開始 する。ステップ S 18で、 Bについての手続き制御プログラムを生成する。このステップ S 18は入れ子構造となっており、 Bについてステップ S 18を実行することは、この Bに ついて図 29全体のフローチャートを実行することに相当する。なおステップ S17及び S 18で生成された文が、 then節の本文を構成することになる。
[0174] 次にステップ S 19で、頂点 Vへの L=Fの制御依存関係がある頂点 uを要素とする基 本ブロックの集合を B'とする。ステップ S20で、基本ブロックの集合 B'が空集合である か否かを判定し、空集合の場合には処理を終了する。基本ブロックの集合 B'が空集 合でない場合、ステップ S21で、 else節を生成する。ステップ S22で、 B'の各要素 B について、 iの昇順に以降の処理を繰り返すループを開始する。ステップ S23で、 B についての手続き制御プログラムを生成する。このステップ S23は入れ子構造となつ ており、 Bについてステップ S23を実行することは、この Bについて図 29全体のフロ 一チャートを実行することに相当する。なおステップ S22及び S23で生成された文が 、 else節の本文を構成することになる。
[0175] 以上の処理を実行することで、基本ブロック B以下の手続き制御プログラムが生成 される。図 30は、第 2の実施例の場合の手続き制御プログラムの構造を示す図であ
[0176] 図 30に示されるように、本発明の第 2の実施例の場合の制御プログラムは、変数の 宣言初期化部分 71、プレディケートへの入力データ待合わせ部分 72、プレディケ一 トの制御構造の生成部分 73、基本ブロックへの入力データ待ち合わせ部分 74、基 本ブロック内のスレッド起動と依存関係登録部分 75、及び手続き及びデータ転送の 待ち合わせ終了処理部分 76を含む。基本ブロックへの入力データ待ち合わせ部分 74では、手続きの入力データの転送指示、遠隔手続き呼び出しの起動指示、手続き の出力データの転送指示、及び依存関係の登録を行う。第 2の実施例では、手続き 間の待ち合わせは、データ転送の待ち合わせとなる。
[0177] 第 2の実施例では、各プロセッサに設けた個別のメモリである分散メモリを使用する 。この場合、手続きの入力データは、制御プロセッサから実行するプロセッサに転送 するものとし、出力データは遠隔プロセッサから制御プロセッサに転送されるものとす る。ただし、基本ブロック内については、手続きを実行するプロセッサ間で、直接デー タの転送を行うものとする。
[0178] 即ち、手続きの生成においては、入出力変数のためのデータ領域は予め用意し、 入力データは予め実行するプロセッサ上に転送されているものとする。また、実行結 果は、実行するプロセッサ上に格納し、制御プログラムによって必要とされるプロセッ サへ適宜その値を転送されるものとする。
[0179] 更に、頂点の部分プログラムが使用したり定義したりする変数であって、入力の変 数以外の変数を求め、それらの変数に対する宣言部を生成する。更に、部分プログ ラムを出力し、最後に、引数として受け取ったアドレスに対して、出力する変数の値を 代入する文を生成する。
[0180] 以下に、第 2の実施例により生成された手続きプログラム及び手続き制御プログラム につ!/、て、その構成及び動作を具体的な例を用いて説明する。
[0181] この例で用いる入力逐次プログラムの部分及び縮退プログラム依存グラフは、第 1 の実施例の場合と同じであり、図 25 (a)及び (b)にそれぞれ示すものである。図 25 (a )に示す入力逐次プログラムからプログラム依存グラフを生成し、頂点を結合して縮退 することにより、（b)に示す縮退プログラム依存グラフが生成される。頂点 V力 Vが
0 6 存在し、頂点 Vは縮退により文の集合となっている。
4
[0182] 図 31は、図 25の縮退プログラム依存グラフから第 2の実施例に従い生成される手 続き制御プログラムを示す図である。最初に変数の宣言があり、使用する変数 X, y, z , a, b, pを宣言する。第 2の実施例では分散メモリを想定しているので、各頂点 V及
0 び V乃至 Vに対応する手続き νθ及び v2乃至 v6のそれぞれについて、入力のデータ
2 6
転送指示及び入力のデータ転送に対する手続きの依存関係、並びに、実行結果の データ転送指示及び手続きに対する実行結果のデータ転送指示の依存関係が規定 される。例えば、頂点 Vに対応する手続き νθの場合、入力のデータ転送指示 81、手
0
続き νθの呼び出し指示 82、入力のデータ転送に手続き νθが依存するという依存関 係の指定 83、実行結果のデータ転送指示 84、及び手続き νθに実行結果のデータ 転送が依存するという依存関係の指定 85が規定されており、これらが登録されること になる。その後のディスパッチ命令により手続き νθが実行される。
[0183] データ転送指示及びその依存関係の指示が含まれて!/、ることを除!/、て、プログラム の制御構造は図 26の場合と同様である。従って、詳細な説明については省略する。
[0184] 図 32は、以上の手続き制御プログラムの動作を手続きプログラムの実行とともに示 す模式図である。図 32では、プロセッサ 0と手続き vO、 v2乃至 v6にそれぞれ対応す るプロセッサとが用いられる。また更に、データ転送ユニット DTU # 0乃至 DTU # 3 が用いられる。プロセッサ 0により手続き制御プログラムを実行する。
[0185] まずデータ転送ユニット DTU # 0により、データ aを手続き νθのプロセッサに転送す る。それに応じて、手続き νθの手続きプログラム 91が、対応するプロセッサにより実行 される。 while文の条件が成立すると、手続き νθの実行結果の転送が未完了である ので、 νθからのデータ転送を待ち合わせする。
[0186] 手続き νθからデータ aがプロセッサ 0に転送されると、それに応答して、手続き v2と v 4とにそれぞれ対応する手続きプログラム 92及び 94が、対応するプロセッサにより実 行される。この際、データ転送ユニット DTU # 1によりデータ z及び Xを転送する。また データ転送ユニット DTU # 2によりデータ pを転送する。
[0187] また登録された依存関係に基づいて、データ転送ユニット DTU # 1を介した手続き v2の出力データ Xの転送に応答して、手続き v3の手続きプログラム 93が対応するプ 口セッサにより実行される。同様に、登録された依存関係に基づいて、データ転送ュ ニット DTU # 3を介した手続き v4の出力データ yの転送に応答して、手続き v5の手 続きプログラム 95が対応するプロセッサにより実行される。
[0188] なお v2はループ繰越フロー依存に従!/、v5のデータ zを待ち合わせる必要がある。
従って、 while文の次のループに入った際に、手続き v5の手続きプログラム 95が実 行中の間は v2や v4の手続きは実行されずに、手続き v5の終了によるデータ zの転 送を待ち合わせることになる。
[0189] while文のループが終了すると、手続き v3の出力データ aの転送を待ち合わせてか ら、手続き v6の手続きプログラム 96が対応するプロセッサにより実行される。
[0190] この例において、手続き vlが第 1の基本ブロックに属し、手続き v2乃至 v5が第 2の 基本ブロックに属し、手続き v3が第 3の基本ブロックに属する。このように、異なる基 本ブロックをまたいでの手続き間の依存関係（例えば v3から νθへの依存関係）につ いては、先行手続きからのデータ転送待ち合わせを行ってから、後続手続きを実行 するようにする。また同一の基本ブロック内部で依存関係がある手続き v2乃至 v5の 実行については、依存関係待ち合わせ付き非同期遠隔手続呼び出しにより手続きを 実行する。このような構成とすることで、複雑な制御の依存関係が存在する基本プロ ック間については、手続きの実行を待ち合わせにより実現することで制御プログラム の生成を容易なものとし、実行順が固定である同一基本ブロック内については、依存 関係待ち合わせ付き非同期遠隔手続呼び出しにより無駄な待ち合わせ時間をなくす こと力 Sでさる。 [0191] 図 33は、本発明による並列化プログラム生成方法を実行する装置の構成を示す図 である。
[0192] 図 33に示されるように、本発明による並列化プログラム生成方法を実行する装置は 、例えばパーソナルコンピュータやエンジニアリングワークステーション等のコンビュ ータにより実現される。図 33の装置は、コンピュータ 510と、コンピュータ 510に接続 されるディスプレイ装置 520、通信装置 523、及び入力装置よりなる。入力装置は、 例えばキーボード 521及びマウス 522を含む。コンピュータ 510は、 CPU511 , RA M512、 ROM513、ハードディスク等の二次記憶装置 514、可換媒体記憶装置 515 、及びインターフェース 516を含む。
[0193] キーボード 521及びマウス 522は、ユーザとのインターフェースを提供するものであ り、コンピュータ 510を操作するための各種コマンドや要求されたデータに対するュ 一ザ応答等が入力される。ディスプレイ装置 520は、コンピュータ 510で処理された 結果等を表示すると共に、コンピュータ 510を操作する際にユーザとの対話を可能に するために様々なデータ表示を行う。通信装置 523は、遠隔地との通信を行なうため のものであり、例えばモデムやネットワークインターフェース等よりなる。
[0194] 本発明による並列化プログラム生成方法は、コンピュータ 510が実行可能なコンビ ユータブログラムとして提供される。このコンピュータプログラムは、可換媒体記憶装 置 515に装着可能な記憶媒体 Mに記憶されており、記憶媒体 Mから可換媒体記憶 装置 515を介して、 RAM512或いは二次記憶装置 514にロードされる。或いは、こ のコンピュータプログラムは、遠隔地にある記憶媒体（図示せず）に記憶されており、 この記憶媒体から通信装置 523及びインターフェース 516を介して、 RAM512或い は二次記憶装置 514にロードされる。
[0195] キーボード 521及び/又はマウス 522を介してユーザからプログラム実行指示があ ると、 CPU511は、記憶媒体 M、遠隔地記憶媒体、或いは二次記憶装置 514からプ ログラムを RAM512にロードする。 CPU511は、 RAM512の空き記憶空間をワーク エリアとして使用して、 RAM512にロードされたプログラムを実行し、適宜ユーザと対 話しながら処理を進める。なお ROM513は、コンピュータ 510の基本動作を制御す るための制御プログラムが格納されて!/、る。 [0196] 上記コンピュータプログラム（並列化プログラム生成プログラム即ち並列化プロダラ ム生成コンパイラ）を実行することにより、コンピュータ 510が、上記各実施例で説明さ れたように並列化プログラム生成方法を実行する。
[0197] 以上、本発明を実施例に基づいて説明したが、本発明は上記実施例に限定される ものではなぐ特許請求の範囲に記載の範囲内で様々な変形が可能である。
[0198] 本国際出願は 2006年 9月 29日に出願した日本国特許出願 2006— 269632号に 基づく優先権を主張するものであり、 2006— 269632号の全内容を本国際出願に 援用する。

Claims

請求の範囲
[1] 逐次プログラムを入力として、該逐次プログラムを構成する各文を頂点として有する とともに、文と文の間の関係を該頂点間の辺として有するプログラム依存グラフを生成 し、
該プログラム依存グラフの該頂点同士を融合することにより該頂点の数を減少させ た縮退プログラム依存グラフを生成し、
該縮退プログラム依存グラフの頂点の実行順序を計算し、
該実行順序を与えられた該複数の頂点のうちで分岐及び合流の何れも含まずに順 番に実行される頂点列を基本ブロックとして纏め、
該縮退プログラム依存グラフの頂点の各々に相当する手続きを生成し、 該基本ブロック間をまたいでの依存関係がある手続きについては先行手続きを待 ち合わせる命令の後に後続手続きを実行する命令を配置し、同一の基本ブロック内 部で依存関係がある手続きについては先行手続きに対する後続手続きの依存関係 を登録する命令を生成するようにして、該手続きの実行を制御する手続き制御プログ ラムを生成する
各段階を含むことを特徴とする並列化プログラム生成方法。
[2] 該手続き制御プログラムを生成する段階は、プロセッサに共通の共有メモリへの値 の書き込み及び参照により該手続き間のデータの転送を実現し、該基本ブロック間を またいでの依存関係がある手続きについては先行手続きの終了を待ち合わせてから 後続手続きを実行するように該手続き制御プログラムを生成することを特徴とする請 求項 1記載の並列化プログラム生成方法。
[3] 該手続き制御プログラムを生成する段階は、プロセッサ毎に設けた分散メモリへの 値の書き込み及び参照により該手続き間のデータの転送を実現し、該基本ブロック 間をまたいでの依存関係がある手続きについては先行手続きからのデータ転送を待 ち合わせてから後続手続きを実行するように該手続き制御プログラムを生成すること を特徴とする請求項 1記載の並列化プログラム生成方法。
[4] 該手続き制御プログラムを生成する段階は、入力データのデータ転送に対する手 続きの依存関係を登録する命令及び手続きに対する出力データのデータ転送の依 存関係を登録する命令を生成することを特徴とする請求項 3記載の並列化プログラム 生成方法。
[5] 該実行順序を計算する段階において、該縮退プログラム依存グラフを静的単一代 入形式に変換する段階を含むことを特徴とする請求項 2記載の並列化プログラム生 成方法。
[6] 逐次プログラムと並列化プログラム生成プログラムとを格納するメモリと、
該メモリに格納された該並列化プログラム生成プログラムを実行することで該メモリ に格納された該逐次プログラムから並列化プログラムを生成する演算処理ユニットを 含み、該演算処理ユニットは、該並列化プログラム生成プログラムを実行することによ り、
該逐次プログラムを構成する各文を頂点として有するとともに、文と文の間の関係を 該頂点間の辺として有するプログラム依存グラフを生成し、
該プログラム依存グラフの該頂点同士を融合することにより該頂点の数を減少させ た縮退プログラム依存グラフを生成し、
該縮退プログラム依存グラフの頂点の実行順序を計算し、
該実行順序を与えられた該複数の頂点のうちで分岐及び合流の何れも含まずに順 番に実行される頂点列を基本ブロックとして纏め、
該縮退プログラム依存グラフの頂点の各々に相当する手続きを生成し、 該基本ブロック間をまたいでの依存関係がある手続きについては先行手続きを待 ち合わせる命令の後に後続手続きを実行する命令を配置し、同一の基本ブロック内 部で依存関係がある手続きについては先行手続きに対する後続手続きの依存関係 を登録する命令を生成するようにして、該手続きの実行を制御する手続き制御プログ ラムを生成する
ことを特徴とする並列化プログラム生成装置。
[7] 該演算処理ユニットは、プロセッサに共通の共有メモリへの値の書き込み及び参照 により該手続き間のデータの転送を実現し、該基本ブロック間をまたいでの依存関係 がある手続きについては先行手続きの終了を待ち合わせてから後続手続きを実行す るように該手続き制御プログラムを生成することを特徴とする請求項 6記載の並列化 プログラム生成装置。
[8] 該演算処理ユニットは、プロセッサ毎に設けた分散メモリへの値の書き込み及び参 照により該手続き間のデータの転送を実現し、該基本ブロック間をまたいでの依存関 係がある手続きについては先行手続きからのデータ転送を待ち合わせてから後続手 続きを実行するように該手続き制御プログラムを生成することを特徴とする請求項 6記 載の並列化プログラム生成装置。
[9] 該演算処理ユニットは、入力データのデータ転送に対する手続きの依存関係を登 録する命令及び手続きに対する出力データのデータ転送の依存関係を登録する命 令を生成することを特徴とする請求項 8記載の並列化プログラム生成装置。
[10] 逐次プログラムを入力として、該逐次プログラムを構成する各文を頂点として有する とともに、文と文の間の関係を該頂点間の辺として有するプログラム依存グラフを生成 し、
該プログラム依存グラフの該頂点同士を融合することにより該頂点の数を減少させ た縮退プログラム依存グラフを生成し、
該縮退プログラム依存グラフの頂点の実行順序を計算し、
該実行順序を与えられた該複数の頂点のうちで分岐及び合流の何れも含まない頂 点列を基本ブロックとして纏め、
該縮退プログラム依存グラフの頂点の各々に相当する手続きを生成し、 該基本ブロック間をまたいでの依存関係がある手続きについては先行手続きを待 ち合わせる命令の後に後続手続きを実行する命令を配置し、同一の基本ブロック内 部で依存関係がある手続きについては先行手続きに対する後続手続きの依存関係 を登録する命令を生成するようにして、該手続きの実行を制御する手続き制御プログ ラムを生成する
各段階を計算機に実行させるコードを含むことを特徴とする並列化プログラム生成プ ログラム。
PCT/JP2007/067310 2006-09-29 2007-09-05 Procédé de création de programme par parallélisation, dispositif de création de programme par parallélisation, et programme de création de programme par parallélisation WO2008041442A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
JP2006-269632 2006-09-29
JP2006269632A JP4946323B2 (ja) 2006-09-29 2006-09-29 並列化プログラム生成方法、並列化プログラム生成装置、及び並列化プログラム生成プログラム

Publications (1)

Publication Number Publication Date
WO2008041442A1 true WO2008041442A1 (fr) 2008-04-10

Family

ID=39268306

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/JP2007/067310 WO2008041442A1 (fr) 2006-09-29 2007-09-05 Procédé de création de programme par parallélisation, dispositif de création de programme par parallélisation, et programme de création de programme par parallélisation

Country Status (2)

Country Link
JP (1) JP4946323B2 (ja)
WO (1) WO2008041442A1 (ja)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2010211731A (ja) * 2009-03-12 2010-09-24 Fujitsu Ltd 並列処理支援プログラム、並列処理支援装置および並列処理支援方法
EP3343351A1 (en) * 2016-12-28 2018-07-04 Waseda University Parallel program generating method and parallelization compiling apparatus

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2008120367A1 (ja) * 2007-03-29 2008-10-09 Fujitsu Limited 並列化プログラム生成方法、並列化プログラム生成装置、及び並列化プログラム生成プログラム
CN112559054B (zh) * 2020-12-22 2022-02-01 上海壁仞智能科技有限公司 用于同步指令的方法和计算系统

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2005258920A (ja) * 2004-03-12 2005-09-22 Fujitsu Ltd マルチスレッド実行方法、マルチスレッド実行プログラム、およびマルチスレッド実行装置
JP2006018447A (ja) * 2004-06-30 2006-01-19 Nec Corp プログラム並列化装置及びその方法並びにプログラム

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2005258920A (ja) * 2004-03-12 2005-09-22 Fujitsu Ltd マルチスレッド実行方法、マルチスレッド実行プログラム、およびマルチスレッド実行装置
JP2006018447A (ja) * 2004-06-30 2006-01-19 Nec Corp プログラム並列化装置及びその方法並びにプログラム

Non-Patent Citations (4)

* Cited by examiner, † Cited by third party
Title
HASHIMOTO T. ET AL.: "Task Scheduling o Mochiita Heiretsu Program Seisei ni okeru Task Ryudo no Chosei to Sono Hyoka (Task Granularity Adjustment to Generate a Parallel Program with Task Scheduling)", INFORMATION PROCESSING SOCIETY OF JAPAN KENKYU HOKOKU, vol. 2000, no. 5, 17 January 2000 (2000-01-17), pages 17 - 24, XP003022160 *
HONDA H. ET AL.: "OSCAR-jo deno Fortran Program Kihon Block no Heiretsu Shori Shuho (Parallel Processing Scheme of a Basic Block in a Fortran Program on OSCAR)", THE TRANSACTIONS OF THE INSTITUTE OF ELECTROS, INFORMATION AND COMMUNICATION ENGINEERS, vol. J73-D-I, no. 9, 25 September 1990 (1990-09-25), pages 756 - 766, XP003022159 *
KASAHARA H. ET AL.: "PARALLEL PROCESSING OF NEAR FINE GRAIN TASKS USING STATIC SCHEDULING ON OSCAR", PROCEEDINGS OF THE 1990 ACM/IEEE CONFERENCE ON SUPERCOMPUTING, 1990, pages 856 - 864, XP010020006 *
KOBAYASHI T. ET AL.: "Path no Jikko Hindo o Koryo shite Multi Thread Code Seisei Shuho no Kento (A Multithreaded Code Generation Technique Based on the Execution Frequency of Paths)", IEICE TECHNICAL REPORT, vol. 106, no. 199, 26 July 2006 (2006-07-26), pages 7 - 12, XP003022161 *

Cited By (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2010211731A (ja) * 2009-03-12 2010-09-24 Fujitsu Ltd 並列処理支援プログラム、並列処理支援装置および並列処理支援方法
EP3343351A1 (en) * 2016-12-28 2018-07-04 Waseda University Parallel program generating method and parallelization compiling apparatus
US10698670B2 (en) 2016-12-28 2020-06-30 Waseda University Parallel program generating method and parallelization compiling apparatus

Also Published As

Publication number Publication date
JP2008090541A (ja) 2008-04-17
JP4946323B2 (ja) 2012-06-06

Similar Documents

Publication Publication Date Title
JP4962564B2 (ja) 並列化プログラム生成方法、並列化プログラム生成装置、及び並列化プログラム生成プログラム
JP7090778B2 (ja) 影響分析
US10672156B2 (en) Systems and methods for processing computational workflows
Aiken et al. Perfect pipelining: A new loop parallelization technique
JP3311462B2 (ja) コンパイル処理装置
US8201171B2 (en) Adjacent data parallel and streaming operator fusion
JP2002116916A (ja) プログラムの最適化方法及びこれを用いたコンパイラ
US20090217272A1 (en) Method and Computer Program Product for Batch Processing
JP2004302706A (ja) プログラム並列化装置，プログラム並列化方法およびプログラム並列化プログラム
JP2009217405A (ja) ジョブネットワーク自動生成方式及びプログラム
Buck et al. The token flow model
JP2001166949A (ja) シンボリック実行を用いてソースコードをコンパイルするための方法及び装置
JP5083204B2 (ja) 並列化プログラム生成プログラム、並列化プログラム生成装置、及び並列化プログラム生成方法
US8782514B1 (en) Parallel XML parsing using meta-DFAs
Zhang et al. A cylinder computation model for many-core parallel computing
WO2008041442A1 (fr) Procédé de création de programme par parallélisation, dispositif de création de programme par parallélisation, et programme de création de programme par parallélisation
CN112114817A (zh) 基于cobol语言的数据字典字段信息获取方法及装置
JP5315703B2 (ja) 並列化プログラム生成方法、並列化プログラム生成プログラム、及び並列化プログラム生成装置
CN101794215B (zh) 一种汇编执行复杂任务的方法和装置
WO2011090032A1 (ja) 並列処理プログラム生成方法、並列処理プログラム生成プログラム、及び並列処理プログラム生成装置
Su et al. Formally verifying data and control with weak reachability invariants
Ramamoorthy et al. Compilation techniques for recognition of parallel processable tasks in arithmetic expressions
JP5273576B2 (ja) ジョブネットワーク自動生成方式及びプログラム
CN112825031B (zh) 基于json格式的流程描述方法及装置
Herzig et al. Towards an Approach for Orchestrating Design Space Exploration Problems to Fix Multi-Paradigm Inconsistencies.

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 07806753

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 07806753

Country of ref document: EP

Kind code of ref document: A1