KR100258084B1 - Forced procedure call service implementation method - Google Patents

Abstract

PURPOSE: A method is provided to reduce procedures of recreating or recompiling a test program for the reexecution of the program. CONSTITUTION: If a procedure forced call service request message is received from a cross-debugging client(S1, S2), a service demon detects the request message in order to accept the request(S3). In case of accepting the request, the service demon prepares for a user procedure to perform forced call(S5, S6). And then, the user procedure performs the froced call(S7). If the service demon receives a message notifing that the forced call is completed, the service domon transmits the result of the service to the cross-debugging client(S8).

Description

How to Implement Procedure Forced Call Service

The present invention is developed to enable advanced debugging in developing massive software in a large-scale exchange system using a scalable real-time operating system (hereinafter referred to as SROS) as a real-time operating system. A method for implementing a procedure forced call service in a debugging server.

In general, since the exchange system is an embedded application field, the target system for the target exchange system is produced by providing an editing and compilation environment on a host computer such as a sun workstation or a cray computer based on the UNIX operating system. Download and run on the exchange system.

In order to provide an effective test environment and debugging environment under such a cross-development environment, a method for testing and debugging a program running on a target exchange system on a host computer is required.

The cross-debugging server developed as part of the above requirements operates in the target switching system and serves as a debugging server that performs debugging services for the cross-debugging clients on the host.

The present invention relates to a procedure forced call service realization method which is one of service items of a cross debugging server of SROS.

The forced procedure call service of the cross-debugging server is a debugging service that provides any procedure of a user program being debugged to be called at any time and in any process.

In other words, by forcibly calling a procedure that is not in the execution order of any process, the existing program execution order can be forcibly changed.

Conventionally, when writing or testing a program running on a target switching system, a test program corresponding to all cases is created and compiled on a host computer, downloaded to the target switching system, executed, tested, and re-hosted when an error occurs. The program was tested or debugged by repeating a series of procedures that were created and compiled on a computer, then downloaded and tested on the target exchange system.

This requires the creation of as many test programs as there are all cases that make up a program to test or debug a piece of software.

There is a strong demand for software productivity that simplifies the creation, testing, and debugging of these cumbersome test programs so that they can be efficiently executed.

In order to achieve the above, the present invention provides a method for executing all procedures constituting a program by calling any procedure at any time in any process in the program, and executing separately required for testing. The objective is to reduce the process of rewriting or recompiling a test program following the procedure.

1 is a configuration diagram of a hardware system according to the present invention;

2 is a software functional block diagram according to the present invention;

3 is a flowchart illustrating a procedure forced call service realization according to the present invention;

4 is a flowchart of a procedure forced call service request accepting step according to the present invention;

5 is a flowchart of a procedure forced call service preparation step according to the present invention;

6 is a flowchart of a procedure forced call service execution step according to the present invention;

7 is a flowchart of a procedure forced call service finishing step according to the present invention;

<Description of the symbols for the main parts of the drawings>

100: target exchange system

110: switch net

120: operation maintenance processor

130: call processing processor

140: cross debugging server in SROS

141: service daemon

142: remote communication processing unit

143: Debugging Service Engine

150: user program

151: process

200: Ethernet

300: host computer

310: cross debugging client

In order to achieve the above object, the present invention provides a target exchange system in which an operation maintenance processor and a call processing processor, each of which has a SROS as an operating system, are connected to each other via a switch network, a host computer for editing, compiling, and cross-debugging of exchange software, and the target exchange system. A method for realizing a procedure forced call service of a cross-debugging server applied to a device having a communication network that physically connects a host computer with a host computer, the method comprising: accepting a procedure forced call service request from a cross-debugging client in a host computer And preparing a procedure forced call service, executing a procedure forced call service, and delivering a result of the procedure forced call to a cross-debugging client of the host computer.

Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

1 is a block diagram of a hardware system according to the present invention, which includes an operation maintenance processor (OMP) 120 and a caller processor (SCP) 130 as an operating system 130. ) Physically connects the target exchange system 100 connected to the switch network 110, the host computer 300 running the UNIX operating system, and the target exchange system 100 and the host computer 300. Ethernet 200 is made up of.

