JP3364952B2 - Compiler device, information processing system, object code generation method, and information processing method - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention improves the processing speed by distributing a processing procedure in a source code to another processor in a program written in a high-level language on the assumption of execution by a multiprocessor. Regarding technology.

[0002]

2. Description of the Related Art As a method for improving the processing speed in executing a certain target program, there is a method in which a plurality of processors can be executed in parallel by using a plurality of processors. The conventional invention in this field is devised mainly as a large-scale computer to which a vector processor is added as an execution environment. Many of the inventions have been made for the purpose of improving the execution processing speed of the compilation result of a high-level language which has been widely used (for example, JP-A-62-34275, "Vectorizing Compiler").

When the object program is divided into processing units and is executed by a plurality of processors, in order to improve the processing speed, a means for arbitrating access to variables shared among the processing units is provided. Processing time becomes a problem. This is because the execution units of the programs allocated in the memory spaces of multiple processors are allocated to the work area of the own program for local variables.
This is because the shared variable is often designed to be placed in the shared memory area.

Further, in recent years, the tendency of downsizing of processing systems has become stronger, and the method of the prior art is often used in a multi-microprocessor system. A parallel processing system using a plurality of microprocessors is expected to obtain a high processing speed while being inexpensive in structure.

Generally, there are about two basic modes for constructing a processing system including a plurality of microprocessors. A configuration in which one or more shared memories 3 are arranged for a plurality of microprocessors 1 as shown in FIG. 15a and a plurality of microprocessors 1 as shown in FIG.
The communication control means 4 is used to connect to the communication path 5. In either configuration, the microprocessor 1
The local memory 2 is usually used in order to maintain the processing speed of.

According to the conventional invention, when there is a variable shared between processing units of a program, in a tightly coupled multi-microprocessor system as shown in FIG. 15a, the memory required for storing the shared variable is the shared memory. Often placed at 3. In this case, exclusive control is performed for arbitrating access to the shared variable. On the other hand, FIG.
In a coarsely coupled multi-microprocessor system like b, the shared variable between processing units must be placed in the local memory 2 of the microprocessor in which the processing unit in which this shared variable is declared is executed. In this case, access arbitration for the shared variable is realized by communication performed using the communication path 5. As the communication path 5, a configuration using a FIFO, which is an ordered memory configured to be able to take out the first-in first-out data first, or a network is used.

Therefore, in the system shown in FIG. 15b, once access arbitration to the shared variable is required, the microprocessor 1 requests execution of the communication processing program using the communication control means 4 and the communication path 5. This is a large overhead when viewed from the target program being executed.

Also in the system of FIG. 15a, the processing time of exclusive control cannot be ignored. In this case, access to the shared variable is performed with contention among a plurality of processors through the bus connected to the shared memory.
Due to the mechanism of exclusive control, if another execution unit attempts to access the same shared variable (or the same memory management unit that contains the shared variable) while this execution unit is accessing this shared variable, this execution unit Processing is put on hold. Therefore, if the number of shared variables is large and access arbitration is performed very frequently, it is inconvenient for improving the processing speed.

In order to eliminate this problem, a method has been devised to reduce unnecessary shared variables between processing units. That is, there is a preprocessing program (preprocessor) for a translation processing system that removes unnecessarily declared shared variables from a source code manually written using a high-level language such as FORTRAN.

As a publicly known example of this method, Japanese Patent Laid-Open No.
There is No. 188529 “Intra-task shared variable detection processing method”. However, the method of removing the originally unnecessarily declared shared variable from the source code by the preprocessor and generating a new source code cannot remove the shared variable existing in the algorithm from the stage when the program was designed. However, it does not reduce the frequency of access arbitration to shared variables.

Among the variables that appear in the actually described source code, shared variables are a plurality of execution units (for example, FORT
RAN SUBROUTINE etc.) is used. In a conventional language for sequential processing, among shared variables, when attention is paid only to a certain execution unit, there are variables that can be referred to. For this execution unit, a variable that is referred to is equivalent to a case where the value of a constant is referred to in its local area. Moreover, even if it is an array variable, if the value of the subscript is constant in a certain series of repeated operations, one element of the array is a single variable in the local area inside this repeated operation. Is equivalent to

In the above case, even a shared variable can be treated as a local variable or a local constant depending on the usage. Focusing on this point, as an invention made with the object of generating an object code having a high execution efficiency suitable for a parallel system from a source program coded for a conventional single processor, Japanese Patent Laid-Open No. 132325/1990 “Compile”. There is a way.

According to the present invention, so-called shared variables used in a plurality of execution units are classified into several types according to their usage conditions, and variables or array elements whose values do not change within a certain execution unit are classified. I'm trying to put them in the local memory of every processor that may reference them. As a result, the reference from the variable arranged in the local memory does not require the exclusive control for access arbitration, which has the effect of improving the processing speed at the time of execution.

However, the present invention is mainly intended to extract parallelism such as array operation in a loop described in a high-level language such as FORTRAN to improve the execution speed. As is clear from that purpose, it is used to perform automatic parallelization processing of a conventional program coded for a single processor, so it is described in a language specification that allows description of parallel processing (hereinafter referred to as parallel processing language). There was a problem that the operation guarantee could not be obtained in the created program.

For existing programming languages, there is a processing system in which the language specification is extended to be a parallel processing language. Here, for the sake of simplicity, a language specification in which two statements for parallel processing are extended to the language Pascal will be taken up and explained. The extended statements are cobegin and coend, which indicate the start and end of blocks to be executed in parallel, respectively. I.e. co
The description between begin and coend has the meaning of being executed in parallel.

FIG. 16 is an explanatory diagram showing an example of a source code including a loop process which cannot guarantee the operation by the conventional method. The source code 407 is written in the extended language specification described above. Here, 400 is a program having two procedures 401 and 402. In the program 400, the integer type variable AA is a global variable and is used in both the procedures 401 and 402. Since the description contents from the statement 403 to the statement 404 are executed in parallel, the procedures 401 and 402 are executed at the same time, and when executed in a multiprocessor system using two or more processors, the processing distribution is If done,
Execution code is placed in the local memory of different processors and executed.

