JPH08185340A - Method for debugging parallel program and device for visualizing parallel program - Google Patents

Abstract

PURPOSE: To provide a parallel program debugging method capable of executing debugging allowing the operation states of plural programs to relate to each other. CONSTITUTION: In this method for debugging a parallel program by controlling plural sequential debuggers 4-1 to 4-5 arranged correspondingly to plural sequential programs constituting the parallel program at the rate of 1 to 1 by a debugger controller 2, the controller 2 executes a procedure for interpreting the description of debugging contents for the parallel program applied from the external, applying instructions to respective debuggers in accordance with the interpreted result to control the execution of the parallel program, acquiring execution control results from respective debuggers, applying instructions to the debuggers again based upon the execution control results to control the execution of the parallel program, and then acquiring execution control results from respective debuggers at least once and outputs a debugged result generated in accordance with the execution control results to the external.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a parallel program debugging method for debugging a parallel program and a parallel program visualization device which is a tool for visualizing the parallel program.

[0002]

[Prior art]

(1) When debugging a sequential program, a method is often used in which a breakpoint is set using a sequential program debugger, the sequential program is executed, and the value of a variable at the time when the program is stopped is read.

At the time of debugging a data parallel program in which a plurality of the same programs are simultaneously executed while communicating with each other, attempts have been made to use a method similar to the above-described method of debugging a sequential program. this is,
This is a method in which a debugger is applied to each partial program that constitutes a data parallel program, a breakpoint is set, each partial program is executed, and the value of the variable at the time when each debugger is stopped is read. However, this method requires the user to send a debug command to each debugger and receive the result. Of course, the same applies when a plurality of programs are different from each other.

In order to reduce this complicated work, a control process that integrates individual debuggers is provided, and a user sends a debug command to each debugger through the control process and receives the result. This is a parallel process called ndb of Express. Used in the program debugger.

However, when the user stops the parallel program at the time of debugging, between the individual partial programs,
There is a case where the user wants to stop the system for the first time when a certain condition is satisfied. This point will be described using the program of FIG. 3 as an example. Here, the program of FIG.
Consider the case of two parallel executions. Now, it is assumed that the user starts each program by using a sequential debugger and sets breakpoints on lines 02 and 04. Set each breakpoint number to 1,
Set to 2. 1, which was added to lines 02 and 04 in FIG.
2 indicates that the breakpoints with the breakpoint numbers 1 and 2 are added to the 02nd line and the 04th line, respectively. Subsequently, the user issues execution instructions of individual programs to the five sequential debuggers. As a result, the individual program stops at either the statement on the 02nd line or the statement on the 04th line, depending on the value of the variable y. Here, when the user issues a continuation instruction for each program to the five sequential debuggers, each program repeatedly executes the loop and stops again at either the statement at line 02 or the statement at line 04. . When the user again issues a continuation instruction for each program to the five sequential debuggers, each program repeatedly executes the loop and stops at the statement at line 02 or the statement at line 04 again.

In this series of processing, on the user side, when three programs out of five programs are stopped at the 02nd line and two programs are stopped at the 04th line, the five programs are not started for the first time. Suppose there is a request to stop. However, in the conventional parallel program debugger, each debugger only controls the corresponding program, and when a condition between a plurality of programs is satisfied, for example, in the above-described state, the debugger automatically automatically operates. The program could not be stopped.

(2) On the other hand, in a parallel program, the processing is advanced while the individual partial programs forming the parallel program communicate with each other, so that the behavior is complicated and the debugging is difficult. Therefore, attempts have been made to visualize the behavior of programs and show them to the user. Usually, a method for embedding a function for visualization in a program for display is adopted.

However, the method of embedding a function for visualization in a program has the following problems. First, the process was complicated because the user had to write the code for visualization. Moreover, even if the code for visualization based on a certain viewpoint is written, if the visualization is desired from another viewpoint, it is necessary to rewrite the visualization portion. In addition, the visualization routine described by taking time and effort becomes unnecessary after the end of debugging. Therefore, a tool that can be easily visualized is desired for general users.

[0009]

[Problems to be Solved by the Invention]

(1) As described above, conventionally, when a parallel program is debugged, the operating states of a plurality of programs are associated with each other, for example, the programs are automatically stopped when a certain condition is satisfied between the plurality of programs. Couldn't debug.

The present invention has been made in consideration of the above circumstances, and an object of the present invention is to provide a parallel program debugging method capable of performing debugging in which the operating states of a plurality of programs are associated with each other.

(2) As described above, conventionally, when visualizing a parallel program, it is not easy to embed a function for visualization in the program, and it is not versatile and the embedded visualization routine is used. Had a bug that became unnecessary after debugging.

The present invention has been made in consideration of the above circumstances, and an object of the present invention is to provide a parallel program visualization device capable of easily visualizing a parallel program without changing the parallel program. .

[0013]

[Means for Solving the Problems]

(1) The present invention provides a parallel program debugging method in which a debugger controller controls each of a plurality of sequential debuggers provided in a one-to-one correspondence with a plurality of sequential programs constituting a parallel program to debug the parallel program. The debugger controller interprets the description of the debug contents for an externally given parallel program, gives an instruction to each of the debuggers according to the interpretation result, controls the execution of the parallel program, and executes the instruction from each of the debuggers. At least one procedure for acquiring control results, giving further instructions to each of the debuggers based on these execution control results to control execution of the parallel program, and acquiring execution control results from each of the debuggers
It is characterized in that the debug result generated according to the execution control result is output to the outside.

Preferably, the debug contents are held in the number of the stopped program, the breakpoint of each program, the value of the variable used in the program at the time of stopping at the breakpoint, and the debugger controller. It may be described using at least one of the values of the internal variables.

Further, preferably, the value of the variable at a certain point in the sequential program is held inside the debugger controller, and even after the value of the variable in the sequential program is destroyed by the continuous execution of the program, the command of the debugger controller is used. You may make it available.

Further, preferably, by defining a hierarchical relationship between the breakpoints, execution control conditions such as a stop condition relating to a plurality of breakpoints may be easily set.

Further, preferably, when all of the plurality of sequential programs are stopped without reaching a breakpoint due to an erroneous setting of a breakpoint by the user, or a deadlock occurs in control of the program. For example, the debugger controller may be interrupted by the user so that control can be returned to the user side. At this time, for example, information such as stop positions of the above-mentioned plurality of sequential programs other than the one stopped at the break point may be shown to the user so that the cause or situation of the deadlock can be grasped.