According to the present invention, a user running on a target exchange system on the host computer 300 is equipped with a cross debugging client on a host computer equipped with an SROS operating system equipped with a cross debugging server in an OMP or SCP of the target exchange system 100. The present invention relates to a method for implementing a forced-procedure service provided by a cross-debugging server of the target switching system 100 used to test or debug a program.

2 is a software functional block diagram according to the present invention, in which the cross debugging server 140 of SROS for providing a procedure compulsory calling service includes one or more service daemons 141, a debugging service engine 143, and remote communication. It consists of a processing unit 142.

The remote communication processing unit 142 controls remote communication with the cross-debugging client 310 in the host computer to deliver a procedure forced call service request message received from the cross-debugging client to the service daemon, and the service daemon receives the service result. If you want to deliver it to a cross-debugging client on the host computer, it sends it.

The service daemon 141 determines whether to accept a procedure forced call service request from a cross-debugging client, and if so, any process in the user program 150 using the debugging service engine 143 may be It creates all conditions to execute the forced procedure call, detects that the procedure forced call execution is completed, and delivers the service result upon completion of the service to the cross-debugging client.

The debugging service engine 143 allows the process 151 in the user program 150 requested by the cross debugging client 310 to execute a procedure forced call.

3 is a flowchart illustrating a procedure forced call service realization to which the present invention is applied. First, a service daemon starting with waiting for a procedure forced call service request message from a cross-debugging client (S1) is a program from a cross-debugging client. Upon receiving the procedure forced call service request message (S2), the request message is examined to determine whether to accept the service request (S3).

It is determined whether or not the service request is accepted (S4). If it is not accepted, an error message is transmitted to the cross-debugging client (S5). If the service request is accepted, the user process using the debugging service engine is prepared to execute a procedure forced call. (S6).

After the user process prepares to execute the procedure forced call, the user process using the debugging service engine executes the procedure forced call based on various conditions prepared by the service daemon (S7).

The service daemon waits while the user process executes the procedure forced call and finishes the procedure forced call service such as sending the service result to the cross-debugging client when receiving the execution completion message from the user process. (S8).

4 is a flowchart illustrating a procedure forced call service request accepting step according to the present invention, and prepares a memory location for storing related information required in the procedure forced call execution step (S3a), and receives from a cross debugging client. In the service request message, the message length, the start address of the forced call procedure, the static link information, the input parameter, and the return value information about the storage space are checked (S3b), and it is determined (S3c).

If it is not correct after the determination, an error message is sent to the cross-debugging client (S3d), and the process ends.

If it is correct after the decision, store it in a place where information related to the procedure start address, call type, static link, input parameters, and return value etc. to be forced is used for the procedure execution call execution step. (S3e).

After storing the related information in a place where the related information is prepared, it is determined whether a process exists after the existence of a process for executing a procedure forced call requested by the cross-debugging client (S3f) (S3g).

If it exists after the determination, it is determined whether the state of the program to which the process belongs is a program execution stop state (S3h). If the program execution stop state, an error message is sent to cross debugging (S3d).

If the program is not in the execution stop state, the input parameters and return value storage locations for which address recalculation is required in the procedure forced call execution step are stored and related information is stored (S3i), and then the procedure forced call service is performed. Complete the acceptance step (S3j).

5 is a flowchart of a procedure forced call service preparation step according to the present invention. In the process of preparing a procedure forced call service, first, execution of a user process to execute a procedure forced call is stopped (S6a). The process state information immediately before being suspended is stored in the process state management queue of the cross-debugging server (S6b).

The contents of all registers are stored so that a user process forcibly interrupted to perform a procedure forced call service can be restored at the time of completion of service (S6c).

The suspended user process prepares a process stack necessary for executing a procedure forced call and readjusts the stack point (S6d).

When the stack pointer rebalancing is complete, the service execution in the debugging service engine is allowed to force the procedure to be called when the interrupted user process occupies the central processing unit (CPU). The program counter (hereinafter referred to as the PC) and the next program counter (hereinafter referred to as the NPC) are forced to run immediately at the point (S6e). It is put in the process preparation queue for process scheduling to execute the procedure forced call (S6f).

