JP2990084B2 - Arithmetic device synthesis method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a semiconductor integrated circuit, and more particularly to mapping to a semiconductor integrated circuit.

[0002]

2. Description of the Related Art Conventionally, FPGA (Field Programm) has been used as an architecture aiming at advanced parallel processing.
There is a method of directly mapping and executing a program in accordance with a data / control flow on a programmable semiconductor integrated circuit such as an available gate array. When mapping a program to a semiconductor integrated circuit, it is easy to take out large-scale parallelism by incorporating the concept of data flow.

In this method, how to map a program to a semiconductor integrated circuit is an important technical problem.
If the concept of a data flow type computation model is simply adopted, it is easy to extract large-scale parallelism, but it becomes difficult to use as a programming model. A well-known programming language based on a programming model compatible with the concept of a data flow type computation model is a single assignment functional language.

[0004] However, C which is widely accepted in the world
Compared to a language or a procedural language such as FORTRAN, a single assignment functional language is a language with strict restrictions, is not very common, and cannot be said to be easy to use.

Conversely, using a conventional procedural language such as C language or FORTRAN as a description language for directly mapping a program in accordance with a data / control flow on a semiconductor integrated circuit also has many problems. Although local variables can be mapped by analyzing the data stream according to the scope, the existence of global variables inherent in procedural languages is cumbersome.

Since global variables are referred to / substituted in all areas of the program, they are complicatedly affected by the data flow and the control flow, and the scope analysis is not easy. And, unlike local variables, which lose their existence after exiting the function, global variables must always have the substance of the variables, so that data does not always stay in one place like a data flow type calculation model. It is incompatible with the calculation model based on continuing.

[0007]

SUMMARY OF THE INVENTION The problem to be solved by the present invention is to use a procedural language as a description language for directly mapping a program on a semiconductor integrated circuit according to a data / control flow while using a large-scale parallel processing. It is an object of the present invention to provide a method for synthesizing an arithmetic unit capable of extracting the characteristics.

[0008]

In order to solve the above-mentioned problems, the present invention provides a method for calling a function in a procedural language, which is based on the concept of a data flow.
In addition to the condition that the values of the arguments are the same, the operation that is substituting for the global variable referenced by the function has been completed, and the function that has side effects has been completed. , It is possible to extend the concept of data flow and extract the high parallelism of the concept of data flow even in a procedural language using the concept of global variables.

The present invention relates to a method for synthesizing an arithmetic unit for mapping a program described in a procedural language onto a semiconductor integrated circuit, and a function described in the procedural language and globally performing one or both of reference and assignment. A global variable analyzing step of recursively analyzing a reference assignment relationship of a variable, a scope stack generating step of generating a scope stack holding information on which operation and function call assigns to the global variable, and the scope Tracing the stack in the direction opposite to the growth direction, a scope analysis step of finding, based on the reference substitution relationship, a function call B and an operation to substitute for a global variable referred to by the function call A,
A circuit generating step of generating a circuit for activating the function caller when the arguments of the function caller are complete and the function caller and the operation are completed. I do.

[0010] This makes it possible to map a procedural language widely used in the world based on the concept of data flow, thereby achieving both ease of use and high performance.

[0011]

DESCRIPTION OF THE PREFERRED EMBODIMENTS A first embodiment of the present invention will be described with reference to the drawings.

FIG. 1 shows an example of an input program. Considering that this program is directly mapped to a semiconductor integrated circuit and realized, attention is focused particularly on when the function call h (x) 103 is activated. Global variable a10
If 9 does not exist, the argument x10 of the function call h ()
It is possible to activate the function call h (x) 103 when the value of 4 is completed. However, if global variables exist, their data dependencies must also be considered.

Therefore, first, in the subroutine called by each function call, which global variable is referred to,
Analyze which global variables are assigned. The analysis is performed as shown in FIG.
1 and global variable assignment table 202, global variable reference table 203 and global variable assignment table 204 for function g (), and global variable reference table 205 and global variable assignment table 20 for function h ()
6 is performed.

Here, it should be noted that the data dependency between the function f () and the global variable appears at first glance as if only the assignment 106 to the global variable b exists. Function g () and function h () called
Is that the assignment to the global variable a is performed. As a result, the function f () has a data dependency not only with the global variable b but also with the global variable a.
Thus, for a global variable that does not have a direct data dependency in a function itself but has a data dependency in another function called in that function, the function called in the function The analysis is performed by recursively listing which global variables are to be assigned to.

