JPH01181132A - Debugging system - Google Patents

Abstract

PURPOSE:To facilitate the debugging jobs by adding a debug flag to a message and securing succession of the debug flag in accordance with the flow of the message. CONSTITUTION:When the debug flag of a message which is transmitted to a process B from a process A is set at '1', the process B receives only the single input message and therefore carries out a debugging program of a 1st type. When this process is through, the process B carries out a debugging program of a 4th type since the debugging flag is kept at '1'. In the same way, the processes D and E carry out the debugging programs of the 1st and 4th types. A process G receives the double input message and therefore carries out the debugging programs of the 2nd and 3rd types at reception of the messages from processes D and E. At the same time, the process G also carries out a debugging program of a 5th type due to the absence of a transmission message.

Description

DETAILED DESCRIPTION OF THE INVENTION [Object of the Invention] (Industrial Application Field) The present invention relates to a debugging method in a processing system in which processing proceeds while exchanging messages between a plurality of processes.

(Prior Art) In general, program debugging involves step-executing the program, setting breakpoints, and tracing the program's behavior at suspicious locations where a bug is likely to exist. The basic thing is to investigate. Such debugging is a very effective method when debugging a program consisting of a single process in which suspicious parts can be easily identified.

However, in a system in which processing proceeds while communicating messages between a plurality of processes, there is a problem in that debugging is extremely difficult because it is difficult to identify suspicious areas.

This difficulty is due to the complexity of message flow. For example, as shown in FIG.
, in a system configured by L and in which messages are transmitted in the direction shown by the arrow, suppose that there is an error in the processing of process J, and a wrong message is sent from process J to process K. However, if process J sends a correct message to process L, process L will output a correct result, and the process will output an incorrect result. Judging from these results alone, it is easy to assume that there was an error in process I or process K.

(Problem to be Solved by the Invention) As described above, in the conventional debugging method, when debugging a processing system that exchanges messages between multiple processes, the message flow of the system is complex, so errors may occur. There was a problem in that it was difficult to find the process and a great deal of effort was required for debugging.

The present invention has been made in view of these problems, and is a debugging method that allows easy debugging even if the message flow is complex in a system where processing proceeds while exchanging messages between multiple processes. The purpose is to provide