(2) According to the present invention, a plurality of sequential debuggers provided in a one-to-one correspondence with a plurality of sequential programs constituting a parallel program, and controlling each of the plurality of sequential debuggers to debug the parallel program. In a parallel program visualization device comprising a debugger controller for performing the above, and at least one display means for displaying a debug result according to an instruction from the debugger controller, the debugger controller includes at least one variable to be acquired and the variable. Means for storing variable acquisition information including a position in the sequential program for acquiring a variable, and giving an instruction to each of the sequential debuggers to control execution of the parallel program, and based on the variable acquisition information, the sequential debugger A means for acquiring the value of the variable from each of them, and at a predetermined timing, Means for giving the value of the variable to the designated display means, and the display means stores a display formula created using at least one of the variables for displaying a debug result. And a means for displaying the value of the variable given from the debugger controller based on the display formula.

Preferably, the debugger controller acquires from each of the sequential debuggers according to the simple language at a predetermined timing and means for storing a simple language for processing at least one of the values of the variables. And a means for processing the value of the variable.

Preferably, the display means stores the coordinates of the graphic displayed on the display screen and the number of the sequential program that has acquired the variable for displaying the graphic in association with each other. Means for displaying a processor map in which sequential program numbers are arranged, and, when a specific figure on the screen is designated by a predetermined pointing device, the coordinates of the designated figure and the contents stored in the storing means From the number of the sequential program that has acquired the variable for displaying the instructed figure, and changing the display of the obtained number among the numbers on the processor map. Is characterized by.

[0021]

[Action]

(1) In the present invention, desired debug contents for a parallel program are described in a file or the like and externally given to the debugger controller. The debugger controller interprets this description and gives an instruction to each debugger to control the parallel program according to the result, and acquires the execution control result.

Then, based on the obtained execution control result of each sequential program, further necessary instructions are given to control the parallel program again, and the execution control result is obtained from each debugger. This procedure is repeated as needed.

The debugger controller creates and outputs a debug result to be given to the outside according to the execution control result.
Therefore, according to the present invention, it is possible to carry out desired debugging such as execution control of a sequential program and acquisition of a variable value by associating operation states between a plurality of sequential programs.

For example, it is possible to automatically stop the program when a certain condition is satisfied among a plurality of sequential programs. (2) In the present invention, variable acquisition information including at least one variable to be acquired and the position in the sequential program for acquiring the variable can be set in advance in the debugger controller. The debugger controller gives instructions to each sequential debugger to control a parallel program,
The value of the variable is sequentially acquired from each debugger based on the variable acquisition information. Then, the value of the acquired variable is given to the designated display means at a predetermined timing.

In order to display the debug result, a display formula defining a variable to be displayed and a function using the variable is preset in the display means. The display means displays the value of the variable given from the debugger controller according to this display formula.

Therefore, according to the present invention, it is possible to easily set / change the information about the variable acquired through each sequential debugger and the information for visualizing the debug result on the display means. The parallel program can be easily visualized without changing the parallel program by embedding the function of etc. in the program.

[0027]

Embodiments of the present invention will be described below with reference to the drawings. (1) First, an embodiment of the parallel program debugger will be described. (First Embodiment) FIG. 1 shows the configuration of a parallel program debugger of this embodiment. As shown, this parallel program debugger includes a debugger controller 2 and a plurality of sequential debuggers 4. The number of the sequential debuggers 4 is arbitrary, but in the present embodiment, description will be given assuming that the five sequential debuggers 4-1 to 4-5 are provided.

The sequential debugger 4 is a debugger for debugging a sequential program. In the present embodiment, as the sequential debugger 4, for example, dbx operating on unix
Assume a debugger like gdb or gdb.

Each sequential debugger 4 is controlled by the debugger controller 2. In this embodiment, in order to make the invention easier to understand, a plurality of user programs 6 (6-1 to 6-1) to be debugged using the sequential debugger 4 are used.
In 6-5), the data parallel program, that is, all the partial programs are the same program, but of course, the present invention can be applied even when the individual programs are different from each other.

The debugger controller 2 of this embodiment includes an instruction interpretation execution unit 21, a first communication unit 22-1, a second communication unit 22-2, a file input / output unit 23, an execution control instruction storage unit 24, a command. The input / output unit 25 is provided.

The execution control instruction storage unit 24 stores the execution control instruction description file 3 of the parallel program. The execution control instruction description file 3 is a file for describing an execution control instruction of a parallel program. As will be described later in detail, in this embodiment, for example, the number of the stopped program, the stop position (breakpoint position) of each program, the value of the variable used in the program at the time of stopping at the breakpoint, and the debugger concerned. It is described using the values of internal variables (local variables) held in the controller 2.

The file input / output section 23 is a section for inputting / outputting the execution control instruction description file 3 which is an external file. The instruction interpretation execution unit 21 interprets the contents of the execution control instruction description file 3 and issues a debug command for controlling the parallel program to the sequential debugger 4. Further, the instruction interpretation execution unit 21 performs debug processing while communicating with the command input / output unit 25, the communication unit 22-1, the communication unit 22-2, the file input / output unit 23, and the execution control instruction storage unit 24. Go forward.

The communication unit 22-1 is provided for each sequential debugger 4
This is for assisting communication between the instruction interpreting and executing unit 21. The communication unit 22-2 is for assisting communication between the external process 10 and the instruction interpretation execution unit 21.

The command input / output unit 25 is an input / output interface with a user (8 in the figure). In addition, in FIG.
6 shows a flowchart of processing in the debug controller 2 of this embodiment. However, not all of the instructions in step S6 are essential, and as will be described later, they are appropriately facilitated.

The debug processing of the parallel program of this embodiment will be described below. In the parallel program debugger of the present embodiment, first, the user is the debugger controller 2
Then, the user program 6 is sequentially started from the debugger 4. At this time, the input / output of the sequential debugger 4 is connected to the communication unit 22-1 of the debugger controller 2.

The instruction interpreting / executing unit 21 of the debugger controller 2 waits for a command from the user, and when a command is input, performs processing according to the command and waits for the user's command again.