Next, a scope stack indicating which global variable is assigned and where is assigned is generated. FIG. 3 is a diagram showing the scope stack 301 generated according to the input program of FIG. 1 and the table shown in FIG.
In this case, the scope stack is the function call f (), and the scope stack 301 grows rightward in FIG. 3 as the program is analyzed in the order of description.
Each item of the scope stack 301 has a variable name,
Describe the distinction between local variables and global variables, and the distinction between assignment on the spot and assignment to a global variable by a function call. In the case of assignment, write the function name.

Here, the assignment to a global variable by a function call means that by calling the function, the assignment to the global variable is performed in the called function. Whether the substitution is performed can be understood by referring to FIG.

When the scope stack 301 is used, when a reference to a variable occurs at a certain point in the program, it is possible to know which assignment is the result of the value to be referenced. That is, when a reference to a certain variable occurs, the scope stack 301 at that time is traced in the reverse direction, and the assignment to the variable found first becomes the value to be referred.

Finally, the function call h () 103
Is determined when to start. In order to activate the function call h () 103, it is necessary that the value of the argument x is obtained and that the value of the global variable a referred to by the function call h () 103 be obtained. Therefore, by tracing the scope stack 301 in the opposite direction, the argument x
And the time when the global variable a is obtained. Then, for the argument x, it is necessary to wait for a reference to the argument x and a value assigned at the assignment 105,
Since the global variable a is substituted by the function call g () 101, it is necessary to wait for the end of the function call g () 101.

Therefore, in order to activate the function call h () 103, it suffices to wait for the reference and the assignment 105 to the argument x and the termination of both the function call g () 101. FIG. 4 is a diagram showing an example of generating a signal for activating the function call h (). Referring to FIG. 4, an end signal 4 indicating that the process of “x ++;” is completed by the block 401.
When the synchronization block 406 that synchronizes the end signals detects that both the end signal 04 and the end signal 405 indicating that the block 402 that calls the function g (x) have ended, the synchronization block 406 is a function h
A start signal 407 of (x) is generated.

By doing as described above, it is possible to map a conventional procedural language such as C language or FORTRAN, in which a dependency is caused by global variables, based on a concept of a data flow, and it is easy to use and sophisticated. Parallelism can be compatible.

FIG. 5 is a diagram showing activation of the function h (x) 503 according to the second embodiment of the present invention. Looking at the program of FIG. 1, it is noted that it is not always necessary to wait for the execution of the function call g () 101 to end in order to activate the function call h () 103. Since the function call h () 103 needs the value of the global variable a, the function call h () 103 immediately after the reference to the global variable a in the function call g () 101 and the assignment 107 are finished.
() 103 may be activated. The second embodiment takes this point into consideration.

In FIG. 4, it is detected by the synchronization block 406 of each end signal that both the end signal 404 of the process of "x ++;" and the end signal 405 of the function g (x) have become complete. In FIG. 5, the end signal 504 of the processing of “x ++;” and the reference and assignment 107 to the global variable a
Immediately after this, both of the end signals 509 of the assignment to the global variable a in the function g (x) are changed
6 and the synchronization block 506
Generates an activation signal 507 for the function h (x). As a result, the function call h () 103 can be activated without waiting for the termination of the function call g () 101, and the execution time can be reduced.

FIG. 6 shows an example of a program to which the third embodiment of the present invention is applied. In the first and second embodiments, it is only necessary to wait for the global variable a. On the other hand, a case where a plurality of global variables have a dependency will be described with reference to FIG.

In the function call g () 601, the global variables a, b and c are substituted, and the function call h () 602
, References to global variables a, b, and c occur. The order dependency of the assignments 603, 604, and 605 to the global variables a, b, and c in the function call g () 601 is clear, and the assignment 605 to the global variable c is executed last. Accordingly, the last assignment end signal of the assignments to the plurality of global variables, that is, the assignment end signal of the assignment 605 to the global variable c can be used as a representative assignment end signal.

FIG. 7 shows an example of a program to which the fourth embodiment of the present invention is applied. The fourth embodiment deals with a plurality of global variables in the same manner as the third embodiment. However, the third embodiment is directed to a program in which the dependency of the order of the global variables is clear. The fourth embodiment targets a program whose order cannot be specified.

Assignments 703, 70 to global variables a, b, c
4 and 705 are relations each having no data dependency.
Since the result of calling the number is substituted,
Can be executed, and each assignment ends
The context of the time is unknown. For this reason, the global variable at which the assignment ends last cannot be specified, and a representative assignment end signal cannot be determined as in the third embodiment. On the other hand, in the fourth embodiment, the substitution 7
A synchronization block for detecting that all three substitution end signals of the substitution end signal of 03, the substitution end signal of the substitution 704 to the global variable b, and the substitution end signal of the substitution 705 to the global variable c are added. , And its output to the function call g ()
701 is used as the substitution end signal. As a result, it is possible to cope with a program in which the order of ending assignment to a plurality of global variables cannot be specified.