When all the necessary steps are completed in the service preparation phase, the service daemon finally completes the work in the service preparation phase by informing the cross-debugging client on the host computer that the procedure forced call service has started (S6g).

6 is a flowchart of a procedure forced call service execution step according to the present invention. First, the procedure forced call service related information stored in the service request acceptance step is inquired to accurately input parameters requiring address recalculation. Compute the address (S7a) and adjust the values of the parameter passing registers according to the procedure call type so that the input parameters can be passed in the procedure forced call (S7b), and call the procedure to be forced to call ( S7c).

After calling the procedure that you want to call, save the contents of the register where the return value of the executed procedure is stored separately, and check whether the request for sending the return value is received from the cross-debugging client. When the request is received, the address of the return value storage location is examined to determine whether it is necessary to recalculate and if necessary, the address is recalculated (S7d).

After performing the address recalculation, the process stops scheduling (S7e), removes the state of the process from the process preparation queue so that it can return to the state it was in before executing the procedure forced call, and also executes the procedure forced call. Restore to the state before execution (S7f).

After restoring the state of the process to the state it was in before executing the forced procedure call, inform the service daemon that the procedure has been forced to execute (S7g), and process the contents of the registers stored in the service preparation step. It is loaded into the block (S7h).

Finally, the memory resource allocated to store the information required to perform the procedure forced call service in the service request acceptance step is released (S7i), and the scheduling of the processes is resumed (S7j).

7 is a flowchart illustrating a procedure forced call service finishing step according to the present invention, and waits until the service daemon receives an execution end message from a process that executes a procedure forced call (S8a).

When the execution end message is received, it is checked whether it has been normally executed and terminated (S8b).

After checking whether or not it is terminated, it is judged whether it is normally terminated (S8c). If it is not normal, it sends an error message to the cross-debugging client (S8d) and resumes the user process that was stopped for the procedure forced calling service (S8d). S8e) End.

If it is confirmed that the program is normally executed and terminated, it is determined whether a request for sending a return value is received from the cross-debugging client (S8f). If no return value is required, the cross-debugging client indicates that the procedure forced call service is completed. (S8g) Next, the user process which has been suspended for the procedure forced call service is resumed (S8e) and terminated.

If there are return values to be sent to the cross-debugging client, construct a message containing all the contents that should be returned, send it to the cross-debugging client (S8h), and then execute the user process that was suspended for the procedure forced call service. Resume (S8e) and end.

As described above, the present invention allows any procedure of a program being debugged to be called at any point in time and in any process, that is, forcing a procedure not in the execution order of any process. Calls can be made, which significantly reduces the programming process or the test process by allowing the program to be repeated in the program writing process or the test and debugging process of the program, or effectively performed online without compiling a new program. This contributes to improving the productivity of the software.

Claims (5)