As a result of the syntactic analysis, it can be determined that the global variable AA can only be read (referenced) in the procedure 401. Therefore, according to the conventional method, the global variable A
A is used by copying the value at the start of processing (in this case, the value 1 immediately after the sentence 403) as the value of the variable AA in the local memory of the processor that executes the procedure 401.
On the other hand, in the procedure 402, the processing result of the rectangle 406 is judged by the subsequent condition judgment sentence, and the value of the variable AA is substituted. However, since this value has no means for updating the value of the variable AA in the local memory of the procedure 401 that is already being executed, the procedure 401 will repeat the processing indicated by the rectangle 405 forever.

This is an operation which is obviously different from the intention at the time of designing the program, and shows that the conventional method cannot guarantee the operation of the program written in such a parallel processing language.

[0019]

In a parallel processing system composed of a plurality of processors, the value of a global variable is individually extracted in a technique of extracting a part that can be executed in parallel from a given source code and parallelizing it. The method of arranging the memory in the local memory of the processor has the effect of reducing the processing time consumed for arbitration of the memory and improving the execution speed of the program.

However, as is apparent from the above, when the global variables are distributed by the conventional method to the source code written in the parallel processing language, there is a problem that the normal operation cannot be guaranteed.

The present invention was devised by focusing on the problems of such a conventional method. The purpose is to copy the source code written in the parallel processing language into the local area of the global variable and obtain the processing speed. It is to realize a guaranteed parallel processing system.

[0022]

According to a first aspect of the compiler of the present invention
La apparatus, variable defined in the source code (source program) is, along with indicating whether used within which processing unit in a plurality of processing units, the use, a variable indicating whether or references the variable assignment and parsing means for generating a reference table, based on the generated variable reference table,
A table creating means for creating a shared variable management table for designating a variable area to be referred to for each processing unit, and a temporary file containing an execution code for independently allocating an object code at execution time to a plurality of processors for each processing unit are generated. and <br/> code generating means for the variables the designated in shared variable management table, the copied to the local memory of the processor all execution units that references this variable is placed 1
And the second execution code for performing access arbitration when rewriting the value of the variable specified in the shared variable management table copied to each processor local memory.
A runtime library that includes a de, a temporary and files generated by the code generating means, said reading and runtime library, as inputs, in that it comprises a linker that generates as output an object code executable, a
Use as a summary. The second compiler apparatus of the present invention is a parallel processing unit.
Source code written in a language specification that can describe science
Compiler device for generating object code from code
However, a plurality of processing units included in the source code are included.
The first processing unit includes a second processing unit, and
When the second processing unit is a target of parallel processing,
Among the variables in the first processing unit, the second processing
And a second processing unit that can be accessed from the physical processing unit.
For a specific variable whose access from
Then, when the parallel processing of the second processing unit is executed,
The memory in which the process at the time of parallel execution of the second processing unit exists
Copy the specific variable as a copy variable to the memory area.
A first code generating means for generating a first execution code, before
When the processing of the first processing unit is executed, the first
There is access to the specific variable from the processing unit, and the access
Is a copy of the specific variable when the set is a value substitution.
Wait for access from the process to the copied variable
And replace the value assigned to the specific variable with the pre-copy variable.
Then wait for access to the copied variable.
Second code generation means for generating second execution code
And, from the source code to the first and second
To generate object code that contains the execution code
Use as a summary. The information processing system of the present invention is the first memo.
In the first process and second memory area existing in the memory area
It is possible to execute the existing second process in parallel
An information processing system, wherein the information is stored in the first memory area.
Variable that exists and is accessed by the first process
Of these, it can be accessed from the second process as well.
In both cases, the access from the second process is a value reference.
The specific variable which is only the second variable in the second memory
A variable copy means for copying as a copy variable to the area;
Access to the specific variable by one process,
If the access is substitution of a value,
Is the second process for the copy variable that is a copy?
The value assigned to the specific variable by waiting for access from
To the pre-copy variable and then
And a variable assigning means for releasing the waiting of the process.
Use as a summary. First Object Code Generation Method of the Present Invention
Method to generate object code from source code
An object code generation method for: (a) defined in the source code (source program)
Variable is used in which processing unit among multiple processing units.
Is used, and this use
Generating a variable reference table indicating input or reference; and (b) processing based on the generated variable reference table.
Shared variable management that specifies the variable area to be referenced for each physical unit
The process of creating a table, and (c) multiple execution object code for each processing unit.
Temporary code containing executable code to be placed independently on
And (d) a variable specified in the shared variable management table.
A number is placed for all run units that reference this variable.
First executable code to be copied to the local memory of the processor
And the variables specified in the shared variable management table
Rewrite the value copied to each processor's local memory of
Second execution code for performing access arbitration at the time of
A step of preparing a runtime library, (e) the generated temporary file, and the prepared
Run-time library and can read and execute as input
And a step of generating a unique object code.
Is the gist. Second object code generation of the present invention
The method is described in the language specification that can describe parallel processing.
Object code from generated source code
An object code generation method for: (a) a plurality of processing units included in the source code
Of which the first processing unit includes the second processing unit, and
When the second processing unit is a target of parallel processing,
Of the variables in the first processing unit, the second processing unit
From the second processing unit
For specific variables whose only access is to reference the value,
When the parallel processing of the second processing unit is executed, the second processing unit
Memory area of the process during parallel execution of each processing unit
In the area, the first actual copy of the specific variable as a copy variable.
A step of generating a line code, and (b) before the processing of the first processing unit is executed,
There is access to the specific variable from the first processing unit,
If the access is substitution of a value, the
Access from the process to the copied variable that is a copy
Process, and the value assigned to the specific variable is copied.
Assign to a variable, and then wait for access to the copied variable.
And a step of generating a second execution code for canceling the machine.
From the source code, the first and second execution code
The main idea is to generate an object code that includes code
It The information processing method of the present invention exists in the first memory area.
The first process and the second existing in the second memory area
An information processing method for executing the processes of (1) in parallel, wherein : (a) the first program exists in the first memory area;
Of the variables accessed by the process
It can be accessed from the
Access to specific variables whose value is only referenced by
The specified variable as a copy variable in the second memory area.
Copying, and (b) accessing the specific variable by the first process.
If the access is a value assignment,
The second for the copied variable that is a copy of the specific variable.
Waits for access from the process
Assign the assigned value to the pre-copy variable and then copy
Releasing the waiting for access to the variable.
And are the gist.