[0027]

According to the present invention, as a calling condition for invoking a function in a procedural language, in addition to the condition that the values of the ○ arguments are uniform based on the concept of data flow, the function is referred to. The concept of data flow is extended by adding the condition that the operation that is substituting is completed and that the function that gives side effects is completed for the global variable Even in a procedural language that uses concepts, it is possible to extract the high parallelism of the concept of data flow.

The method for synthesizing an arithmetic unit according to the present invention recursively analyzes a global variable referred to / assigned by each function, and retains information on which operation or function call is assigned to a certain global variable. When a function stack is mapped to a semiconductor integrated circuit, the operation or function call assigned to the global variable referred to by the function is traced back through the scope stack. And the call condition of a certain function, ○ that the arguments of the function are complete,
○ According to the scope stack, collect the two conditions of the operation assigned to the global variable referenced by the function and the fact that the function call has been completed, and start the function call when all of these conditions are met. At the stage of generating a circuit to perform.

This makes it possible to map a procedural language widely used in the world based on the concept of data flow, thereby achieving both ease of use and high performance.

Although the present invention has been described based on the embodiments, the present invention is not limited to these embodiments, and it is understood that alterations and improvements are possible within the ordinary knowledge of those skilled in the art. Of course.

[Brief description of the drawings]

FIG. 1 is an example of a program which is a target of a first embodiment of the present invention.

FIG. 2 is a global variable reference table and a global variable assignment table of the program of FIG. 1;

FIG. 3 is a diagram showing a scope stack generated according to the program shown in FIG. 1 and the table shown in FIG. 2;

FIG. 4 is a diagram illustrating an example of generating a signal for activating a function call h ().

FIG. 5 shows a function h (x) according to the second embodiment of the present invention.
FIG.

FIG. 6 is an example of a program which is a target of the third embodiment of the present invention.

FIG. 7 is an example of a program which is a target of the fourth embodiment of the present invention.

[Explanation of symbols]

 201, 203, 205 Global variable reference table 202, 204, 206 Global variable assignment table 301 Scope stack

──────────────────────────────────────────────────続 き Continued on the front page (58) Field surveyed (Int.Cl. ⁶ , DB name) G06F 17/50 G06F 9/06 G06F 9/44-9/455

Claims (8)

(57) [Claims] 1. A method for synthesizing an arithmetic unit that maps a program described in a procedural language onto a semiconductor integrated circuit, comprising: a function described in the procedural language; and a global variable performing one or both of reference and assignment. A global variable analyzing step of recursively analyzing the reference assignment relationship; a scope stack generating step of generating a scope stack that holds information about which operation and function call assigns to the global variable; and Tracing in the reverse direction of the growth direction, a scope analysis step of finding a function call B and an operation to be assigned to a global variable referred to by the function call A based on the reference assignment relationship, and the arguments of the function call A are aligned, and Generating a circuit for activating the function caller when the function caller and the operation are completed Arithmetic unit synthesizing method characterized by including the road generation stage. 2. The method according to claim 1, wherein the step of generating the circuit includes the steps of: calling the function when the arguments of the function call are the same and assigning to the global variable in the function call is completed. A method for synthesizing an arithmetic unit, comprising: generating a circuit for activating the instep. 3. The method according to claim 1, wherein when there are a plurality of global variables to be substituted by the function call, the circuit generation step includes the step of: A method for synthesizing an arithmetic unit, comprising: generating a circuit for activating a function caller when the arguments are complete and when the latest one of the assignments to the global variables in the function caller is completed. 4. The method according to claim 1, wherein when there are a plurality of global variables substituted by the function call, the circuit generating step includes the step of generating the function call. A method for synthesizing an arithmetic unit, comprising: generating a circuit for activating a function caller when all arguments are completed and when all of the substitutions to global variables in the function caller have been completed. 5. The method according to claim 1, wherein the semiconductor integrated circuit is a PLD.
(Programmable Logic Device
e) A method for synthesizing an arithmetic device, the method comprising: 6. A method according to claim 1, wherein said semiconductor integrated circuit is reconfigurable. 7. The arithmetic unit synthesizing method according to claim 6, wherein the reconfigurable semiconductor integrated circuit is an FPGA (F
field Programmable Gate Ar
(ray). 8. The method according to claim 1, wherein the procedural language is FORTRA.
A method of synthesizing an arithmetic device, wherein the method is one of N and C languages.