JP3075359B2 - Program debugging start processing method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Summary] The present invention relates to a program debugging start processing method in an information processing apparatus in which a plurality of users can simultaneously operate a program in parallel. Means for inputting a user identification symbol and a program name relating to a program to be debugged in a debugger program, without having to be aware of processes and processes, A means for notifying the management program of the symbol and the program name, and holding the user identification symbol and the program name notified in the management program, and each time a program is loaded, the user identification symbol and the program name are stored. Means for determining whether or not the And a means for making the loaded program stand by in a state immediately before the start of execution and notifying the debugger program.

[Industrial applications]

The present invention relates to a program debugging start processing method in an information processing apparatus in which a plurality of users can simultaneously operate a program.

[Conventional technology]

The created program does not always output the expected result and may end abnormally, so it is necessary to investigate the cause and correct the program. That is, it is necessary to debug the program.

One way to do this is to specify one or more of the instructions in the program to be debugged as so-called breakpoints, stop the CPU when it tries to execute any of those instructions, and then make each variable A method such as checking whether the value is the expected value is used.

Normally, at the time of debugging, a program called a debugger program is simultaneously operating in the system in addition to the program to be debugged. The debugger program is
Conversation with the user through the keyboard display device, stop and restart the program to be debugged, read and write variables of the program to be debugged, and set and release breakpoints according to the user's instructions. Controls the operation of the program to be debugged.

During the operation of the debugged program, the debugger program is normally in a waiting state, and when an event (for example, execution of a breakpoint) occurs in the debugged program, an interrupt or a service function call of a management program (also referred to as an OS) is performed. At the same time, the management program changes the program to be debugged to the waiting state, and changes the debugger program that has been in the waiting state to the operating state. Thus, the debugged program and the debugger program operate alternately.

By the way, many of today's information processing devices take a form in which a plurality of users simultaneously and independently execute programs from a plurality of keyboard display devices.

In the system, one or a plurality of tasks are usually generated for each program execution unit. When a task is created, certain management information is created in an area in a management program (OS), and a certain area is given on main memory. Then, the program is loaded into the area, and the execution of the program is started. The management program assigns a CP to each task
U The execution of each program proceeds by assigning the execution right.

The relationship between the task of the debugger program and the task of the debugged program differs depending on the management program. In a certain management program, a task of a debugger program generates a task to be debugged, and has a function of loading and executing the program to be debugged there.
In this case, the debug process can be started by stopping the task to be debugged at the start of the program to be debugged and notifying the task that generated the task.

However, in a management program that does not have such a processing function, the task of the debugger program and the task to be debugged are initially unrelated, so after detecting the point in time at which the program to be debugged starts in the system, It is necessary to perform a process of connecting and starting alternate operations.

Only one debugged program running in the system
In the case of two, the program name had to be specified. However, a program having the same name may be executed in an information processing apparatus that can be used independently and in parallel by a plurality of users. For this reason, it is practically impossible to specify the debug start by the program name.

Another method is to specify a task to execute the program to be debugged, but this makes the specification method difficult. This is because a general user cannot specify a task number in advance, and it is difficult to identify a target task from a list of tasks.

In the management program of the second type, since the job in which the debugger program operates and the job of the program to be debugged are initially independent, a task is generated under one job in the program to be debugged. Above, the initialization processing of the job is executed. Among them, several programs in the management program are executed in order to create execution environment information of the task, and finally, the program to be debugged is started.

The running of the program before the start of the debugged program is meaningless to a normal user for debugging. Therefore, if debugging starts from the beginning of the processing of a task generated under the job of the debugged program, the user uses the interactive function of the debugger program to proceed until the program to be debugged is loaded. Needed.

Further, a plurality of tasks may be generated under a user's job. For example, one task is created first, and the initialization process of the management program starts, and another task (or a process that is a small execution unit similar to a task without a specific memory area) is created from it. In such a case, the loading process of the program to be debugged may be executed. The procedure division of the program used at this time is usually already in the management program.