[Configuration of the Invention (Means for Solving the Problem) The present invention provides a debugging method for debugging a processing system in which processing proceeds while exchanging messages between a plurality of processes. At the same time, each process executes debug processing according to the value of the debug flag added to the input message, and the message flowing between the processes transfers the value of the debug flag from the upper process to the lower process. It is characterized by the fact that it is something that can be passed down from generation to generation.

(Operation) According to the present invention, a debug flag is added to a message, and this debug flag is inherited according to the flow of the message. Then, each process executes debug processing according to the value of the debug flag of the input message. Therefore, it is possible to automatically determine which process a message output from a certain higher-level process passed through, and which process an error occurred in, making it easy to debug even systems with complex message flows. can be done.

(Example) An embodiment of the present invention will be described below.

FIG. 2 is a diagram showing the system configuration of a parallel processing system that performs processing in parallel while communicating messages between a plurality of processes. This system includes a plurality of processors 11a+11b, . . .

11n are interconnected via a coupling network 12.

Each process executed on this system does not necessarily have a one-to-one correspondence with these multiple processors lla to lln; for example, even if one process is executed by multiple processors, good. FIG. 3 shows the format of messages exchanged between each process. That is, the message has a header 21
and a message body 22, and the header 21 includes a debug flag 2 in addition to the message sending address.
3 is added. This debug flag 23 is a flag indicating whether or not debug processing is to be performed in each process, and its value is set to "1" when debugging is to be performed in the process that gave the message.

FIG. 1 shows the processing in each process.

Each process is provided with five types of debugging programs, types 1 to 5. These debugging programs are designed to handle input messages, output results, tasks activated by input messages, and
Performs processing to trace information such as important variable values of the process.

Next, the operation of each process will be explained.

First, a program starts when the parent process sends a message asking it to start. It is assumed that the device leg flag of the message for this activation is also set. Initially, the process waits for the arrival of a message (sl). When the process receives a message, it determines whether it is a human message or a multi-input message (S2). If the received message is a one-person message, the debug flag is subsequently referred to (S3). Debug flag is “1”
”, execute the first type debug program (S
4). Here, for example, tasks activated by human messages, input messages, etc. are traced.

If the message you received is a multi-input message,
If the debug flag of the message is "1" (S5), the second type of debug program is executed (S6). Here, for example, an input message is traced.

If the required multi-input message is not yet available even after the message arrives, the process returns to the message waiting state (S7). Once all the messages have been collected, if the OR result or AND result (which one to use is specified in the program) of the debug flags of these multi-input messages is "1" (S8), then the third type The debugging program is executed (S9). That is, here, if debugging is requested for any one of the multi-input messages, each process is set to perform debug processing, or a debug request is made for all of the multi-input messages. If debugging is not performed, it is decided whether to use the OR result of the debug flags or the AND result, and this is given in advance as a program for each process. In the third type of debugging program, tasks activated by a plurality of messages are traced.

Thereafter, the process processes the received message (S10), and if there is a sent message (S11), it determines the value of the debug flag to be added to the sent message (S12). Here, when the debug flag of the input message is "1", the debug flag of the transmitted message is also set to "1". This inherits the debug flags in messages to the next process. Then, send a message (313),
If the debug flag given to the message is "1" (S14), the fourth type of debug program is executed (S15). Here, for example, a transmitted message is traced.

After this, the process returns to the message waiting (Sl) state.

On the other hand, if there is no transmitted message (S11), if the received message is a one-person message and its debug flag is "1", or if the received message is a multi-input message and the result of the logical sum or logical product of those debug flags is If the result (which one to use is specified in the program) is “1°” (S16)
To do this, run the fifth type of debugging program (S
17). After this, the process returns to waiting for a message (Sl).
−Please note that the debug flag of the input message is “0”.
”, no debugging programs are executed, normal message processing is performed, and the results are output as messages as necessary.

By performing such processing, each process can be debugged along the message flow according to the debug flag of the message.

This situation will be explained in detail based on the example shown in Figure 4.
First, if you set the debug flag of the message sent from process A to process B to "1", process B will:
- In order to receive only human messages, the first type debugging program is executed as shown in FIG. 184. Also, when the process is finished, the debug flag is “1”, so
Execute the fourth type of debugging program. Similarly, processes D and E also execute the first and fourth types of debugging programs. Furthermore, process G receives the two-person message, so process G receives the two-person message in FIG. 36. According to S9, when the message from E is received, the second and third types of debugging programs are executed.

Furthermore, since process G has no message to send (there is no output message corresponding to the input message), it executes the fifth type of debugging program.

During this time, the processes B, D, E, and G execute the first to fifth types of debugging programs, so that traces of important variable values and the like between the processes can be obtained. Therefore, it becomes easy to determine how the message was passed from process A to process G, and which process had an abnormality.

In the past, in systems where multiple processes communicated messages, debugging was generally difficult because it was difficult to understand the flow of messages. By providing a flag and debugging each process according to the value of the debug flag, the system can automatically track the flow of messages and debug only necessary processes. Therefore, the difficulty of debugging is reduced.

Note that the present invention is not limited to the above embodiments. For example, in the above embodiment, five types of debugging programs are provided for each process, but this is just an example, and the number and type of debugging programs can be changed as necessary.

Further, in the above embodiment, an example was shown in which multiple processes are processed in parallel, but the present invention uses one processor to execute multiple processes sequentially, and messages are exchanged between each process. It is also applicable to systems where

[Effects of the Invention] As described above, according to the present invention, even in a system where processing proceeds while exchanging messages between multiple processes, the flow of messages can be easily grasped, and errors can be detected in which process. This has the effect of greatly simplifying debugging work because it can be determined whether or not a problem has occurred.

[Brief explanation of the drawing]

Fig. 1 is a flowchart showing the processing contents of a process to which a debugging method according to an embodiment of the present invention is applied, Fig. 2 is a block diagram of a parallel processing system to which the same embodiment is applied, and Fig. 3 is a message diagram in the system. FIG. 4 is a diagram showing the format, FIG. 4 is a diagram showing the flow of messages between processes in the same embodiment, and FIG. 5 is a diagram for explaining conventional problems. 11a-lln...processor, 12...coupling network, 21...header, 22...message body, 23...debug flag. Applicant's agent Patent attorney Takehiko Suzue Figure 2 vi3 Figure 4

Claims (2)

[Claims] (1) In a debugging method for debugging a processing system that proceeds with processing while exchanging messages between multiple processes, a debug flag is added to the message, and each process has a debug flag added to the input message. A debugging method characterized in that debugging processing is executed according to the value of the debugging flag, and the message flowing between the processes inherits the value of the debugging flag from a higher-level process to a lower-level process. . (2) If each process outputs a message as a result of processing the input message,
2. The debugging method according to claim 1, wherein the value of the debugging flag of the output message is determined according to the value of the debugging flag added to the input message.