JPH03189775A - Data driving type computer - Google Patents

Abstract

PURPOSE:To decrease the quantity of the whole execution program by comparing the program quantities in the case execution programs are generated by a subroutine shared system and a subroutine embedded system, respectively, and generating the execution program by selecting a system in which the program quantity becomes small. CONSTITUTION:The program quantities in the case an execution program is generated by a system for sharing a subroutine by utilizing an identifier managing mechanism, in the case the execution program is generated by a system in which a subroutine body is embedded in a main program are compared by a program size comparing part 7. In accordance with a result of decision by the program size comparing part 7, the execution program is generated by selecting the execution program generating system in which the program quantity becomes small by an execution program generating part 6, and the execution program is outputted to an external storage device 1 from a file output part 8. In such a way, the quantity of the whole execution program can be decreased.

Description

[Detailed Description of the Invention] [Industrial Application Field] The present invention relates to a data-driven computer, and more specifically,
The present invention relates to a data-driven computer with an improved linkage loader that combines multiple programs to generate an executable program including subroutines.

[Prior Art] A data-driven computer executes a program called a data flow graph according to a simple execution rule that ``processes are executed starting from processable data.'' A data-driven computer mainly consists of three components: a data pair detection mechanism, an arithmetic processing mechanism, and a program storage mechanism. The actual execution of the data flow graph is roughly as follows.

In a data-driven computer, program processing is performed using a set of data called a packet as a unit. This packet consists of data to be processed, data flow graph connection information (hereinafter referred to as node number), instruction code, etc.

The data pair detection mechanism detects that a pair of operand packets are in a computable state and outputs this. A pair of operand buckets output from this data pair detection mechanism are processed by an arithmetic processing mechanism. As a result, the packet is given a new node number in the program storage and sent to the data pair detection mechanism. A series of data flow graphs are executed by repeating such processing.

By the way, in the execution method of such a data-driven computer, when processing packets whose order relationship is not determined, the processing order is not determined until execution time. Therefore, if the main program uses a subroutine sharing system in which the same subroutine can be called and used from multiple locations, there is a possibility that one subroutine may be called simultaneously from different locations in the main program. In such a case, it becomes difficult to distinguish from which part of the main program the packet in which the subroutine is being executed is called.

For this reason, conventional data-driven computers employ a method of including in packets an identifier for distinguishing packets during subroutine execution. Such identifiers are managed by the data-driven computer's identifier management mechanism.
An unused identifier is given to a packet by an identifier acquisition command, and a used identifier is returned by an identifier return command. Note that the identifier acquired in the first packet is assigned a new node number in the program storage mechanism, and continues to be received even when the next packet is executed.

By the way, on a data-driven computer having the above-mentioned identifier management mechanism, when the linkage loader that assembles the execution program detects a subroutine call instruction, the linkage loader shown in FIG. Add a description of the bucket operation as shown in .

When a subroutine is called from the main program and execution of the subroutine is started, first a GETC instruction 9 for acquiring an identifier is executed. Next, after the 5ETC instruction 10 is executed to give an identifier to each packet with parameters passed to the subroutine,
The packet operation is described so as to be connected to the node number of packet 11 of the subroutine body.

At the end of the subroutine execution, it is necessary to inform the packet of the return destination node number on the main program. In this case, first, the 5ETR is used to hold the return node number of the packet of each main program that receives the packet from the subroutine inside the packet.
After the TN instruction 12 is executed, the RETIIRN instruction 13
The node number is attached to the packet that executes.

Apart from this, a packet holding parameters to be passed to the main program at the end of execution of the subroutine is also connected to the node number of the packet that executes the RETtlRN instruction 13. When the RET[IRN instruction 13 is executed, the node number in the subroutine is replaced with the return address of the main program, and the packets with parameters are connected to the packets of the main program.

After waiting for the arrival of all packets returning from the subroutine to the main program by the 5YNC instruction 14, the used identifier is returned to the identifier management mechanism by executing the FREεC instruction 15 which returns the identifier.

By adding the above description of packet behavior when calling a subroutine from the main program,
Even when subroutines are called simultaneously from different positions in the main program, each packet executing the subroutine is executed while retaining a specific identifier.

Since the bucket pair detection mechanism does not detect two packets as a set unless the identifiers of the two packets are the same, calculations are performed while distinguishing between these packets.

Furthermore, in a data-driven computer that does not have the above-mentioned identifier management mechanism, when a linkage loader detects a call to a subroutine, an execution program is generated by embedding the main body of the subroutine in the main program.

[Problem to be solved by the invention]

In a data-driven computer equipped with the conventional identifier management mechanism as described above, an execution program that performs subroutine sharing is generated whenever a subroutine call (a call for using a subroutine) is detected. When an executable program for subroutines is generated, as mentioned above, an identifier is acquired so that each packet can be distinguished even if the same subroutine is called from different positions in the main program at the same time, and the parameters passed to the subroutine are It becomes necessary to newly add to the main program an instruction for assigning an identifier to a packet with a subroutine, and a description for an instruction for identifying a used identifier and returning it to the management mechanism at the end of subroutine execution.

Therefore, the number of times a particular subroutine is called is n
, the program size of the subroutine body is S.

Letting t be the amount of program that is newly added when subroutines are shared, when an execution program is generated using the subroutine sharing method, the program lyl required to call this subroutine is expressed as yl=s+tXn.

Furthermore, in data-driven computers that do not have an identifier management mechanism, when a subroutine call is detected, an executable program is generated by embedding the subroutine body into the main program. Therefore, let n be the number of times a particular subroutine is called.

Assuming that the program size of the subroutine body is S, when an execution program is generated by embedding the subroutine body in the main program, the program size y2 required for the subroutine call is expressed as y2=sXn.

Comparing both execution program generation methods, in the case of a program in which the program amount 3 of the subroutine body is larger than the additional program amount t and the number of iterations n is also larger, it is better to generate the execution program by the subroutine sharing method. The amount of programs can be saved compared to the case where the execution program is generated by embedding it in the main program.

However, when the additional program amount t is larger than the program amount S of the subroutine body, or when the number of subroutine calls n is small, the method of sharing the subroutine is compared to the method of embedding the subroutine body in the main program. This actually increases the amount of programs.

Expressing this numerically, the execution program generation method using subroutine sharing actually exhibits the effect of reducing the amount of execution programs only when the condition y2>yl is satisfied. If we rearrange the contents of this conditional expression, sXn>s+tXn, so sx (n-1)/(txn)>1.

Therefore, the method of generating an execution program by sharing subroutines is effective in reducing the amount of programs only when this conditional expression is satisfied, and in other cases there is a problem in that the amount of programs increases.

[Means to solve the problem]

The present invention generates an execution program by assembling a program selected from a plurality of programs by either a subroutine sharing method in which a subroutine is shared in a main program or a subroutine embedding method in which a subroutine is embedded in a main program. In a data-driven computer to be executed, when generating an execution program that includes a subroutine, compare the amount of the program when the execution program is generated using the subroutine sharing method and the subroutine embedding method, and choose whichever method has the smaller program amount. A feature is that there is no need to select a method and generate an executable program.

More specifically, the present invention assembles and executes a program selected from a plurality of programs using either a subroutine sharing method in which a subroutine is shared in the main program or a subroutine embedding method in which a subroutine is embedded in the main program. In a data-driven computer that generates and executes a program, a subroutine call detection section detects subroutines to be included in the execution program, and for each subroutine detected by the subroutine call detection section, the program amount,
a subroutine information registration unit that stores the program amount and the number of times of use that are separately required when shared by the execution program; an execution program generation unit that can generate an execution program using either the subroutine sharing method or the subroutine embedding method; If a subroutine is required when generating an executable program by the executable program generator,
a program size comparison section that compares the amount of programs generated when execution programs are generated using the subroutine sharing method and the subroutine embedding method, respectively, according to the storage contents of the subroutine information registration section; The present invention is characterized in that the execution program is generated by selecting one of the methods that reduces the amount of the execution program according to the comparison result of the comparison section.

[Effect]

In the data-driven computer of the present invention, the program size is different when an executable program is generated by a method of sharing subroutines using an identifier management mechanism, and when an executable program is generated by a method of embedding the subroutine body in the main program. If it is determined that the amount of execution programs will not be reduced even if the subroutines are shared, an execution program is generated by selecting a method of embedding the subroutine body in the main program.

〔Example〕

Hereinafter, the present invention will be explained in detail with reference to the drawings showing embodiments thereof.

FIG. 1 is a block diagram showing an example of a schematic configuration of a data-driven computer according to the present invention.

The linked and assembled program is stored in external storage device 1.
is stored in. File data indicating the contents of the execution program is input from the external storage device 1 into the linkage loader through the file input section 2.

The execution control unit 3 of the linkage loader first uses the subroutine call detection unit 4 to inspect the contents of the file.

As a result, when the subroutine call detection section 4 detects a subroutine call (subroutine call), if the called subroutine name is the first subroutine called, the subroutine name is stored in the subroutine information registration section 5.

Program IS of subroutine body, number of times called n
(in this case, "1") and the program N[, which is a description part that needs to be added separately when an execution program is generated using the shared subroutine method, is calculated and registered. When a subroutine that has already been called is called again, "1" is added to the number of calls n already registered with the same subroutine name.

After the subroutine call detection unit 4 performs the above-described inspection on all linked programs, the execution control unit 3 of the linkage loader uses the execution program generation unit 6 to generate an execution program.

At this time, when the execution program generation section 6 detects a subroutine call, the program size comparison section 7 is activated.

The program size comparison section 7 is the subroutine information registration section 5.
By substituting the information registered in the above-mentioned equation sX (n-1)/(txn)>1, it is determined whether the adoption of the subroutine sharing method can reduce the amount of executed programs.

According to the determination result by the program size comparison unit 7, the execution program generation unit 6 selects the execution program generation method that reduces the program amount, generates an execution program, and executes it from the file output unit 8 to the external storage device 1. Output the program.

〔Effect of the invention〕

As detailed above, in the data-driven computer of the present invention, the amount of programs generated when an executable program is generated using the subroutine sharing method, and the amount of programs when an executable program is generated using the method of embedding the subroutine main body in the main program. Since the execution program is generated by selecting the one with the smaller program amount, the overall amount of the execution program can be reduced compared to the case where only one method is used to generate the execution program. It becomes possible to increase the efficiency of program use.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing an example of a schematic configuration of a data-driven computer according to the present invention, and FIG. 2 is a schematic diagram for explaining the instruction part newly added when generating an execution program using the subroutine sharing method. It is a diagram. 3... Linkage loader execution control unit 4... Subroutine call detection unit 5... Subroutine information registration unit 6... Execution program generation unit 7...
Program size comparison section patent Applicant: SANYO Electric Co., Ltd.

Claims (1)

[Claims] (1) Either the subroutine sharing method, in which subroutines are shared in the main program, or the subroutine embedding method, in which subroutines are embedded in the main program,
In a data-driven computer that assembles a program selected from a plurality of programs to generate and execute an execution program, when generating an execution program including a subroutine, the subroutine sharing method and the subroutine embedding method are used to generate an execution program, respectively. What is claimed is: 1. A data-driven computer that compares the amount of programs generated and selects one of the methods that reduces the amount of program to generate an executable program.