[0023]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 is a block diagram of a high-level language compiler suitable as an embodiment of the present invention. The compiler of this embodiment generates object code that can be executed in parallel in a multi-microprocessor system from source code. The programming language specification handled in this embodiment is the language Pasc.
It is a specification in which two words of cobegin and coend are extended with respect to al. Here, cobegin and coend are the start statement and end statement of the block that allows parallel execution, respectively. The following explanation
Follow the steps below.

1. Compile Source Program 1-1. Extraction of block structure 1-2. Variable processing 1-3. Purpose of using variable class structure 2. Operation of table creating means 2-1. Outline of table creating means 108 2-2. 2. Creation of block execution management table Method of Generating Object Code for Accessing Global Variable 3-1. Exclusive control method 3-2. Process of exclusive control program 113 3-3. Process of parallelization program 112 3-4. Method of generating object code 4. Method of executing processing unit in local area of other processor 4-1. When non-local variable is reference only 4-2. When substitution to a non-local variable is performed 1. Compilation of Source Program The processing flow of the processing system of this embodiment from the source program to the generation of an executable object code will be described below with reference to FIG. The main components of this embodiment are a compiler 102, a runtime library 111, and a linker 11.
It is 4.

1-1. The compiler 102 that has read the block structure extraction source code 101
The lexical analysis means 103 performs lexical analysis. Here, by sequentially reading the character string appearing in the source code 101, the procedure, variable, constant, character constant,
Extracts data type definitions, names and values such as character strings, operators, special symbols, and reserved words for programming languages.
The read result is recorded in the work area of the compiler 102.

Next, the syntax analysis unit 104 is executed by inputting the data of the read result of the lexical analysis unit 103. In the present embodiment, for simplicity of explanation, in the grammar of the language Pascal, a subprogram started by a procedure statement or a function statement is called a block, and an assignment statement and if, while, r
A statement that starts with a departure symbol such as epeat or for is called a statement. The sequence of "statements" enclosed by begin ... end is usually called a "compound statement", but this is also called a statement here. The parsing code of this embodiment performs well-known descending analysis because the Pascal grammar has a property called LL (1).

Normally, in the parsing process, names other than reserved words appearing in the source program are constant names, variable names,
In many cases, the procedure name, function name, and variable type name are registered in the name table without distinction, and the object type is recorded together with the name in this table. This is a rational method for detecting the inconvenience of name overloading (the function name and the constant name are the same). Also in this embodiment, the management of the name (identifier) in the syntax analysis unit 104 is performed by this method.

Since parallel description is allowed in the language specification in this embodiment, the portion to be executed in parallel is required to be explicitly described in the source code. In other words, for the processing blocks not included in the range enclosed by cobegin and coend, the execution code in the single processor environment is generated. From the standpoints of the syntax analysis unit 104 and the code generation unit 107, the execution code of the block other than the processing unit for which parallel execution is designated by cobegin and coend should generate the same code as in the normal compilation process. become.

Therefore, the syntax analysis means 104 of the present embodiment.
The first difference from the conventional method is the following processing. That is, in order to reduce the time required for the compilation process as much as possible, the syntax analysis unit 104 first scans the source code, and the presence of cobegin and coend and cobegin and c exist.
The name of the function or procedure called in the range of oend,
Record in the parallel execution procedure name table 116. Every time a block is detected in the actual parsing process that follows, it is checked whether the block (procedure or function) matches the name recorded in the parallel execution procedure name table 116, and only when it matches. , Perform the processing steps required for parallel execution.

The second difference of the syntax analysis means 104 of this embodiment from the conventional method is that the variable effective range detection means 1 is used.
05 and the processing result of the variable substitution detection means 106 are used for the table creation means 108. This process will be described below with reference to the flowchart of FIG. FIG. 6 is an explanatory diagram of an example of source code used to supplement the flow of processing. In languages such as Pascal, which has a block structure, variables are scoped within the declared block. For this reason,
To determine and refer to the value of a variable, the depth of the block and the information indicating the order of appearance of the blocks (when the depths of the blocks are the same) are required. The syntactic analysis unit 104 proceeds with the processing by regarding the program start level as block level = 0.

In the example of FIG. 6, the position of the main program of the program 601 is block level = 0. After that, the value of the block level is incremented by 1 every time the nested state of the block becomes one step deeper. Similarly, the block level value is decremented by 1 each time the nested structure is exited one step. The block declared in the main program statement has block level = 1. In the example of FIG. 6, the procedures p1 (602), p2 (60
4) and p3 (605) are regarded as block level = 1.

In order to distinguish variable declarations between different blocks at the same block level, the parsing means 1
04 further has a block number as information. The block numbers simply assign consecutive numbers to the individual blocks in the order they appear in the syntactic analysis. Regarding the example of the source program shown in FIG. 6, the relationship between the block structures of individual procedures and functions and the block numbers are shown in FIG. 7a.

When the start of a block is detected (S500), the syntactic analysis means 104 performs block level + 1 (S501), and then performs block number + 1 (S50).
2). A variable declaration (if there is a variable to be used) follows the reserved word of the block definition, so that an in-block variable table shown in 802 of FIG. 8 is created (S503). further,
A new data field of the variable table designation structure 801 as described below is created, and a pointer to the created in-block variable table is recorded in the table entry 811 that is the element.

The variable table designation structure 801 includes a block level 810, a table entry 811, and a chain address 81.
A data structure consisting of three elements of 2 is made one element,
An array of its elements. This data structure is created in each block to maintain the relationship of non-local variables. In the following step S504, an element whose block level value is one smaller than its own block level value is found, starting from the current element of the variable table designation structure 801 which is an array structure and tracing back one element at a time. , Replaces the contents of the chain address 812 of its own element with the index of the array of elements found here. As a result, 81
A chain between elements as shown in 3 is generated. Further, the process searches whether the block name (function name or procedure name) is recorded in the parallel execution procedure name table 116 (S505). Here, if the procedure or function is not the target of parallel execution, normal syntax analysis processing is performed. On the other hand,
If it is a procedure or function to be executed in parallel, the table creating means 108 is called, and then the process S50 is performed again.
After 1 is repeated, the whole parsing is continued recursively. On the other hand, even when the normal parsing process is started, when the start of the block is detected, the process returns to the process S500 and the process is repeated.