In such a case, it is more difficult to reach the starting point because it is not known which task or process should be tracked before the debugged program starts.

[Problems to be solved by the invention]

SUMMARY OF THE INVENTION The present invention solves the above problems, and allows a user to be aware of a system program that runs before the start of a debugged program and tasks and processes generated under a user job that are not related to the debugged program. ,
The purpose is to be able to start debugging the program immediately.

[Means for solving the problem]

 FIG. 1 shows a configuration example of the present invention.

In FIG. 1, reference numeral 10 denotes an information processing device including a CPU and a memory, reference numeral 11 denotes a management program called an operating system (OS), reference numeral 12 denotes a program start control unit for controlling start of a program, and reference numeral 13 denotes a program to be debugged detection unit. , 14 is a debug-designated information management unit, 15 is a debug start management table for managing information of a debug target program to be debugged, 16 is a notification unit for notifying information of a debug target program, 17 is a debugger program, and 18 is a use. The user identification code and program name input section 19 is used to manage the user identification code and program name of the program to be debugged.
, A debug conversation processing unit for performing debugging while conversing with the user, 21 a debugged program to be debugged, 22-1 and 22-2 a task area, 23
Reference numerals -1, 23-2 denote task control blocks (TCBs) for storing task management information; 24, an input device such as a keyboard display device; and 25, a program storage device such as a secondary storage device for storing programs.

When a user operates a certain program, the user inputs a user identification symbol (hereinafter, referred to as a user ID) in advance, and then inputs a program name to be operated.

In this system, the debugger program 17 and the debugged program 21 are started independently. Therefore,
The debugger program 17 needs to know the debugged program 21 to be debugged. Therefore, the following means are provided.

The user identification code / program name input unit 18 inputs the user ID and the program name of the program 21 to be debugged from the input device 24 via the management program 11.

The notifying unit 19 sends the debugged program to the debug target designated information management unit 14 of the management program 11.
Notify 21 user IDs and program names.

The debugged specified information management unit 14 sends the notified user ID
And the program name is entered and stored in the debug start management table 15.

When a user requests to start the debugged program 21, the program start control unit 12 in the management program 11
When the debugged program 21 is loaded, the debugged program detection unit 13 executes
15, it is determined whether the user ID and the program name of the program to be loaded match the user ID and the program name stored in the debugging start management table 15.

When both the user ID and the program name match, the management program 11 causes the loaded debugged program 21 to wait in a state immediately before the start of execution, and notifies the information about the task of the debugged program 21 by the notifying unit 16.
Notify the debugger program 17.

The debug conversation processing unit 20 of the debugger program 17 recognizes the program 21 to be debugged based on the notified information, and executes the program to be debugged by conversation processing with the user.
Perform debug control for 21.

[Action]

The present invention utilizes that a user of a system always enters a user ID when starting to use the system. For example, when a user ID is entered by a logon command declaring the start of use, the system checks whether there is already a user with the same user ID, and if so, uses it later. Prohibit the use of persons. Therefore, by combining the user ID and the program name, the program can be uniquely identified in the system. By using this to specify the debugged program 21, the management program
The debugger program 17 starts debugging the program 21 to be debugged in cooperation with the program 11.

Therefore, the user starts the debugger program 17 first. With this activation, the task area 22-1 is secured, the task control block 23-1 is generated, and the task of the debugger program 17 operates. In this debugger program 17, the user will
Enter the user ID and program name to be used when starting 21.

The debugger program 17 sends the debugged program 21 to the management program 11 under the user ID.
Ask your task to be notified when is loaded or dynamically linked. Then, the management program
Enter wait state using 11 service functions.

Each time a program is loaded in the system, the management program 11 checks the user ID and the program name. If the user ID and the program name match with the one notified by the debugger program 17, the management program 11 completes the loading. Then, the task is stopped and the debugger program 17 in the waiting state is notified. At this time, the address of the management information of the task control block 23-2 of the debugged program 21 is notified. The debugger program 17
Starts debugging of the program 21 to be debugged. Thereafter, the debugger program 17 designates the management information address and requests the setting of a breakpoint of the program to be debugged 21, the restart, the reading and writing of data, and the like.