A target exchange system in which an operation preservation processor and a call processing processor operating as a scalable real-time operating system (SROS) are interconnected by a switch network, a host computer for editing, compiling, and cross-debugging of the exchange software, and the target exchange system and the host. In the method of realizing a procedure forced call service of a cross-debugging server applied to a device having a communication network that physically connects computers with each other, A first step of starting with waiting for a procedure forced call service request message from a cross debugging client; The service daemon receives a procedure compulsory call service request message from the cross-debugging client, examines it, and determines whether to accept the service request; A third step of determining whether to accept the service request and transmitting an error message to the cross-debugging client if it cannot accept the service request; A fourth step of preparing a user process using a debugging service engine to execute a procedure forced call when accepting the determination; A fifth process of preparing a user process to execute a procedure forced call and then executing a procedure forced call based on various conditions prepared by the service daemon; The service daemon includes a sixth process of waiting for a user process to execute a procedure forced call and then transmitting a service result to the cross-debugging client when receiving the execution completion message from the user process. How to realize call service. The method of claim 1, wherein the second process A first step of arranging a memory location for storing related information required in a procedure forced call execution step; In the service request message received from the cross-debugging client after performing the first stage, the message length, the start address of the forced call procedure, the static link information, the input parameters, and the return value storage space are examined and checked for correctness. A second step; A third step of sending an error message to the cross debugging client and terminating if it is not correct after the determination; If it is corrected after the determination, store the information related to the procedure start address, call type, static link, input parameters, and return value to be forced in order to use in the procedure forced call execution step. A fourth step; A fifth step of determining whether the process exists after storing it in the place where the relevant information is prepared and checking whether there is a process to execute a procedure forced call requested by the cross-debugging client; Determining whether the state of the program to which the process belongs is a program execution stop state, if it exists after the determination, and if the program execution stop state transmits an error message to cross debugging and terminates; If the program is not in a suspended state, the procedure for executing the procedure forced call service acceptance step is completed after the procedure forced call execution step examines the input parameters and return value storage locations for which address recalculation is required and stores the relevant information. A procedure forced call service realization method comprising the seven steps. The method of claim 1, wherein the fourth process Stopping the execution of the user process to execute the procedure forced call and storing the process state information immediately before the execution is stopped in the process state management queue of the cross-debugging server; A second step of storing contents of all registers so that a user process forcibly stopped to perform the procedure forced call service can be restored at the time of completion of the service; A third step in which the suspended user process prepares a process stack required for executing a procedure forced call and readjusts a stack point; After the stack pointer rebalancing is complete, the program counter and the next program can be run directly from the service execution start point in the debugging service engine, which forces the procedure to be called when the interrupted user process occupies the central processing unit. A fourth step of forcibly adjusting the counter; A fifth step of putting the program counter and the next program counter into a process preparation queue for process scheduling so as to execute a procedure forced call by occupying only the central processing unit without changing the state of the process after forcing adjustment; After completing all the necessary steps in the service preparation phase, the service daemon notifies the cross-debugging client on the host computer that the procedure forced-call service has started, finally consisting of the sixth phase of completing the work in the service preparation phase. A procedure forced call service realization method characterized by the above-mentioned. The method of claim 1, wherein the fifth process A first step of calculating correct addresses for input parameters for which address recalculation is required by querying the procedure forced call service related information stored in the service request accepting step; The procedure to forcibly call by adjusting the values of the parameter transfer registers according to the procedure call type so that the input parameters can be delivered when the procedure is forcibly called after calculating the correct address for the input parameters for which the address recalculation is required. Calling a dewar; A third method for calling a procedure to be called and then storing the contents of the register where the return value of the executed procedure is stored separately, and investigating whether a request has been received from the cross-debugging client. Steps; A fourth step of checking whether an address of a return value storage location needs to be recalculated when receiving a request for transmission after receiving a return value request from the cross-debugging client, and performing recalculation of addresses if necessary; After the address recalculation is performed, the processes are not scheduled, and they are removed from the process ready queue so that they can return to the state they were in before the execution of the forced procedure call, and the state of the process was restored to the state before the forced procedure call was executed. A fifth step of restoring; After restoring the state of the process to the state it was in before executing the procedure forced call, notify the service daemon that the procedure has been forced to execute, and load the contents of the registers saved in the service preparation step into the process control block. Sixth step of making; The compulsory call service comprising the seventh step of releasing the memory resources allocated to store the information required to perform the procedure forced call service in the service request acceptance step, and resumes the scheduling of processes. How to realize. The method of claim 1, wherein the sixth process A first step of waiting for a service daemon to receive an execution termination message from a process that executes a procedure forced call; A second step of, upon receiving the execution completion message, whether to execute normally and to terminate; Determining whether it is normally terminated after checking whether it has been terminated, and if it is not normally terminated, transmitting an error message to the cross-debugging client, restarting the user process that was suspended for the procedure forced call service, and terminating it; A fourth step of determining whether or not a request for sending a return value has been received from the cross-debugging client when notifying that the execution is successful and notifying the cross-debugging client that the procedure forced call service is completed when no return value is required. ; A fifth step of notifying the cross-debugging client that the procedure forced call service is completed and then restarting and terminating the user process that has been suspended for the procedure forced call service; If there are return values to be sent to the cross-debugging client, construct a message that contains all that should be returned, send it to the cross-debugging client, and then resume and terminate the user process that was suspended for the procedure forced call service. A procedure forced call service realization method comprising: a step.

Images