Chain address 8 of variable table designation structure 801
A supplementary description will be given to the processing S504 for generating the chain 813 from 12.

By this processing, each block takes out the element of the variable table specifying structure 801 of the block (parent block) of one small block level, and further, from the table entry 811 of the element, the in-block variable table 80.
A pointer to 2 can be obtained. Taking the example of the source program of FIG. 6, the state of this chain is shown in FIG. 7b. However, in order to make it easier to understand, the block number that is the same value as the array index is also shown. For example the function p313
Is at the position of block number 9, and its chain address points to the position of procedure p31 at block number 6.
The chained address of p31 is the procedure p3 of block number 5.
Shows the position of. Since the variables are accessed by following the chain of the variable table designating structure 801, it is possible to prevent erroneous reference between different block structures.

If the content of the judgment in the process S500 is other than the block start, other syntax processing is performed and the code generation means 107 is called. In the present embodiment, the syntax (S515) other than the handling of variables is the same as the conventional syntax processing, and therefore only variable processing will be described.

1-2. If a name (identifier) appears in the variable processing syntax (S506),
This name is the name of the variable, and the value 0 is assigned to the flag for detecting whether the variable is a local variable in the block (S507). After the current block level is temporarily saved (S508), the detected name is
It is inspected whether it exists in the block variable table created in S504 (S509). If it is in the variable table, since this variable is a variable in the block, a variable class that is a data structure to be referred to later by the table creating means 108 is created (S510). Next, it is determined whether the content of the syntax is an operation for assigning to this variable (S51
1) If yes, the rewritten information is added to the variable class (S512). On the other hand, if the determination is No, information only for reference is added to the variable class (S513).
The variable class information and the contents of the flag are passed to the table creating means 108, and the processing described later is performed. Then, the code generation means 107 is executed and the code of the compilation result is generated. After this, the block level value temporarily saved in S508 is restored (S514), and the process proceeds to the next syntax.

On the other hand, if the name of the object to be processed is not in the in-block variable table (S509), the value 1 is assigned to the flag for detecting whether it is a local variable (S516), and the block level is decremented by one. (S517).

Since the block level value has been changed, the block level value saved in step S508 is updated (S518). At this time, it is checked whether the value of the block level is smaller than 0 (S519). If the block level value is less than 0, it means that there is no variable name that matches the variable name being processed in the variable table, even when tracing back to the main program, and the retrieved name is an identifier other than the variable name. If so, the process (S520) is performed.

Otherwise, the variable declaration in the outer block is checked. First, as the value of the block level is decremented by one, the process traces the chain address 812 of the variable table designation structure 801 to the immediately preceding chain. Here, the pointer extracted from the table entry 811 is used to access the in-block variable table 802 at the block level, and the process S509 and subsequent steps are repeated again. However, since flag = 1, it is recorded that the variable is not a local variable in the block at the stage of creating the data structure of the variable class (S510), and this information is referred to the table creating means 108.

If the end of the block is detected (S521) among the processes of the syntax other than the variable, the value of the block level is decremented by 1 (S522), and the processes from S506 onward are repeated until the block level becomes <0. Be done. When the block level is <0, it indicates that the syntax analysis processing is completed up to the level of the main program, the normal termination of the program is checked, and the processing is terminated.

Of the processing shown in the flowchart of FIG. 5, the loop after the processing S509 for searching the in-block variable table 802 realizes the variable effective range detecting means 105 having the configuration of FIG. Further, the processes S511 to S513 implement the variable substitution detection means 106 having the configuration of FIG.

1-3. Purpose of Using Variable Class Structure The variable class structure is a data structure generated as a record of the access status of each variable, and has a structure 900 shown in FIG. That is, a flag 901 indicating whether the variable of interest is declared externally or internally to the block to be processed, the data structure 902 for specifying the variable, and the data structure 9 for specifying the access.
03. The variable designation data structure 902 further has a variable name, a block number in which the variable is declared, and a block level element. The content of the flag 901 is logical [true] when the variable is declared inside the block to be processed. At this time, the data structure 9 of the access specification is set.
03 is unnecessary. Access specification data structure 903
Has a block number of the block to which the variable is accessed (that is, the block currently being processed), a block level, and a flag that determines whether the operation for the variable involves rewriting or only referencing.

Needless to say, one variable may be accessed many times in the same block, and a plurality of variable class structures 900 can be generated for the same variable. Until the parsing in the block is completed, it is impossible to know whether the variable of interest is referred to or is accompanied by assignment. The solution to this is the two chained addresses described below.

First, the processing S509 of the syntax analysis unit 104.
There are four elements for each variable in the in-block variable table 802 generated in. They are variable name, variable type,
A chain address 803 and a chain address 804. Here, the initial values of the two chain addresses 803 and 804 are 0. These two chained addresses are a data structure that manages information on the access status of variables.

2. Operation of table creating means 2-1. Overview of table creating means 108 The table creating means 108 creates two types of tables related to parallel execution. The first table is a table that keeps a record of which processing block accesses each variable when paying attention to each variable, and is illustrated as an in-block variable table 802 in FIG. The second table has a structure opposite to the above, and is a table in which, when attention is paid to each processing block, which block the processing block accesses a variable declared in is recorded. The structure of this table is illustrated by the block execution management table 806 in FIG. The block management table 806 is an array whose elements are the data structure 815.

The purpose of creating the in-block variable table 802 is to provide a judgment condition for generating a code for performing exclusive control when a variable is accessed by another processing unit which is executed in parallel. . The data structure of the in-block variable table 802 is the same as that of the code generation means 107 of the compiler 102 for each case where variable substitution or reference occurs.
Referenced by the linker 114.

The purpose of creating the block execution management table 806 is to
This is to give a judgment condition when arranging a block for parallel processing in a local memory of another processor. This data is referenced by the linker 114. Therefore, processing blocks that are not the target of parallel execution are unnecessary and data is not generated.

As shown in the flow chart of FIG. 5, the table creating means 108 is called after the start of a block and is called in the process S505, and after the access to the variable is detected, the process S512, There are two types of calls when they are called after S513.

2-2. Creation of Block Execution Management Table The table creating means 108 performs the process according to the procedure of FIG. 11 when it is continuously called in step S505. A new element 815 of the block execution management table 806 is designated and the block number is recorded (S1001). Next, the chain of the variable table designation structure 801 is searched, and if there is a block located in the upper structure of its own block, the block number of that block is taken out (S1002), and the parallel execution procedure is performed using the value of the block number as a key. Search the name table 116 (S
1003). If there is a name (block number), it is possible to determine that the block of its upper structure is the target of parallel execution. At this time, the corresponding element 815 in the block execution management table 806 is extracted from the block number of the detected upper structure block, and the data structure 819 of the linked list starting from the data 814 is traced to the end of the chain. , The value of the index of the position occupied by the own block in the array 806 is recorded. As a result, a chain to the lower block is generated in the data 814 of the block of the upper structure (S1005).

Next, the offset value from the program start address of the start address of the current block calculated from the current processing state of the compiler is recorded in the data 807 (S1).
006). Subsequently, the argument list at the time of calling the procedure or function is analyzed, the stack depth consumed by passing the parameter is calculated, and the value is recorded in the data 809 (S1007).

On the other hand, when the parallel execution procedure name table 116 is searched and it is determined that the upper block is not the target of parallel execution, it is checked whether the block number is 1 and [False].
At the time of S, in order to further inspect the block of the upper structure, S
Repeat from 1002. On the other hand, block number = 1
In this case, even if the highest block (main program) is inspected, it can be determined that the own block does not depend on the block to be executed in parallel. In this case, since registration in the block execution management table 806 is unnecessary, the block number registered in the table is deleted and the process ends.

2-3. After the access to the creation variable of the block variable table is detected, the processes S512 and S5 are performed.
When it is called again after 13, the table creating means 1
08 performs the processing shown in the flowchart of FIG. 12 based on the value of each element of the variable class structure 900.

A flag 901 indicating whether it is declared externally or internally is checked, and if the variable to be accessed is a variable declared internally, the process is terminated (S1011). In other cases, the block number and the block level value are extracted from the variable-designated data structure 902 (S1012). Using this value as a key, the chain of the variable table designation structure 801 is searched, the value of the table entry in the case of matching is retrieved (S1013), the in-block variable table 802 is accessed, and the variable names in the table match. The field is taken out (S1014).

Here, in the variable class structure 900,
The data structure 903 designating access is referred to, and the value of the rewrite flag is checked (S1015). When this value is [true], the block number and the block level value of the access designation data structure 903 are extracted, and as a chain from the chain address 803 of the in-block variable table 802, the data structure 805 of FIG. A chain is generated (S1016). Next, using the block number as a key,
The corresponding element 815 of the block execution management table 806 is designated, and a chain from the chain address 817 is designated as 8 in FIG.
A data structure chain shown in 20 is generated (S101).
8). When the content of the determination S1015 is [false], a chain from the chain address 804 of the in-block variable table 802 is generated (S1017), and subsequently, a chain 820 from the chain address 818 of the block execution management table 806.
Is generated (S1019). When generating a chain, if an element having the same block number already exists in the chain, it is not necessary to add a new chain and the process is skipped.

As a result, in the chain address 803, the head address of the structure 805 in which the information of the block to be rewritten for this variable is recorded is recorded, and a plurality of blocks are held in the linked list. Further, the chain address 804 records the start address of the structure 805 in which the information of the block only referring to (reading) this variable is recorded, and thereafter, a plurality of blocks are held in the linked list.

Within one block, for the same variable,
Even if there are a plurality of references and substitutions, duplication is removed by the management of the chains 803 and 804, and the correct usage status can be grasped.

The data generated by the table creating means 108 is output to the file as the shared variable management table 110 when the syntax analysis process is completed until the end of the source code.

3. Method of Generating Object Code for Accessing Global Variable 3-1. Exclusive Control Method In this embodiment, execution units (for example, procedure blocks) of programs to be executed in parallel are transferred to the local memory of another processor and executed. (Of course, if the number of blocks to be executed in parallel is large and exceeds the number of available processors, multiple processing units may be executed in parallel on the local memory of a single processor.) At this time, different Whether or not there is a shared memory between the processors, exclusive access control is performed on variables for which access conflict occurs. The execution code of this exclusive control is
Supplied by the runtime library 111.

A semaphore was used for exclusive control in this embodiment. Semaphores require privileged machine language instructions that can perform tests and value rewrites in a series of operations, or memory accessible only in privileged mode. Here, the privileged memory S is used.

The operation on the semaphore is performed by a special two-group process. One is weight processing and the other is signal processing. In the wait process, if S> 0, S: = S-1 is executed, and if not, the process that called the wait is (temporarily stopped) suspended. The signal process restarts the previously suspended process if it is in the queue. If not, execute S: = S + 1.

In a multiprocessor system, particularly when there is no shared memory, it becomes a problem to arrange the privileged memory S in the memory space of a plurality of processors in order to realize the semaphore. In this embodiment, the states of variables to be accessed are divided into rules, and the arrangement of the memory S is determined according to each rule. For this purpose, the exclusive control program 113 is provided with the seven processing routines shown in FIG. 13b. Also, the parallelized program is shown in FIG.
The three processing routines listed in 1. were prepared. For the following description, the memory S used for the semaphore will be simply referred to as "semaphore S". 3-2. Processing of Exclusive Control Program 113 First, individual processing routines of the exclusive control program 113 will be described below. From the perspective of the processing processor, when the semaphore S exists in the local memory of another processor,
The weight and signal processing is performed via the communication path between the processors. This processing is performed by two processing routines of remote wait and remote signal. On the other hand, when the semaphore S is placed in its local memory, it uses local wait and local signal processing to access it. As a matter of course,
Local weights and local signals without communication can be executed much faster than remote processing. Further, the remote write process is used as a process for assigning a value to a variable arranged in the local memory of another processor. Similarly, remote read processing is used to read the value of a variable in the local memory of another processor. In addition, the local read processing is performed so that a processing unit placed in the local memory of another processor for parallel execution and executed by the other processor can refer to the value of the non-local variable copied to this local memory. To use.

3-3. Parallelization program 1 included in the processing runtime library 111 of the parallelization program 112
The process in 12 will be described. The variable / execution object copy processing 1101 is a pre-processing routine for arranging blocks to be executed in parallel in the local memory of another processor and executing them. In this embodiment, the minimum unit when the execution code of the target program is generated and executed is the process. A process consists of a process header containing process identifiers, execution management, and memory management information, an area for saving the current processor register status at the time of suspension, an object code area, and a stack area. It is a unit. The variable / execution object copy processing 1101 creates a process that executes the processing block of the specified procedure or function, and records the number of the processor on which this process depends on the work area at the time of execution.

The remote activation process 1102 extracts the processor number for managing the process generated by the variable / execution object copy process 1101 and enqueues the process execution request to the process request queue of this processor. This processing is used when the processing units to be executed in parallel are arranged in the local memory of another processor and then activated, and in the remote signal processing, when the suspended processing is restarted.

The suspend 1103 process suspends the process being executed on the local memory and causes a jump to the standby process.

3-4. Method of Generating Object Code Next, how the code generation means 107 generates an object code in the case of accessing a global variable will be described.

After the table creation processing 108 is called after S512 and S513 in the flowchart of FIG. 5, the code generation means 107 is subsequently executed. At this time, the data of the variable class structure 900 is referenced. Run-time library 1 if you are accessing non-local variables
An instruction word space for jumping to the exclusive control program 113 included in 11 is secured. A symbol indicating that it is necessary to link the code of the runtime library for exclusive control is recorded in the data string secured as the instruction word space. The processing result is output as a temporary file 109 from the code generation unit 107.

It is the processing of the linker 114 described below that embeds a jump instruction to the actual exclusive control program into this space and makes it an executable object code. When the linker 114 uses the temporary file 109 and the shared variable management table 110 as input files and detects a symbol in the temporary file 109 that requires a branch to the code of the runtime library 111, the linker 114 follows the specified content. Do the actual code generation. Linker 114
Is included in the exclusive control program 113 described above.
From the one processing routine, only the required processing routine is extracted and added to the object code at runtime. Further, when the linker 114 finds a place where a branch to these processing routines is designated in the object code of the target program created from the source code, it calculates the machine code of the branch code based on the actual address calculation of the relative address. The instruction is generated and the object code 115 is completed.

Linker 11 for access code of variable
4 is an exclusive control program according to the rules shown in the table of FIG.
Generate branch code for each process in the ram in the execution code
It The rules are as follows. Declared inside from my own perspective
If the specified procedure or function is subject to parallel execution,
The processing rule 401 is applied. In the example of FIG. 6, the procedure
Since p32 is the target of parallel execution, this rule is added to process p3.
Rules are applied. First, to the variable of interest in your block
On the other hand, if there is no access from the block that is executed in parallel
If so, normal code generation is performed (403). In own block
For the variable of interest inFrom blocks executed in parallelA
There are some habits,That accessIf it's just a reference,
SelfIn the above variable to be noted in the execution code in the block
ToNormal reference or assignment processIf you do
If the content is an assignment process, after performing the assignment process,Re
Mote weight, remote light, remote sig
Processing codes are generated in the order of null (404). Own block
For the variable of interest inFrom blocks that are executed in parallel
Is accessed, and that access is an assignmentIf
local・Weight, ordinary reference or assignment, local
Generate code in the order of signals (405). Next,
Min is a block that runs in parallel, or more inside
If it is a block of
Code generation is done. This is the procedure p3 in the example of FIG.
This is for accessing non-local variables from 2, p321, etc.

First, if the variable to be processed is not a non-local variable, normal code generation is performed (406). If the variable of interest for code generation is a non-local variable but only referenced, the code is generated in the order local wait, local read, local signal (407). On the other hand, if the variable of interest for code generation is a non-local variable and the assignment is performed at least once in the block, remote wait is performed first, and then remote write or remote write is performed. Codes are generated in the order of read and then remote signal (408).

If the shared variable is referenced only from the processing blocks that are executed in parallel, the partition 404,
Processing is performed with 407 combinations. Further, when there is an assignment to a non-local variable from the processing blocks that are executed in parallel, the processing by the combination of the sections 405 and 408 is performed. In the case of the partitions 403 and 406, even if the blocks are executed in parallel, the generated code is no different from the code generation in the case of the single processor system.

4. Method of executing processing unit in local area of other processor 4-1. When Non-Local Variable is Reference Only When a shared variable is referenced only from parallel processing blocks, the arrangement and execution of the object will be described with reference to FIG. 2 is 2
One processor is used, each local memory 20
1 illustrates a case in which the target program is loaded and executed on the device 1. The main program 203 is a single process, and the stack 204 in the process is used as its variable area.
To use. Some execution code 208 in the program is
This is a code for accessing the variable 207 taken in the stack. On the other hand, the execution unit 205 defined in the main program is an execution unit targeted for parallel execution.

In the execution code of the main program 203,
It contains code generated between the reserved words cobegin and coend. In order to activate a processing unit in a normal program, since the processing unit is a block such as a procedure or a function, a machine language instruction for calling a subroutine for this block is generated. On the other hand, a procedure and a function call at the time of parallel execution of this embodiment will be described with reference to FIG. Here, 1201 has shown the memory map of an execution object. First, the stack from the first argument to the Nth argument is stacked. Next, block execution management table 8
The index of 06 is put on the stack. Subsequently, the variable / execution object copy processing 1101 is called. The variable / execution object copy processing 1101 is read from the runtime library 111 and linked to the memory 201 as a part of the execution object of the program. This processing 1101 extracts the start position of the object of the block 205 that is executed in parallel from the offset 807 to the execution code according to the designation of the block execution management table 806. Next, the chain address 814 to the lower block
Sequentially, the data of the lower block in the block execution management table 806 is taken out, and the object of the sequential execution code is taken out. After tracing all the chains, these execution codes are transferred to the local memory 202 of another processor, and a new process 210 is created. Next, the contents of the arguments stacked on the stack of the process 203 are copied to the stack 211 in the process before calling the block 205. In this copy, the depth of the stack 809 in the block execution management table 806 is used to determine the depth of the stack to be copied. Processing 1 by this
The contents of the arguments passed up to 202 are also inherited to the stack 211 of the process 210. Further, the variable / execution object copy processing 1101 checks whether or not there is a chain 820 after the chain address 818. If there is a chain 820, the variables specified in the chain are variables that are only referenced by process 210. In the example of FIG. 2, the variable 207 is referenced by the processing block 205. Therefore,
Since the process 210, which is the substance of the parallel execution of the processing block 205, makes a reference, the processing 1101 makes a copy of the variable 207 in 213 on the memory 202. Furthermore, in order to arbitrate access to this variable, the local wait, local signal, and local read of the runtime library are loaded into 214 on the memory 202. In addition, the process 1101 places the semaphore 215 on the memory 202.

When referencing the value of the newly created variable 213 as a copy of the variable 207, the process 210 is shown in FIG.
407, local wait local read local signal is executed in this order. Therefore, the actual address of the variable 213 may be known by the local read, which is one process of the runtime library. For this reason, process 1101
Records the address of the variable 213 in the work area of the runtime libraries 214 and 209.

Next, as shown in FIG. 14, the remote start processing 11
02 is called. The remote start processing 1102 enqueues the execution request of the process 210 in the queue of the processor that manages this process. The above is the processing until the processing block 205 is remotely activated. When the execution is completed, the remotely activated block 210 rewrites the parallel execution flag of the main program work area by the completion signal. When the flags related to all the blocks in parallel execution are rewritten to the end state, the parallel execution ends, it is considered that the coend has been processed, and the subsequent processing is continued.

In the example of FIG. 2, the process 210 in parallel execution of the processing block 205 accesses the variable 207 of the block 203 (the main program is also a block), but is only for reference. As for the reference method, as already mentioned,
This is performed for 213 which is a copy of the variable 207. However, the block 203 substitutes the variable 207 in the execution code 208. From the specification of the parallel processing language of this embodiment, it is necessary that the change of the value of the variable 207 be reflected correctly in the process 210. Therefore, the execution code 208
Then, the code generation shown at 404 in FIG. 4 is performed. That is, after the substitution to the variable 207, the processing is called from the runtime library 209 in the order of remote wait remote write remote signal and executed. Here, since the address of the variable 213, which is a copy of the variable 207, is recorded in the work area of the runtime library 209, a match between the value of the variable 213 and the value of 207 can be guaranteed.

Further, as shown by 404 in FIG.
When the access to 07 is only a reference in the processing block 203, since the execution code 216 performs code generation of a quite normal variable reference without exclusive control, the access can be processed at extremely high speed. on the other hand,
Even in the execution code 212 inside the process 210 that refers to the copy 213 of the variable 207, exclusive control is performed by a local semaphore without communication. For this reason, the execution speed is comparable to the processing speed in the case of having a shared memory, despite the parallel processing with the communication paths separated. When the entire processing is viewed, the execution code 216 or the like does not require exclusive control, so the average processing time of variable access is
Rather, it can be said that it exceeds the case of using shared memory. Therefore, the processing speed can be improved even if the method of the present embodiment is applied to the processing system of the form of FIG. 15a having the shared memory as it is.

4-2. When Assignment to Non-Local Variable is Performed With reference to FIG. 3, the arrangement and execution of the object will be described for the case where assignment to a non-local variable is performed from a processing block that is executed in parallel.

In the state shown in FIG. 3, the processing block 301 declared inside the block 203 is the target of parallel execution,
It shows the case where it is executed on the local memory managed by another processor. Process 304 is block 301
Is an entity when executed on the memory 202. The variable 302 of the block 203 is arranged in the stack 204 of the block 203. At this time, process 30
Rewriting from 4 to the variable 302 is also performed. In this case, the semaphore 303 is arranged on the memory 201 where the execution code of the block 203 exists.

In accordance with the rules described above, the code for accessing the variable 302 from the block 203 uses the runtime library 306 to perform access with exclusive control. Similarly, from the process 304, the variable 302
The execution code 305 that accesses the file is accessed with exclusive control using the runtime library 307. At this time, the actual address of the variable 302 is held in the work area of the runtime libraries 306 and 307.

The processing relating to the case where a non-local variable is assigned from the processing blocks executed in parallel is equivalent to the conventional variable access method as described above.

In the present embodiment, the method described above can guarantee the operation even when a variable which is only read-referenced is assigned to the local memory for the source program written in the parallel processing language. it can.

When the reserved words cobegin ... coend are detected in the source code in the compilation of the parallel description language defined by extending the specification of the language Pascal, the procedure (function) used inside is It was defined in advance and already has compiled code generated. In order to remove the complicated process of performing a normal compile process for a single processor and detecting cobegin for already generated code, then returning and embedding the code required for parallel execution, the above-mentioned embodiment Used the parallel execution procedure name table 116.