In the parallel program debugger of this embodiment,
You can switch between conditional execution mode and interactive mode. The conditional execution mode has a conditional execution instruction and a conditional execution continuation instruction. When the conditional execution instruction or the conditional execution continuation instruction is executed, the instruction interpretation execution unit 21 causes the execution control instruction storage unit 24 to execute.
While interpreting the statement stored in the communication unit 22-
1 to send a debug command to each of the sequential debuggers 4 (4-1 to 4-5), to create an internal variable in the debugger controller 2, and to send data to the external process 10 via the communication unit 22-2. Perform processing.

In the interactive mode, the parallel program debugger of this embodiment is provided with an interactive execution instruction and an interactive execution continuation instruction for performing interactive execution. When the interactive execution instruction or the interactive execution continuation instruction is executed, the instruction interpretation execution unit 21 causes the communication unit 22-1 to execute the individual sequential debugger according to the data structure and the value of the variable in the debugger controller 2. (4-1 to 4-
5) Process for sending a debug command to, process for creating an internal variable inside the debugger controller 2, communication unit 22
The process of sending data to the external process 10 through -2 is performed.

Next, the function of the sequential debugger 4 will be described. In this embodiment, each sequential debugger 4 has the functions listed below. The “run command” causes the sequential program 6 to be executed from the beginning.

The "cont command" restarts the execution of the sequential program 6 which has been temporarily stopped. "Print
The "x command" outputs the internal variable of the sequential program 6 that is temporarily stopped.

"Stop at line command"
(Line is a value representing a line number; the same applies hereinafter) sets a breakpoint on the line line of the sequential program 6. When the breakpoint is stopped, the line number of the stopped line is output.

The "ctrl-C command" forcibly suspends the running sequential program 6. Next, the function of the debugger controller 2 will be described.

A flag for identifying the two modes of the conditional execution mode and the interactive mode is provided inside the debugger controller 2. The mode after starting the debugger controller 2 is the interactive mode.

In the interactive mode, the instruction from the user is transmitted to each debugger 4 through the communication unit 22-1. The debugger controller 2 has, for example, the following commands input by the user.

The "select instruction" designates the sequential debugger 4 which transmits an instruction from the user. After startup, all programs are specified "stop at l
The "ine instruction" is an instruction to set a breakpoint on a line line. Every time a breakpoint is set using this instruction, a unique breakpoint number is assigned on the debugger controller 2 side. A correspondence table of these numbers and line numbers (hereinafter referred to as line-breakpoint correspondence table) is created and held by the debugger controller 2.

The "readconditionfile instruction" is
The file is read from the outside into the execution control command storage unit 24. The "crun instruction" shifts the mode to the conditional execution mode, sends the "run instruction" to all the sequential debuggers 4, waits for all the programs 6 to stop at the breakpoint, or finishes, and then to a variable described later. Perform the setting process and set the variable "$ CONTPELIST" to "#
PEALL "is set to interpret and execute the execution control instruction description program stored in the execution control instruction storage unit 24. Here, #PEALL is a variable indicating all programs. If so, it returns to the interactive mode.

"Ccont instruction" is $ CONTPE
Sends a "cont instruction" to the sequential debugger 4 that controls the program 6 registered in LIST, waits for all the programs to stop at the breakpoint, or finishes, and performs the variable setting process described later, and $ CONTP
ELIST is set to #PEALL, and the execution control instruction storage unit 2
The instruction held in 4 is interpreted and executed. When all programs have finished, return to interactive mode.

The "view variable command" is a variable "vari" in the execution control instruction description file.
external process 1 via the communication unit 22-2
Send to 0.

Next, a description method of the execution control instruction description file 3 will be described. In the present embodiment, the execution control instruction description file 3 is described by a program in the C language format, for example.

First, the variables used in the execution control instruction description file 3 and the setting method thereof will be described. Below, $ va
r represents an internal variable. "#PE" is the program number, "#PE: var" is the value of the variable in the #PE program, and "#BP (#PE)" is the position of the breakpoint where the #PE program is stopped. And For example, when the first program stops at the second breakpoint, #BP (1) = 2.

In the variable setting process, the value of #BP (#PE) is set for all programs. This processing is performed from the line number of the stopped breakpoint, which is output to the communication unit 22-1 by the sequential debugger 4 that controls the sequential program 6 when the sequential program 6 is stopped at the line-breakpoint number. Check the breakpoint number using the correspondence table and set its value to #BP (#P
It is realized by setting the value of E). Further, in the variable setting process, the value of "$ PENUM" is set to the number of programs.

#PE in the execution control instruction description file 3:
When var is referenced, “print” is issued to the serial debugger 4 which controls the serial program 6 of #PE.
var command ”and the result is used as #PE: var.