〔Example〕

FIG. 2 is a flowchart of a debug start process according to the embodiment of the present invention, FIG. 3 is a debugger program process flow according to the embodiment of the present invention, FIG. 4 is a debug conversation process flow according to the embodiment of the present invention, FIG. 5 is a configuration example of a debug start management table according to the embodiment of the present invention, FIG. 6 is a configuration example of a task control block according to the embodiment of the present invention, and FIG. 7 is a user program according to the embodiment of the present invention. 3 shows a processing flow of the start processing of the processing.

The overall flow of the debugging start process with the configuration shown in FIG. 1 will be described with reference to FIGS.

The debugger program 17 is started by specifying a user ID and issuing a logon command, followed by specifying a program name and issuing a start command in the same manner as a normal user program is started. Do. Alternatively, the debugger program 17 is started by a job control statement or the like. The program name of the debugger program 17 is specified as the execution program name.

When the debugger program 17 is started by the management program 11, the debugger program 17 inputs a user ID specified when starting the debugged program 21 to be debugged by conversation processing. here,
It is assumed that C has been input as the user ID. Note that the user ID of C is different from the user ID of the debugger program 17.

Next, the program name of the program 21 to be debugged is input by conversation processing. Here, it is assumed that D is input as the program name.

The debugger program 17 is the management program (OS) 11
Is requested to notify the start event of the program to be debugged having the contents of user ID = C and program name = D. The management program 11 stores the notified user ID = C and program name = D.

When the debugger program 17 has requested the OS to notify the start event of the program to be debugged, it issues a WAIT macro and enters a task execution wait state.

On the other hand, the debugged program 21 is started as one of the user programs independently of the debugger program 17 by, for example, a logon command and a subsequent program start command or a job control statement. Assume that the user ID of the debugged program 21 is C and the program name is D.

The management program 11 performs a loading process of the program with the program name = D. At this time, user ID = C
It is checked whether or not the information of program name = D is stored in the debug start management table 15.

User of loaded debugged program 21
If the ID = C and the program name = D match the stored ones, the debugged program 21 is stopped just before the start of execution.

The management program 11 is a debugger program 17
, The address of the management information of the task of the program to be debugged 21 is notified.

The debugger program 17 displays the start of debugging to the user and performs a conversation process for debugging. The following is an example of debugging.

When a breakpoint setting instruction is issued, the management program 11 is requested to set the breakpoint.

When the breakpoint is set, it is displayed.

When the execution start instruction is issued, the management program 11 is requested to start execution of the debugged program 21.

 The debugged program 21 resumes processing.

When the operation of the debugged program 21 stops at the break point, the management program 11 notifies the debugger program 17 of the stop.

The debugger program 17 is the debugged program 21
Is notified to the user, and a conversation process for debugging is similarly performed.

The processing flow of the debugger program 17 for realizing the above processing is as shown in FIG.

User identification code of the debugged program 21 (user
ID).

 Enter the name of the program to be debugged.

Debugged program 21 in management program (OS) 11
Request notification of the loading event at the start.

 Enter the WAIT state.

Debugging is performed by debugging conversation processing with the user.

The processing flow of the debug conversation processing of the processing shown in FIG. 3 is as shown in FIG.

A debug command provided by the debugger program 17 is input. The following processes are performed according to the contents of the debug command.

If it is the instruction information for the debugger task, the process in the debugger task is performed.

To read or write the data of the debugged program 21, read (READ) or write (WRIT) the memory area or register save area for the debugged task.
E).

If the instruction is to execute the debugged program 21, the operation of the debugged task is started. After that, it waits for the event of the task to be debugged.

If the debug command is an end command, a debug end process is performed.

FIG. 5 shows a configuration example of the debug start management table 15 shown in FIG.