As another embodiment, there is the following method. It is a method of rewriting a part of the data string passed from the lexical analysis means 103 on the working memory of the syntax processing means 104 according to the record of the parallel execution procedure name table 116. Therefore, in addition to the normal procedure and the symbol indicating the function, the symbol of the procedure and the function to be executed in parallel are defined, and the procedure name (the procedure name to be executed in parallel in the data string output from the lexical analysis unit 103 ( Alternatively, the position of the function name) is detected, and the symbol for this procedure (or function) is replaced from the normal value to the value of the symbol to be executed in parallel.

In the subsequent parsing process, the code required for parallel execution is generated at the stage when a symbol to be executed in parallel is detected.

As yet another embodiment, the language specifications for procedure and function declarations are expanded, and the procedure to be executed in parallel is not declared by the reserved word procedure, but for example co-procedur.
There is also a realization method such as declaring e to solve. This largely depends on what specifications are provided at the language design stage. However, the method used by the embodiment of the present invention described above is effective for generating an execution code on a multiprocessor of a parallel description language regardless of a specific language specification.

[0088]

According to the present invention having the above-described structure, the result of updating the value at the time of parallel execution is reflected by the exclusive control program even for the variable of reference only copied to the local area. As a result, even if the source code is written in the parallel description language, the operation of which cannot be guaranteed by the conventional method,
There is an effect that a correct operation can be obtained. In this case, the variable detected only by the variable effective range detecting means and the variable substitution detecting means of the present invention and only referred to is copied to the local area of another processor by the parallelized program. This function reduces the frequency of access arbitration when reading the shared variable, and thus has the effect of improving the execution speed.

[Brief description of drawings]

FIG. 1 is a configuration diagram of an embodiment of the present invention.

FIG. 2 is an explanatory diagram of a procedure for referring to a non-local variable.

FIG. 3 is an explanatory diagram of a procedure of substituting a non-local variable.

FIG. 4 is an explanatory diagram of a rule of program code generation for exclusive control.

FIG. 5 is a flowchart of variable detection processing.

FIG. 6 is an explanatory diagram of an example of a block.

FIG. 7 is an explanatory diagram of an example of a relationship between blocks and a variable table designation structure.

FIG. 8 is an explanatory diagram of a block variable table and a block execution management table.

FIG. 9 is an explanatory diagram of an in-block variable table and a block execution management table.

FIG. 10 is an explanatory diagram of a variable class structure.

FIG. 11 is a flow chart of processing of table creating means.

FIG. 12 is a flow chart of processing of table creating means.

FIG. 13 is an explanatory diagram of processing of a runtime library.

FIG. 14 is an explanatory diagram of an execution code during parallel execution.

FIG. 15 is an explanatory diagram showing a configuration example of a multiprocessor system.

FIG. 16 is an explanatory diagram showing an example of source code for which a guarantee of operation cannot be obtained by a conventional method.

[Explanation of symbols]

1 ... Microprocessor unit 2. Local memory 3 Shared memory 4 ... Communication control means 5 ... Communication path 101 ... Source code 102 ... Compiler 103 ... Lexical analysis means 104 ... Syntax analysis means 105 ... Variable effective range detecting means 106 ... Variable substitution detection means 107 ... Code generation means 108 ... Table creating means 109 ... Temporary file 110 ... Shared variable management table 111 ... Runtime library 112 ... Parallelization program 113 ... Exclusive control program 114 ... Linker 115 ... Object code 213 ... Copying variables that can only be referenced 215 ... Semaphore 303 ... Semaphore 801 ... Variable table designation structure 802 ... In-block variable table 806 ... Block execution management table 900 ... Variable class structure

─────────────────────────────────────────────────── --- Continuation of the front page (56) References JP-A-2-132525 (JP, A) JP-A-4-102159 (JP, A) JP-A-3-52033 (JP, A) JP-A-2- 311949 (JP, A) JP 3-6751 (JP, A) JP 2-87258 (JP, A) JP 63-156257 (JP, A) JP 63-67669 (JP, A) JP-A-55-74656 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 15/16-15/177

Claims (5)

(57) [Claims] 1. A compiler apparatus for generating an object code from a source code written in a language specification capable of describing parallel processing, wherein: a plurality of processing units included in the source code;
The first processing unit includes a second processing unit, and
Of the variables in the first processing unit can be accessed from the second processing unit, and the access from the second processing unit is a value when the processing unit is subject to parallel processing. Regarding the specific variable that is only for reference, the second
When parallel processing of the second processing unit is executed, in the memory area in which the process at the time of parallel execution of the second processing unit exists,
First code generation means for generating a first execution code for copying the specific variable as a copy variable; and the first code generation means for executing the first processing unit when the processing of the first processing unit is executed.
When there is an access to the specific variable from the unit of processing and the access is a value substitution, the access from the process to the copy variable, which is a copy of the specific variable, is made to wait, and the specific variable is assigned. Second code generating means for generating a second execution code for substituting a value into a pre-copy variable and then releasing a wait for access to the copy variable; and A compiler device for generating an object code including two execution codes. 2. An information processing system capable of executing in parallel a first process existing in a first memory area and a second process existing in a second memory area, wherein: Of the variables existing in the memory area and accessed by the first process, the specific variables that can also be accessed by the second process and are accessed only from the second process,
Variable copying means for copying the specific variable to the second memory area as a copy variable; and if the specific variable is accessed by the first process and the access is substitution of a value, the specific variable A variable assignment that waits for an access from the second process to the duplicated variable that is a copy, assigns the value assigned to the specific variable to a pre-duplicated variable, and then releases the wait for access to the duplicated variable An information processing system comprising: 3. The information processing system according to claim 2 , further comprising at least first and second processors, wherein the first process is executed by the first processor, and the second process is executed by the first process. An information processing system characterized by being executed by a second processor. 4. An object code generation method for generating an object code from a source code described in a language specification capable of describing parallel processing by using a compiler device, comprising: (a) included in the source code. The first processing unit includes the second processing unit, and
When the second processing unit is a target of parallel processing, it can be accessed from the second processing unit among variables in the first processing unit, and can be accessed from the second processing unit. When the parallel processing of the second processing unit is executed for a specific variable whose value is only a value reference,
The compiler device generates a first execution code for copying the specific variable as a copy variable in a memory area in which a process exists in parallel execution of the processing unit of (b) the first processing unit. When the processing of is executed, there is access to the specific variable from the first processing unit,
If the access is a value substitution, the process waits for an access from the process to the copy variable, which is a copy of the specific variable, and the value assigned to the specific variable is assigned to the pre-copy variable. The second execution code for releasing the waiting for access to the copy variable is the compiler device.
And a step of: generating an object code including the first and second execution codes from the source code using the compiler apparatus . 5. The first process existing in the first memory area by the first processor is transferred to the second processor.
Thus the second process that exists in the second memory area,
A respective information processing method to be executed in parallel, (a) present in the first memory area, among the variables accessed by said first process, with may be accessed by the second process, With respect to a specific variable whose access from the second process is only a value reference, the first processor copies the specific variable to a second memory area as a copy variable, and (b) the first variable If there is access to the specific variable by the process of and the access is substitution of value,
The first processor waits for an access from the second process to the copy variable, which is a copy of the specific variable, substitutes the value assigned to the specific variable into a pre-copy variable, and then the copy An information processing method comprising a step of canceling a wait for access to a variable.