Next, the functions used in the execution control instruction description file 3 and the method of realizing them will be described. Function BP (#
PEi, #PEj ,. ． ． , #PEk) returns the type of BP position at which the program given as an argument is stopped. Here, 1 ≦ # PEi, #PEj, # PEk ≦ n, and n is the number of sequential programs. This is #BP
It can be obtained by checking the value of (#PE) for all program numbers and listing all different types.

Function PE (# BP1, # BP2, ...,
#BPm) returns a list of programs stopped at the BP given as an argument. This is obtained by checking the value of #BP (#PE) for 1 ≦ # PE ≦ n and returning the value of #PE as a result when the result is included in the argument.

Function CONT (#PEi, #PE
j ,. ． ． , #PEk) sends a "cont instruction" through the sequential debugger to the sequential program given as an argument. Function WAIT (#PEi, #PE
j ,. ． ． , #PEk) waits for messages to be returned from the debuggers of all programs given as arguments. After messages are returned from the debuggers of all programs, variable setting processing is performed. If all the programs have ended, the "crun instruction" or "ccont instruction" is ended, and the mode of the debugger controller is returned to the interactive mode.

Now, a procedure for stopping the program under a certain stop condition using each function such as the above-mentioned instruction will be described below. Here, the following conditions are taken as an example of the stop condition. When five programs in FIG. 3 operate at the same time, if breakpoints are set on lines 02 and 04 and individual programs are executed,
Each program will stop at either breakpoint after each while loop. The stop condition is
When this "while loop" is repeatedly stopped once, the program is not stopped unless there are only two programs that are stopped at break point 1, and it is stopped at break point 1. Program is 2
Suppose there is only one. A procedure for realizing the processing of stopping the program only when such a stop condition is satisfied will be described.

First, the user activates the debugger controller 2, and subsequently activates the user program 6 from the debugger 4. Then, select "(PEAL
After selecting all programs with "L) command," st
op at 02 instruction "and" stop at 04
"Instruction" sets breakpoints on lines 02 and 04 of each program. At this time, a breakpoint number of 1 is assigned to the breakpoint on line 02, and a breakpoint number of 2 is assigned to the breakpoint on line 04.

The user creates (or has already created) the execution control instruction description file 3 in which the execution control instructions as shown in FIG. 4 are described. Then, "re
This file is read into the execution control instruction storage unit 24 in the debugger controller 2 by the "addfilefile instruction".

Then, the program 6 is conditionally executed by the "crun instruction". The individual programs 6 as shown in FIG. 3 stop at the break points 1 and 2 respectively depending on the value of y, and return to the debugger controller 2 a message indicating at which line the stop occurred. After receiving a message that a breakpoint has been reached or a message that the program has ended, all programs start interpreting and executing the execution control statement.

In the execution control statement of FIG. 4, $ BP1
NUM is a variable for counting the number of programs stopped at break point 1, and the "for loop" actually counts the number. If the number is 2, "br
The process is returned to the user by "eak instruction", otherwise, all programs are continuously executed again by WAIT (#PEALL), and the stop condition at the breakpoint is determined again.

By the above procedure, the user can stop the program at a desired stop position. After this process,
The user can stop the program again under desired conditions by continuing the operation with the "ccont command".

In this way, it is possible to perform a debugging process in which the program is automatically stopped when a certain condition is satisfied among a plurality of sequential programs. Of course, the present invention can perform not only the debug processing as described above, but also the debug processing of other desired contents in which the operating states of a plurality of sequential programs are associated with each other.

By the way, by facilitating instructions other than the above-mentioned instructions as appropriate, desired debug processing can be realized. Below, the example of various debugging processes is shown. First, an example in which the debug controller 2 has a program stop position and a variable to be referred to at the stop position as a structure according to a user command and is referred to as a control condition when executing a parallel program will be described.

If you want to refer to a variable in another place in the program at another breakpoint, use "probe".
It is sufficient to further provide a “command”. "Probe at l
The "ine x $ x instruction" is an instruction for setting a probe point and can be used in both the interactive mode and the conditional execution mode.

By this instruction, the structure PROBE as shown below is prepared in the parallel program debugger, and the line in the structure has an argument line, the var1 in the structure has an argument x, and the var2 in the structure has an argument $ x. Is set, and a breakpoint is sequentially set on the line line through the debugger 4. The “ucrun instruction” prepared in the debugger controller 2 is a program execution instruction in the interactive mode. This command switches the mode to interactive mode, sends "run command" to all sequential debuggers 4, and sends $ CONTPEL
Substitute #PEALL for IST and wait for all programs 6 to stop or end at breakpoints. If the stop position of a program #PE is the probe point, the debugger controller
A "print x instruction" is issued to the PE, the result is assigned to the variable #PE: $ x, and the program #P is again used.
Give "cont command" to E.

[U] prepared in the debugger controller 2
The "ccont instruction" is a program continuation execution instruction in the interactive mode. This command is $ CONTELIST
The "cont instruction" is sent to the sequential debugger 4 which controls the program of the program number assigned to
Substitute #PEALL in CONTELIST and wait for all programs 6 to stop at breakpoints or end. If the stop position of a program #PE is the probe point, the debugger controller 2
Issues a "print x instruction" to the program #PE and assigns the result to the variable #PE: $ x,
The "cont instruction" is given again to the program #PE.

FIG. 5 is an example of a program in which a value calculated in a certain line is destroyed by an instruction in a subsequent line. In this program, the value of x calculated in line 01 is 03
It is destroyed by the instruction on the line and cannot be referenced on line 04.

Here, in the above program, if the user sets a breakpoint on line 04 and the program stops there, and the value of x calculated on line 01 is referred to, the line 02 Against "probe
An example of applying the “instruction” will be described.

First, the user activates the debugger controller 2, and subsequently activates the user program 6 from the debugger 4. Then, select "(PEAL
After selecting all programs 6 with "L) command," p
The line 02 is set as a probe point by "robe at 02 x $ x instruction", and the breakpoint is set by "stop at 04 instruction". P on the 02nd line indicates that a probe point has been set, and B on the 04th line indicates that a breakpoint has been set.

When the program is executed by the "ucrun instruction", each program is stopped at the 02nd line, the value of x is read out and stored in the value of #PE: $ x. The programs are re-executed and each program is 0
It stops at the breakpoint of 4 and the input request is returned to the user. At this time, the value of the desired variable is stored in the variable #PE: $ x.

In this way, the value of the variable at a certain point in the program can be referred to even after the value of the variable in the program is destroyed by the continuous execution of the program. Next, an example will be described in which a hierarchical relationship of breakpoints is provided as a structure in the debug controller 2 by a user command and is referred to as an execution control condition when executing a parallel program.

Here, in the program shown in FIG. 6, breakpoints are set on lines 04, 06, 09, and 11, respectively, until the end of the convergence loop 3, the convergence loop 2
The following is an example of a case in which the processing of step 1 is not advanced and the processing of the convergence loop 1 is not advanced until the convergence loop 2 ends. The break points on lines 04, 06, 09, and 11 are the break point numbers 1, 2, 3, respectively.
It corresponds to 4.

In this embodiment, the user's first "uc
FIG. 7 shows the position of the breakpoint which is stopped by the repetition of the "run instruction" and the subsequent "uccont instruction".

At the first time, the individual programs stop at the breakpoints of 2, 1, 1, 1, 1 respectively. Two
In the first round, the individual programs are 1, 2, 1,
Stop at a break point of 2,1.

At the third time, programs 2 and 3 are 3
No. 2 and No. 3 programs are not continuously executed until the other programs finish the convergent loop 3 because they are stopped at the breakpoint.

At the fifth time, all the programs reach the break point of 3, so that all the programs are continuously executed at this time, and at the sixth time, the individual programs break at 1, 4, 2, 1, 1 respectively. It will stop at the point.

This processing can be realized by further providing the following "parent instruction" and "gourp instruction". “Parent bp1 bp2 instruction”
Defines a parent-child relationship between breakpoints bp1 and bp2. Two data structures BP as shown below are prepared. The BPnum of one structure has a breakpoint number of bp1 and the BPnum of the other structure has b.
The breakpoint number of p2 is substituted. struct BP {int BPnum; / * break point number * / struct * BP child; / * child break point number * / struct * BP group; / * child break point number * /} This instruction causes bp1 to become BPnum The structure c
A child means a structure having bp2 in BPnum.

"Group bp1 bp2 instruction"
Defines a group relationship between breakpoints bp1 and bp2. Two data structures BP are prepared. The breakpoint number of bp1 is assigned to the BPnum of one structure, and the breakpoint number of bp2 is assigned to the BPnum of the other structure. This command causes bp1
Is a structure with BPnum as BPnum, and bp2 is B
It means the structure of Pnum.

[U] prepared in the debugger controller 2
The "run instruction" is a program execution instruction in the interactive mode. This command switches the mode to interactive mode,
Send "run instruction" to all sequential debuggers and
Substitute #PEALL into NTPELIST and wait for all programs to stop at breakpoints or to end. When the parent-child relationship is set for the breakpoints, the program number stopped at the breakpoint number whose returned breakpoint type is the smallest child is assigned to the internal variable $ CONTELIST.

[U] prepared in the debugger controller 2
The "ccont instruction" is a program continuation execution instruction in the interactive mode. "Uccont command" is $ CON
Send "cont instruction" to the sequential debugger that controls the program with the program number assigned to TPELIST, assign #PEALL to $ CONTELIST, and either all programs stop at the breakpoint or the program ends. Wait for When a parent-child relationship is set for a breakpoint, the program number stopped at the breakpoint number that is the child of the type of the returned breakpoint is the internal variable $ CO.
Substitute in NTPELIST.

In the case of this embodiment, first, the user activates the debugger controller 2 and then successively activates the user program from the debugger. Then, select
After selecting all programs with the "(#PEALL) instruction", "stop at 04, stop at 0
6, stop at 09, stop at 11 instruction ", and set breakpoints at break point numbers 1, 2, 3, and 4, respectively.

Then, "group 1, 2, pare
nt 3,1, parent 4,3 instruction ”, a linked list as shown in FIG. 8 is created inside the debugger controller. Linked list (3 in the figure)
0, 31, 32, 33) includes a breakpoint number (30-1 in the figure), a link to a child (30-2 in the figure), and a link to a group (30-3 in the figure). If there is no link to a child or a link to a group, null is set like 33-2 and 33-3 in the figure.

When the "ucrun instruction" is executed, $ C
#PEALL is set in ONTPELIST, and the position where each program stops is returned to the debugger controller 2. Check the type of breakpoint at this time, and
The breakpoint type of the most child is determined with reference to the linked list of the structures created by the "up instruction" and the "parent instruction". The number of the program stopped at this breakpoint is the internal variable $ CO
Substituted in NTPELIST.

When the "uccont instruction" is executed, $
Cont is sent to the program having the program number assigned to CONTELIST. Then, $ CON
#PEALL is set in TPELIST, and the position where each program stopped after each program stopped is returned to the debugger controller 2. Check the type of breakpoint at this time, and check the "group instruction" and "paren".
The type of the child's breakpoint is determined with reference to the linked list of structures created by the "t instruction".
The number of the program stopped at this breakpoint is assigned to the internal variable $ CONTELIST.

As described above, the execution control condition of the parallel program can be easily set by giving the breakpoints a hierarchical structure. Next, for the debugger controller,
An example of providing a processing interruption instruction and reporting the stop status of each program at the time of interruption will be described.

The user can return control to the user by sending a "ctrl-C instruction" to the debugger controller 2. "Ctrl-C instruction"
Means that the serial debugger 4 of the running program 6 sends "ctrl" to the program 6 through the serial debugger 4.
-C command "is sent and the stop position of the program 6 at that time is received and shown to the user.

Thus, for example, when a deadlock occurs due to a breakpoint and a communication instruction embedded in each program itself, the processing of the debugger controller 2 is interrupted, the user is notified of the stopped state of the program, and a command to the user is issued. Can be resumed.

As described above, when the control of the program causes a deadlock due to an incorrect breakpoint setting or the like, the user interrupts and the situation where the deadlock occurs can be grasped.

(2) Next, the parallel program visualization is executed in which the individual partial programs constituting the parallel program are started from the sequential debugger, and the variable values at the time of program execution are acquired from the individual partial programs through the sequential debugger for visualization. An example of the apparatus will be described.

(Second Embodiment) FIG. 9 shows the configuration of a parallel program visualization device of this embodiment. As shown in the figure, this parallel program visualization device is equipped with a debugger controller 1
02, a plurality of sequential debuggers 104 (104-1 to 104
-N) One or a plurality of display units 107 (107-1)
~ 107-m).

The sequential debugger 104 uses the sequential program 1
It is a debugger for debugging 06. In this embodiment, it is assumed that the sequential debugger 104 is a debugger such as dbx or gdb that operates on unix.

Each sequential debugger 104 is controlled by the debugger controller 102. In this embodiment, in order to make the invention easier to understand, a plurality of user programs 6 to be debugged using the sequential debugger 4 are used.
In (6-1 to 6-5), it is assumed that the data parallel program or all the partial programs are the same program, but of course, the present invention can be applied even when the individual programs are different from each other. The present embodiment can be applied even when there is only one program.

The debugger controller 2 is roughly
The debugger controller 2 sends instructions to the sequential debugger 4 that debugs the individual partial programs that form the parallel program 6, and receives the output from the sequential debugger 4.

The debugger controller 102 of this embodiment
Is provided with a control unit 121, a first communication unit 122-1, a second communication unit 122-2, a user interface 125, a variable acquisition table 131, and a variable storage table 132.

The control unit 121 includes the first communication unit 122-
1, second communication unit 122-2, user interface 1
25, while communicating with the variable acquisition table 131 and the variable storage table 132, the entire system is controlled.
As will be described in detail later, generally, after executing the parallel program, referring to the variable acquisition table 131 as the program progresses, control such as sending an instruction or receiving a variable value to each sequential debugger 4 is performed. I do.

The communication section 122-1 communicates with each sequential debugger 104. The communication unit 122-2 communicates with each display unit 107. The variable acquisition table 131 stores information about acquisition positions of variables and variables to be acquired.
For example, probe points, probe variables, show points, and the like input by the user as described later are stored.

The variable storage table 132 stores the values of the acquired variables. The user interface unit 125 is an input / output interface with a user (108 in the figure).

The debugger controller 2 is provided with one or a plurality of display sections 107 (107-1 to 107-m). The display unit 107 is a device for visualization based on the values of one or more variables (called template variables). For example, when the program 6 reaches the show point, visualization is performed on the display unit 107 selected by the user in advance.

Each display unit 107 includes a communication unit 140 and a visualization processing unit 141. The communication unit 140 communicates with the debugger controller 2. Visualization processing unit 141
Is a template variable description part 142, an expression interpretation part 143,
The drawing unit 144 is included.

The template variable description section 142 describes the variables in the program corresponding to each template variable, and the expressions combining them. For example, probe variables, program numbers, breakpoint numbers, and expressions combining these can be described.

In the display unit 107, the description written in the template variable description unit 142 is interpreted by the expression interpretation unit 143, and the drawing unit 144 draws. Next, an outline of the operation of the parallel program visualization device of this embodiment will be shown.

First, the user selects the debugger controller 10
2 is started, and then the sequential debuggers 104-1 to 104-
The user programs 106-1 to 106-n are activated from above. At this time, the input / output of the sequential debugger 104 is connected to the communication unit 122-1 of the debugger controller 102.

The user operates the user interface unit 12
5, the variable acquisition position (probe point), the variable name (probe variable), and the visualization position (show point) are input, and the control unit 121 stores the information in the variable acquisition table 131.

The control unit 121 sets a break point for each of the sequential programs 106-1 to 106-n based on the contents of the variable acquisition table. After executing the parallel program, the control unit 121 refers to the values in the variable acquisition table 131 and, depending on the position where each program 106 stops,
A continuation instruction and an instruction for variable acquisition are sent to each serial debugger 104. The acquired variables are stored in the variable storage table 132.

The display unit 107 to be used is selected by the user's display unit selection command. When the display unit 107 is selected, the user is requested to input the template variable description unit 142. When the program reaches the show point, visualization is performed using the selected display unit 107.

In the display unit 107, from the communication unit 122-2 of the debugger controller 102 to the communication unit 1 of the display unit 107.
The drawing unit 144 draws while receiving the values of necessary variables via 40 and interpreting the description written in the template variable description unit 142 by the expression interpretation unit 143.

Hereinafter, this embodiment will be described in more detail. The debugger controller 102
It has a “view command” for selecting the display unit 107 used for visualization, a “probe command” for designating a probe variable or a probe point, and a “show at command” for designating a show point. In addition, the debugger controller 102
It has a command and a cont command. The "run instruction" is transmitted to the debugger 104 in sequence and the program 10
6 is executed. The "cont instruction" is transmitted to the debugger 104 and the program 106 is continuously executed.

The "view instruction" takes the number of the display unit 107 as an argument. It is assumed that the display unit 107 is numbered in advance. When the "view command" is executed, a window for inputting information regarding variables necessary for visualization opens.

FIG. 10 shows a display unit 1 for displaying two-dimensional points.
07 is an example. The position of the point is represented by (X, Y).
These X and Y are called template variables. Enter which template variable corresponds to which variable in the user program. In the table of X =, Y = in FIG. 10, x and y (185 and 186 in the figure) are respectively written, so that the values of variables x and y are acquired from the program and the two-dimensional X and Y are obtained. It shows plotting on the axis. Vertical and horizontal scroll bars (201, 201,
200) is attached, and the screen can be scrolled. X
See 20 and 20 (1 in the figure) for max and Ymax respectively.
83, 184) is input to set the display magnification on the screen. Instead of this input, expand,
A reduction button may be provided.

The "probe instruction" takes a row number and a variable column as arguments. When this instruction is executed, a breakpoint is set at the line number given as an argument. The line corresponding to this line number is called a probe point. A list of variables to be acquired is registered in the variable acquisition table 131 in the format of a line number, a flag P indicating a probe point, and a variable list. For example, x and y in the 10th row
To get the variable "probe 10 x
When the “y instruction” is executed, the elements as shown in FIG. 11 are registered in the variable acquisition table 131.

When the programs 106-1 to 106-n are executed and the program reaches the probe point,
The debugger controller 102 is used for each sequential debugger 1
An instruction to acquire the value of the variable registered in the variable acquisition table 131 is issued to 04-1 to 104-n. Specifically, when acquiring the value of the variable x, the "print x command" is issued to the sequential debugger 104. The debugger controller 102 stores this result in the variable storage table 132. At this time, the number of the program that acquired the variable and the line number of the probe point are added to the variables to be stored. For example, when the values of variables x and y are acquired from the programs of processor numbers 0 to 4 at the probe points on the 10th row, the variable storage table 132 as shown in FIG. 12 is created. After this, the debugger controller 102 determines that each serial debugger 104-1
The "cont instruction" is sent to 104-n to continuously execute the program.

The "show at instruction" takes a line number as an argument. When this instruction is executed, a breakpoint is set at the line number given as an argument. The line corresponding to this line number will be called a show point. The line number and flag S indicating the show point are stored in the variable acquisition table. For example, when the “show at 11 instruction” with the 11th row as the show point is executed, the values shown in FIG. 13 are registered in the variable acquisition table 131.

The debugger controller 102 waits until all the partial programs reach the show point or the program ends after the user executes the "run instruction" or the "cont instruction".

When all the partial programs reach or end the show point, the user passes the data for visualization to the display unit 107 selected in advance and instructs the display unit 107 to perform visualization.

In the same line, "probe instruction" and "sho
If "w at command" is set, "probe
The process performed on the "command" is prioritized, and the process performed on the "show at command" is executed without continuously executing the program.

Now, the display section 107 for two-dimensional display is designated by the "view command", and the template variables X and Y thereof are designated.
And xmax and Ymax are 20, respectively, and a "probe instruction" is used as the 10th line probe point of a parallel program (provided that all the partial programs constituting the parallel program are the same). , Y are set, a show point is set on the 11th line, and the program is executed by the "run instruction", the program stops at the 11th line, and FIG.
You will get a table like. The content of the variable is displayed on the display unit 107.
Sent to. Further, the debugger controller 102
Sends a command to the display unit 107 to perform visualization. The display unit 107 receives this data and command, interprets the contents described in the template variable description unit 142, and
Display 4 is performed by using the drawing unit 144.

Note that it is possible to facilitate the display unit 107 that performs three-dimensional display, and select it to perform three-dimensional display. As described above, according to this embodiment, the variable is acquired through the debugger and the drawing is performed on the display unit.
The behavior of the program can be visualized without changing the program to be debugged. Moreover, since the probe variable, the program number, the breakpoint number, and the expression combining them can be entered in the template variable description part, visualization from a wide range of viewpoints is possible.

Here, PE numbers and break point numbers may be written as template variables.
#PE and #BP (187 and 188 in the figure) are respectively
It is a variable that indicates the program number and breakpoint number. As a result, as shown in FIG. 15, it is possible to display which program stops at which breakpoint.

Further, when describing the correspondence of template variables, an expression may be written on the right side. In this case, the above-described expression interpreting unit is provided in the debug controller 102 so that the value of the expression can be calculated. As a result, as shown in FIG. 16, the X axis is x and the Y axis is x +.
You can write a graph like y.

As described above, according to the present embodiment, it is possible to easily visualize a parallel program without changing the parallel program by embedding a function for visualization in the parallel program.

(Third Embodiment) FIG. 17 shows the configuration of a parallel program visualization device of this embodiment. This embodiment is different from the debug controller 10 in the configuration of the second embodiment.
2 has a simplified language processing unit 160 added inside.

The simple language processing section 160 comprises a simple language storage section 161, a simple language interpretation execution section 162, and a simple language variable storage section 163. The simple language storage unit 161 is for describing a simple language executed when each partial program arrives at a specific line. The simple language interpretation execution unit 162 is for interpreting and executing a simple language. The simplified language variable storage unit 163 is for storing the values of variables used during execution of the simplified language.

The outline of the operation of the parallel program visualization device of this embodiment is shown below. First, the user activates the debugger controller 102, and then the sequential debugger 104-1.
From 104-n, user programs 106-1 to 10-10
Start 6-n. At this time, the input / output of the sequential debugger 104 is the communication unit 122-1 of the debugger controller 102.
Connect with.

The user operates the user interface unit 12
5, the variable acquisition position (probe point), the variable name (probe variable), the visualization position (show point), and the simple language execution position (simple language execution point) are input. The information is stored in the variable acquisition table 131.

The control unit 121 sets a break point for each of the sequential programs 106-1 to 106-n based on the contents of the variable acquisition table. After executing the parallel program, the control unit 121 refers to the values in the variable acquisition table 131 and, depending on the position where each program 106 stops,
A continuation instruction and an instruction for variable acquisition are sent to each serial debugger 104. The acquired variables are stored in the variable storage table 132.

When the program reaches the simple language execution position, the simple language is executed. The simple language is interpreted and executed by the simple language processing unit 160. The display unit 107 to be used is selected by the user's display unit selection command. When the display unit 107 is selected, the template variable description unit 14
Input request for 2 is made to the user. When the program reaches the show point, visualization is performed using the selected display unit 107.

In the display unit 107, from the communication unit 122-2 of the debugger controller 102 to the communication unit 1 of the display unit 107.
The drawing unit 144 draws while receiving the values of necessary variables via 40 and interpreting the description written in the template variable description unit 142 by the expression interpretation unit 143.

The present embodiment will be described in more detail below. In this embodiment, the user can write a simple language. This simple language uses "prob" as an external variable.
The variable acquired by the "e command" can be used. Prepare a "user command" that determines the position to activate the simple language. The "probe instruction" has priority over the "user instruction", and the "user instruction" has priority over the "show at instruction".

The "show instruction" used in the simple language gives the data necessary for visualization to the display unit 107 from the simple language, and
7 is an instruction to instruct the display to be performed.

For example, assume that a simple language is described as shown in FIG. In this example, the 01st line declares that the probe variables x and y are used, and the 02nd visualization tool performs visualization at 02.

If the second visualization tool is a two-dimensional drawing tool and X = oldx-x and Y = oldy-y,
As shown in FIG. 19, the direction in which x and y have moved can be displayed. As described above, according to this embodiment, it is possible to perform flexible visualization using past values of variables that cannot be seen because they have already been updated by the user program.

There may be a plurality of simple languages and simple language starting positions. (Fourth Embodiment) FIG. 20 shows the configuration of the display unit 207 of the parallel program visualization device of this embodiment. In this embodiment,
In the configuration of the first or second embodiment, a user event handler 210, a graphic data storage unit 211, and a processor map display unit 212 are added inside the display unit 107.

The figure data storage unit 211 stores the coordinates of the visualized figure on the screen, the number of the program that acquired the data for drawing the figure, and the position in the program. The processor map display unit 212 displays a processor map in which program numbers are arranged in a two-dimensional table.

In the present embodiment, when the user clicks on specific graphic data on the visualized screen with the mouse, the user event handler 210 determines the user from the clicked position of the mouse and the contents of the graphic data storage unit 211. The number of the program that acquired the data for drawing the clicked figure is acquired, and the display of the program number on the processor map is reversed.

When a point is drawn on the display unit 107 for two-dimensional display, the coordinates of the point on the screen, that is, the relative coordinates (x, y) of the point in the two-dimensional display, and the processor that has acquired these variables x, y Number, probe point position, and show point position are stored in association with each other.

FIG. 14 is a screen in which five points are drawn. For each point, the graphic data storage unit 211
21 holds the data as shown in FIG. The figure number is a unique number given to the displayed figure.
eX and mouseY are positions on the screen, x and y are relative coordinates in the two-dimensional display by the display unit 107,
The processor number is the number of the processor whose variable was calculated, and the show point shows the show point at which the display was made.

When the user clicks on a point on the screen,
The user event handler 210 detects the clicked coordinates of the mouse, and the mouse of the graphic data storage unit 211
The one that matches the values of eX and mouseY is searched for and the figure number is obtained. The processor number of the figure number is acquired from the table, and the program number is sent to the processor map display unit 212. The processor map display unit 212 inverts the processor number of the sent number, as shown in FIG. 22, for example.

In this way, information suitable for the user can be obtained from the visualization screen. A process for displaying the source file is provided in place of the processor map display unit 212, and the probe point where the variable is acquired is stored in the variable list of the graphic data storage unit 211, so that the displayed point can be displayed with the mouse. When clicked, the function of inverting the row of probe points from which the data to draw that point was obtained is obtained. Further, the present invention is not limited to the above-described embodiments, and various modifications can be carried out without departing from the scope of the invention.

[0139]

【The invention's effect】

(1) In the present invention, a description of desired debug contents for a parallel program is externally given to a debugger controller, and the debugger controller gives an instruction to each debugger according to the interpretation result of this description to control the parallel program and obtain the execution control result. In addition, since instructions are given based on the execution control results of each acquired sequential program, the operating states of a plurality of sequential programs are associated with each other, and the desired debug such as execution control of the sequential programs and acquisition of variable values is performed. It can be performed.

For example, it is possible to automatically stop the program when a certain condition is satisfied among a plurality of sequential programs. (2) In the present invention, a variable to be sequentially acquired from each debugger and a position in a sequential program for acquiring the variable can be set in advance in the debugger controller, and the variable to be displayed and the variable to be displayed in the display means. A display expression defining a function using a variable can be set in advance, and the display means displays the value of the variable given from the debugger controller according to this display expression. Therefore, the function for visualization is displayed in the parallel program. The parallel program can be easily visualized without changing the parallel program by, for example, embedding it in the program.

[Brief description of drawings]

FIG. 1 is a diagram showing a configuration of a parallel program debugger according to a first embodiment of the present invention.

FIG. 2 is a flowchart showing a procedure of processing in the debug controller.

FIG. 3 is a diagram showing an example of a program in which two breakpoints are set.

FIG. 4 is a diagram showing an example of an execution control instruction description file.

FIG. 5 is a diagram showing an example of a program in which a variable is destroyed by a later instruction.

FIG. 6 is a diagram showing an example of a program having three convergence loops.

FIG. 7 is a diagram showing a stop situation at a breakpoint of five programs.

FIG. 8 is a diagram showing an example of a data structure held in the debug controller.

FIG. 9 is a diagram showing a configuration of a parallel program visualization device according to a second embodiment of the present invention.

FIG. 10 is a diagram showing an example of a display unit that performs two-dimensional display.

FIG. 11 is a diagram showing contents stored in a variable acquisition table when registering probe points.

FIG. 12 is a diagram showing an example of a variable storage table.

FIG. 13 is a diagram showing contents stored in a variable acquisition table when registering show points.

FIG. 14 is a diagram showing a drawing example of a two-dimensional graph.

FIG. 15 is a diagram showing a display example of a graph of processor numbers and breakpoints.

FIG. 16 is a diagram showing an example in which an expression is written in a template variable.

FIG. 17 is a diagram showing a configuration of a parallel program visualization device according to a third exemplary embodiment of the present invention.

FIG. 18 is a diagram showing a description example of a simple language.

FIG. 19 is a diagram showing an example of displaying using past values of variables.

FIG. 20 is a diagram showing the configuration of a parallel program visualization device according to a fourth embodiment of the present invention.

FIG. 21 is a diagram for explaining a storage method of graphic data on the display unit.

FIG. 22 is a diagram showing an example of displaying processor numbers related to graphics on the display unit.

[Explanation of symbols]

2 ... Debugger controller, 3 ... Execution control instruction description file, 4, 4-1 to 4-5 ... Sequential debugger, 6, 6-1
6-5 ... User program, 8 ... User, 10 ... External process, 21 ... Instruction interpretation execution unit, 22-1 ... First communication unit, 22-2 ... Second communication unit, 23 ... File input / output Section, 24 ... Execution control instruction storage section, 25 ... Command input / output section, 102 ... Debugger controller, 104, 104
-1 to 104-n ... Sequential debugger, 106, 106-1
~ 106-n ... User program, 107, 107-1
-107-n ... Display part, 108 ... User, 121 ... Control part, 122-1 ... 1st communication part, 122-2 ... 2nd communication part, 125 ... User interface, 131 ... Variable acquisition table, 132 ... Variable storage table, 140 ... Communication unit, 141 ...
Visualization processing unit, 142 ... Template variable description unit, 14
3 ... Expression interpreting section, 144 ... Drawing section, 160 ... Simple language processing section, 161 ... Simple language storage section, 162 ... Simple language interpretation executing section, 163 ... Simple language variable storage section, 207 ... Display section,
210 ... User event handler, 211 ... Graphic data storage section, 212 ... Processor map display section

Claims (4)

[Claims] 1. A parallel program debugging method in which a debugger controller controls each of a plurality of sequential debuggers provided in a one-to-one correspondence with a plurality of sequential programs constituting a parallel program to debug the parallel program, The debugger controller interprets the description of the debug content for the parallel program given from the outside, gives an instruction to each of the debuggers according to the interpretation result to control the execution of the parallel program, and the execution control result from each of the debuggers. Based on these execution control results, further giving instructions to each of the debuggers to control the execution of the parallel program, and performing the procedure of acquiring execution control results from each of the debuggers at least once, Output the debug result generated according to the control result to the outside. Parallel program debugging method comprising and. 2. A plurality of serial debuggers provided in a one-to-one correspondence with a plurality of serial programs constituting a parallel program, and a debugger controller for controlling each of the plurality of serial debuggers to debug the parallel program. ,
In a parallel program visualization device comprising at least one display means for displaying a debug result in accordance with an instruction from the debugger controller, the debugger controller comprises at least one variable to be acquired and the serially acquiring the variable. A means for storing variable acquisition information including a position in a program, and giving an instruction to each of the sequential debuggers to control execution of the parallel program, and based on the variable acquisition information, a value of the variable from each of the sequential debuggers. And a means for giving the value of the variable to the designated display means at a predetermined timing, wherein the display means displays at least one of the variables for displaying a debug result. Means for storing the display formula created by using the And a means for displaying the value of the variable based on the display formula, the parallel program visualization device. 3. The debugger controller stores a simple language for processing at least one of the values of the variables, and the sequential controller acquires the sequential language from each of the debuggers at a predetermined timing according to the simple language. The parallel program visualization device according to claim 2, further comprising means for processing the value of the variable. 4. The display means associates and stores the coordinates of a graphic displayed on a display screen with the number of the sequential program that has acquired the variable for displaying the graphic; A means for displaying a processor map in which numbers are arranged; and, when a specific figure on the screen is designated by a predetermined pointing device, from the coordinates of the designated figure and the contents stored in the storing means, A means for obtaining the number of the sequential program that has acquired the variable for displaying the instructed figure and changing the display of the obtained number among the numbers on the processor map. The parallel program visualization device according to claim 2.