JPH0727473B2 - Data flow program debug device - Google Patents

Description

Description: TECHNICAL FIELD The present invention relates to a data flow program debugging device, and in particular, it is possible to debug a source program by displaying each line of the source program expanded in the data flow program. To a debugging device such as

[Prior Art] In a conventional computer, various instructions are stored in a program memory as a program, addresses of the program memory are sequentially designated by a program counter, the instructions are sequentially read, and the Neumann computer is executed. Is the majority.

On the other hand, the data flow type information processing apparatus is a type of non-Neumann type computer that does not have the concept of sequential instruction execution by a program counter. Such a data-flow type information processing device has an architecture based on the premise that instructions are processed in parallel. Then, as soon as the data to be operated is available, the instruction can be executed, and multiple instructions are driven simultaneously by the data,
Programs are executed in parallel according to the natural flow of data. As a result, the time required for the calculation can be greatly reduced.

FIG. 5 is a schematic block diagram showing an example of a conventional data flow type information processing apparatus, and FIG. 6 is a diagram showing a basic configuration of a data packet circulating in each part of the information processing apparatus shown in FIG. FIG. 7 is a diagram showing a part of the data flow program stored in the program memory.

First, with reference to FIG. 5, FIG. 6 and FIG. 7, the configuration and schematic operation of the data flow type information processing apparatus will be described. Destination information of the data packet shown in FIG. 6 stores destination information, instruction information stores instruction information, and data 1 field or data 2 field stores operand data.

In FIG. 5, the program storage unit (PS) 1 includes a program memory, and as shown in FIG. 7, a data flow program including destination information and instruction information is stored in the program memory. The program storage unit 1 reads out the destination information and the instruction information by addressing based on the destination information of the data packet, stores each information in the destination field and the instruction field of the data packet, and outputs it to the input buffers 2a, 2b made of FIFO. .

The data detector (FC) 2 waits for a data packet input from the program storage unit 1 via the input buffers 2a and 2b, and selects one of the two data packets having the same destination information. The operand data of is stored in a predetermined data field of the other data packet and is output to the input buffer 3a formed of a FIFO. At this time, the one data packet described above disappears.

The arithmetic processing unit (FP) 3 decodes the command information of the data packet input from the paired data detection unit 2 via the input buffer 3a, performs a predetermined arithmetic processing on the two operand data, and outputs the result. The data is stored in the data field of the data packet and output to the branch unit 4.

Based on the destination information of the data packet, the branching unit 4 gives the data packet to the input buffer 1a composed of a FIFO or to the external data memory (EDS) 6 via the input buffer 5a composed of a FIFO. The data packet from the input buffer 1a or the data packet output from the external data memory 5 via the output buffer 5b is the merging unit 6
And the merging unit 6 supplies the data packets to the program storage unit 1 in the order of arrival.

In the data flow type information processing apparatus shown in FIG. 5, the data packet is stored in the program storage unit 1-> pair data detection unit 2-> arithmetic processing unit 3-> branching unit 4 (-> external data memory 5)-> merging unit 6 → By continuing to rotate like the program storage unit 1, the arithmetic processing based on the program stored in the program storage unit 1 proceeds.

FIG. 8 is a diagram showing a schematic configuration of the program storage unit 1 shown in FIG. In FIG. 8, the input data latch unit 11 holds the destination information and operand data of the data packet, and the command information is erased. The held operand and the new destination information and instruction information read from the program memory 13 based on the destination information are given to the output data latch unit 14 and latched. The destination information latched by the input data latch unit 11 is given to the address calculation unit 12, and the destination memory information is used to program memory.
13 addresses are calculated. The program memory 13 stores the data flow program including the destination information and the instruction information as shown in FIG. 7, and the new destination information and the instruction information are output by the above-mentioned address.
Given to 14.

[Problems to be Solved by the Invention] In the above-mentioned data flow type information processing apparatus, it becomes possible to execute an instruction as soon as data to be operated is prepared,
Programs are executed in parallel and asynchronously according to the natural flow of data. Therefore, when a source program such as the one written when it is executed in a normal Neumann computer is developed and executed in a data flow program, the execution order does not always match the execution order in the Neumann computer, so it is simple. There was a problem that the error of the source program could not be found and corrected only by following the program. In addition, it is more difficult to find an error when executing the expanded data flow program, and it is also very difficult to know the correspondence with the source program.

Therefore, a main object of the present invention is to provide a debug device for efficiently debugging a data flow program executable on a data flow type information processing device.

[Means for Solving the Problem] The present invention is a data flow program debugging device for debugging the operation of a data flow program in units of lines described in a source program, and a program storage means for storing the data flow program. For each line of the source program corresponding to the data flow program, the data flow program including a plurality of functional parts for simulating functions corresponding to a plurality of constituent parts in the processing device that executes the data flow program and stored in the program storage means Used for executing the data flow program in each row of the corresponding source program, the state executing means for storing the execution state corresponding to each row of the source program of the plurality of functional parts of the program executing means, Data program Data transition storage means for storing the progress of processing and execution in each functional part of the line means, and debug data information storage for storing debug information indicating the correspondence between each line of the source program and each node of the data flow program Means and state storage means to obtain information on the execution status of the dataflow program at the time of program execution, and the data transition storage means to obtain information on the data of the dataflow program at the time of program execution, and store those information in debug information. Control means for associating each line of the source program from the debug information stored in the means and extracting information about each line of the source program from the program storage means, and debug information for displaying the debug information about each line of the source program obtained by the control means And a display means .

[Operation] Since the debug device according to the present invention creates the file showing the correspondence between the source program and the data flow program, the source program corresponding to the sequentially executed data flow program can be displayed. Further, during the simulated execution of the program, the data flow program is sequentially advanced each time each line of the corresponding source program is executed and finished, and the state of each component of the data flow type information processing apparatus and the data transition are sequentially performed. The result is stored in the state storage means and the data transition storage means, and as a result, the execution order and execution information of the source program corresponding to the data flow program can be obtained.

[Embodiment] FIG. 1 is a schematic block diagram of an embodiment of the present invention.

In FIG. 1, the debug execution device 10 is a part that simulates the internal operation of the data flow type information processing device, and executes the operation of each component of the data flow type information processing device. As the debug execution device 10, a general information processing device (Neumann computer) is used. An input file 20, a command file 30, a console 40, an internal file 50, a debug display file 60, a result file 70 and a display 80 are connected to the debug execution device 10.

The input file 20 is a part for inputting data necessary for causing the debug execution device 10 to execute a data flow program and perform debugging. The input file 20 includes a program file 21 and a debug information file 22. The program file 21 stores the object program of the data flow program and the data used for it. Also, debug information file 22
Stores a source program list and information indicating the correspondence between the source program and the object programs expanded in the data flow type. The command file 30 stores various instructions related to debugging, and the command file 30 stores a command group executed by batch processing.

The console 40 is for inputting various designations relating to debugging. The internal file 50 stores various information used inside the debug execution device 10, and includes a PS file 51, a data packet file 52, and an ED.
Includes S file and EDS map file (hereinafter referred to as EDS file) 53. PS file 51 is a program file
It stores a data flow program obtained by converting the object program given from 21 into a format executable by the debug execution apparatus 10. The data packet stored in the data packet file 52 corresponds to the data packet circulating in each part of the data flow type information processing apparatus shown in FIG. The EDS file 53 stores the storage contents of the portion corresponding to the external data memory 5 shown in FIG.

The debug display file 60 stores changes in the display during debug execution in the debug execution device 10, and the result file 70
Stores the execution result of the data flow graph by the debug execution device 10.

Therefore, the result of the arithmetic processing based on the data flow program is stored in the result file 70. Display 80 is the contents of debug display file 60, result file
Show 70 contents and message.

The object program given from the program file 21 is converted into a data flow program that can be executed by the debug execution device 10 and stored in the PS file 51. Further, the data given from the program file 21 is stored in the data packet file 52. The debug processing by the debug executing device 10 shown in FIG. 1 is executed according to a command input from the console 40 or a command stored in the command file 30.

2 is a diagram showing an example of a source program debugged by the debug device shown in FIG. 1, FIG. 3 is a diagram showing a flow graph based on the source program shown in FIG. 2, and FIG. FIG. 6 is a diagram showing an example of a debug execution result according to an embodiment of the present invention.

In the flow graph shown in FIG. 3, the numbers in the circles on the right side show the execution rank values, and the numbers on the left side show the node numbers added in ascending order of the execution rank values. Programs shall be executed in the order of their node numbers. Therefore, when the source program shown in FIG. 2 is executed in the order of the node numbers, it is displayed as shown in FIG. 4 along with the execution of debugging.

First, the display format of FIG. 4 will be described by taking the case of the node 2 shown at the position 100 as an example. The information displayed there is the information when the node 2 was executed.

At the time of debug execution, as shown in FIG. 4, three types of display, that is, the executed node number 100, the process start line 210, the process line 220, and the process end line 230 are displayed. Processing start line 2
Reference numeral 10 means a line of the source program in which data comes to any one of the nodes belonging to one line.
In addition, the line 220 being executed means the line of the source program whose data has come to all of the input nodes among the nodes belonging to one line. Note that an input node is a node that is directly connected to a node that does not belong to the row, such as a node that belongs to another row. The processing end line 230 means the line of the source program in which all the nodes belonging to the one line are executed.

All of the above three types are displayed in the same format. Here, the format will be described. The number 10 displayed at the leftmost position 300 indicates the line number in the source program. Its right position 31
0 indicates the contents of the source program described on the 10th line, and the position 320 on the right of it is a list of all variables existing on that line. Each (output source line number): (variable name ) Is in order.

If the variable name is in parentheses, it means that the value of the variable is fixed, and "source" at position 320 means the source such as the input to the program. Next, 330 below it shows the line number in which the instruction to be processed next for each variable is described. Since there are a plurality of lines, they are separated by the symbol ",". The above three types of lines 210, 220, 230 are all displayed in the above format.

According to the above format, the information regarding each line displayed in the process end line 210, the process start line 220 being executed, and the process end line 230 is changed as the debug is executed, as shown in FIG. To go. For example, looking at 10 lines, first, the execution of node 2 shown at position 100 causes information about 10 lines to be displayed in the process start line 210, and then after execution of node 6, the execution line 222 is displayed. The display is moved, and the execution of node 10 causes the processing end line 233.
Moved to and displayed. The display is changed as above for all lines, and debugging is executed.

Next, how the display changes according to the execution of each node will be described in detail. As shown in FIG. 3, since the data is sent to the node 7 by executing the node 2, the line 10 to which the node belongs is displayed in the process start line 210. At that time, all the variables belonging to the row are fixed, and all the variables to be displayed at the position 320 are displayed in ().

Next, when node 5 is executed, node 11 belonging to line 12
Since the data having the fixed value of the variable b is sent to, the 12 lines are displayed in the processing start line 211. At this time, a variable belonging to the 12th line, "x" displayed at the position 420, is displayed without being put in (). This is because the 10 lines that output that value have not been completed yet, so the value has not yet been determined.

Furthermore, since the data is sent to all the input nodes belonging to the 10th row by the execution of the node 6, the 10th row is displayed in the currently-executed row 222. The input node means a node having a node that does not belong to the row as an output source node as described above, and the nodes 7 and 8 are shown in the case of 10 rows. Output source node 2 of input node 7,
4 and the output source nodes 5 and 6 of the input node 8 are all executed at this point, and therefore the input node 7 and
Data comes to all eight.

Further, when the program is executed and the node 10 is executed, all the nodes 7, 8 and 10 belonging to that line have been executed for the 10 lines, and the 10 lines become the processing end line 233. Is displayed. In addition, as a result, the value of the variable “x” is determined, so that it is displayed in the line 223 being executed.
Variable “x” displayed at position 422,520 in 12 lines respectively
Is displayed in ().

As described above, the displayed information changes as the program is executed. Finally, the execution of the node 16 completes the execution of the expression on the 14th line, which is the final line of the source program, and the 14th line is displayed in the processing end line 234, and the data flow program given as an example ends. For the variable “out” output by the 14th line, since the destination is the output of the program, “sink” (meaning sync) is displayed as the line number 630 of the destination.

The debugging is executed as described above, and the execution order and the execution information regarding the source program executed by the data flow type information processing apparatus are obtained.

[Effects of the Invention] As described above, according to the present invention, it is possible to obtain the execution order of a source program corresponding to the execution of a dataflow program and the execution information of the source program represented by variables. It enables easy and accurate development.

[Brief description of drawings]

FIG. 1 is a schematic block diagram of an embodiment of the present invention.
FIG. 2 is a diagram showing an example of a source program applied to one embodiment of the present invention. FIG. 3 is a diagram showing an example in which the source program shown in FIG. 2 is expanded into a data flow program. FIG. 4 is a diagram showing a debug execution result according to an embodiment of the present invention. FIG. 5 is a block diagram showing an example of the configuration of a conventional data flow type information processing apparatus. FIG. 6 is a diagram showing a structure of a data packet circulating in each part of the information processing apparatus shown in FIG. FIG. 7 is a diagram showing a part of the data flow program stored in the program memory. FIG. 8 is a block diagram showing the configuration of the program storage unit of the data flow type information processing apparatus. In the figure, 10 is a debug execution device, 20 is an input file, 21 is a program file, 22 is a debug information file, 30 is a command file, 40 is a console, 50 is an internal file, 51 is a PS file, 52 is a data packet file, 53 is an EDS / EDS map file, 60 is a debug display file, 70 is a result file, and 80 is a display.

Claims (1)

[Claims] 1. A debug device for a data flow program, which debugs the operation of a data flow program in units of lines described in a source program, the program storage means storing the data flow program, and executing the data flow program. The processing unit includes a plurality of functional portions that simulate functions corresponding to a plurality of constituent portions, and the data flow program stored in the program storage means is sequentially executed for each line of the corresponding source program. Program execution means, state storage means for storing execution states of the plurality of functional portions of the program execution means corresponding to respective lines of the source program, and execution of the data flow program in respective lines of the corresponding source program. Data used Data transition storage means for storing the progress of the processing and execution in each functional part of the program execution means, and debug information indicating the correspondence between each line of the source program and each node of the data flow program. Debug information storage means, the state storage means obtains information on the execution status of the data flow program during program execution, and the data transition storage means obtains information on the data of the data flow program during program execution, and the information Is associated with each line of the source program from the debug information stored in the debug information storage unit, and a control unit that extracts information about each line of the source program from the program storage unit, and the source program obtained by the control unit. Debug information about each line With debug information display means for displaying the debugging apparatus of the data flow program.