The debug specification information management unit 14 is a debugger program.
In response to the notification from 17, the user ID of the program 21 to be debugged, the program name to be debugged, and the TCB address of the requesting task are stored in the debug start management table 15. The TCB address of the request source task is the address of the task control block 23-1 of the debugger program 17, and is used when notifying the loading event of the debugged program 21.

FIG. 6 shows a configuration example of the task control block 23.

The task control block 23 is a control table for managing a task which is a unit for giving a CPU execution right, and is used in a normal operating system having a task management function.

As management information, for example, a user ID, a name of a program operating on the task, a memory area start address, information on a size of the memory area, information indicating a task state such as operating or waiting, and a waiting state. There is a CPU register save area at the time.

The processing flow of the start processing of the user program by the program activation control unit 12 shown in FIG. 1 is, for example, as shown in FIG.

 Enter the user ID (for example, C).

 Search the user management table (not shown).

It is checked whether or not the program of the same user ID is running, and if not, the process proceeds.

If another program with the same user ID is running,
Displays usage prohibition.

If a program with the same user ID is not running, an execution program name (for example, D) is input.

Generate a task to run the user program.

 Load the user program D.

In the debugging start management table 15 shown in FIG.
It is checked whether information of C and program name = D is registered. If not registered, the process proceeds.

If it is registered, the task is stopped, and the requesting task, that is, the debugger program 17 shown in FIG.
Notify.

If it is not registered in the debug start management table 15, the program execution is started as a normal user program.

〔The invention's effect〕

As described above, according to the present invention, in a system in which a plurality of users can operate programs in parallel at the same time, a debug target program to be debugged can be easily recognized from an independently operating debugger program. Then, you can start debugging.

[Brief description of the drawings]

1 is a configuration example of the present invention, FIG. 2 is a flow of a debugging start process according to an embodiment of the present invention, FIG. 3 is a processing flow of a debugger program according to the embodiment of the present invention, and FIG. FIG. 5 is a configuration example of a debug start management table according to the embodiment of the present invention, FIG. 6 is a configuration example of a task control block according to the embodiment of the present invention, FIG. 9 shows a processing flow of a start process of a user program according to the embodiment of the present invention. In the figure, 10 is an information processing device, 11 is a management program, 12 is a program start control unit, 13 is a debugged program detection unit, 14
Is the debugged information management unit, 15 is the debug start management table,
16 is a notification section, 17 is a debugger program, 18 is a user identification symbol / program name input section, 19 is a notification section, 20 is a debug conversation processing section, 21 is a program to be debugged, and 22-1 and 22-2 are task areas. , 23-1 and 23-2 represent task control blocks, 24 represents an input device, and 25 represents a program storage device.

Continuation of front page (56) References JP-A-1-169546 (JP, A) J. Refleletal "The Design and Implementment of the 4.3 BSD Unix Operating System" (USA) Addison-Wesley Pub. Co. Inc. (Nov. 1989) pp. 69-86 ASCII Editing Bureau “Standard MS-DOS Handbook” (Showa 60-10-5). 180-205 (58) Field surveyed (Int. Cl. ⁷ , DB name) G06F 11/28

Claims (1)

(57) [Claims] An information processing apparatus (10) having means for inputting a user identification symbol and a program name, loading a program on a main memory based on the user identification code, and having a management program (11) for executing the program. The same information processing device (10) as the program to be debugged (21)
Means (18) for inputting a user identification symbol and a program name relating to a program to be debugged in a debugger program (17) which operates independently on the above, and notifies the management program of the input user identification symbol and the program name. Means (19), the user identification symbol and the program name notified in the management program are retained, and each time the program is loaded, the user identification symbol and the program name of the program and the retained usage are stored. Means for determining whether the user identification symbol and the program name match (13, 14), and when both match, means for waiting the loaded program in a state immediately before the start of execution and notifying the debugger program ( 16) A program debugging start processing method characterized by comprising: