JP3437284B2 - Service processing system - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a service processing system for executing a predetermined service process in accordance with a program loaded in a memory, and more particularly to a replacement technology of the above program.

[0002]

2. Description of the Related Art Conventionally, in a service processing system for executing various service processes by using a computer, when partial modification of a program is required, either a process stop type or a process continuation type is used. The program was being replaced. Here, the process stop type method is a method in which the running service process is once terminated, the program on the storage medium and the memory is changed, and then the process is restarted. On the other hand, the process continuation method is a method of directly specifying and changing a position of data (text area, data area) on the memory, that is, a memory address while continuing the service process, and is corrected by a patch. The point is characteristic.
In this case, the change data needs to be described at the machine language level. At the same time, it is necessary to change the data in the storage medium as well. This is because the program is loaded from the storage medium when the service process is terminated and the memory is released and then restarted.

[0003]

By the way, in the conventional service processing system, when the programs are replaced by using the above-mentioned method, the following problems occur.

(1) Process stop type This method has a problem that it is difficult to take over the resources held by the process and its state because the running service process is once terminated. For example, in order to hold the state of the communication line and the state of the process, it is necessary to convert the information at the end point into a file in some kind of file, and it is necessary to prepare a special process and a storage area for that purpose. Further, there is a problem that the timing of termination is limited because the service process needs to be terminated appropriately. In other words, if the service process is forcibly terminated, the service itself is interrupted, so that the process can be terminated only when a series of services are separated. Furthermore, since the service process is once terminated and then restarted, time is required for process termination processing, process generation processing, initialization processing, and the like.

(2) Process continuation type In this method, since correction data is created at the machine language level, there is a problem that it takes time to specify a correction point and create correction data. In addition, it was necessary to manually check the reliability by checking interface errors between function of modified data and bugs in machine language creation. Further, since the actual memory space is directly modified, there is a restriction on the modification size, and there is a problem that a patch larger than the original memory area cannot be applied. Furthermore, since the running state of the service process cannot be specified, inconsistencies may occur before and after changing the program depending on the running state. For example,
If the return address of the function is changed while the function is being called, it will run out of control. In order to prevent this, there are cases where partial initialization processing must be performed after the patch.

In view of the above problems, an object of the present invention is to provide a service processing system having a configuration capable of replacing programs without stopping or erasing the service process and capable of creating correction data in high quality and in a short time. To do.

[0007]

A service processing system provided by the present invention is a service processing system for executing a predetermined service process by utilizing a program loaded in a memory, wherein a plurality of modules obtained by dividing the program are provided. Module storing means for storing, a loader for reading a required module from the module storing means and loading it in the memory, and a loaded module
The first frame that represents the number that is called by another module
Lag, that module is calling another module
A module management table that sets a second flag that indicates the number of switches and a third flag that indicates the presence or absence of a replacement request for the module for each module, reference update processing of each flag set in the module management table, and the load Module control means for controlling the replacement of the loaded modules with each other and controlling a service process using the individual modules, and link means for linking the loaded module with the module control means,
And the module control means includes the service provider
Set the link module from the first module running
The process to a second module linked by a stage
When moving the second module corresponding to the first module
Add a predetermined value to the flag and send it to the second module.
Supports the second module when process transfer is possible
To first flag by adding a predetermined numerical value, it is determined whether the reference to the module replaced each flag that is set in the module management table can, a module replacement against the replacement state module Tomo When you run
The process from the second module to the first module.
The first module corresponding to the second module when returning to
Subtract the above value from the lag and proceed to the first module
Corresponds to the first module when process transfer is possible
The configuration is such that the numerical value is subtracted from the second flag .

The module control means is preferably
Module replacement is in progress or a replacement request has occurred.
The service process for the module
When the module has been replaced by suspending before replacing the module
At this point, the service state is released from the dormant state.
To do.

For example, the third flag is set as a replacement request.
None, can be replaced only when unused, unused and calling
Can be exchanged with, if it is expressed in at least three states
The module control means to manage the module.
The first flag and the second flag set in the table
Whether the module is running, calling, or unused
Check the status of this module and
Whether the module can be replaced depending on the state of flag 3
It may be configured to determine whether or not.

[0010]

[0011]

According to the present invention, first, the program is divided into a plurality of modules and stored in the module storing means, the required modules are loaded into the memory as needed, and the usage status from the service process and the module Understand whether there is a replacement request. As a method of grasping the usage status, a method of grasping the running position of the process from the value of the program counter of the service process is known, but this method requires instruction tracing and so on. There is a drawback that the overhead of is large. Therefore, in the present invention, a module management table is provided in place of this method, and the module management table includes a first flag indicating the number of times the module is called by another module, and the module is another module. Sets a second flag that indicates the number of calls to. In this way, when the numerical value of the first flag is larger than the numerical value of the second flag, it means that there is at least a service process running in the area of the module (during running). If the second flag and the second flag have the same numerical value and are not zero, it means that the service process running in the area of the module is calling another module and running (calling).
If both the second flag and the second flag are zero, it means that there is no service process running in the area of the module and no service process running by calling another module from the module (unused). Therefore, the process running position, that is, the usage status of the module from the service process can be easily grasped in module units.

Further, regarding the presence / absence of the replacement request, for example, a third flag indicating whether or not replacement of the module is instructed is set in the module management table for each module. With this configuration, when the module control means moves the process, the third
It is possible to determine whether or not the modules before and after the movement are in the process movable state by referring to the flag.

Here, when the module in which the service process is running is the first module and the module to which the process linked to by the link means is the second module, the module control means is the first module. When a process running on the vehicle is moved to the second module, first, a predetermined numerical value is added to the second flag corresponding to the first module, and if the process can be moved, the second flag is added. A predetermined numerical value is added to the first flag corresponding to the module. On the other hand, when the process is returned from the second module to the first module, the value is subtracted from the first flag corresponding to the second module, and if the process movement is possible, the first The value is subtracted from the second flag corresponding to the module. When a process cannot be moved, for example, as a result of referring to the third flag of the module management table, if a replacement request is generated for any module, the module control means keeps the process until the conditions for module replacement are satisfied. It is in a sleep state. Then, it is confirmed whether each module can be replaced, and if the module can be replaced, the module is replaced and then the suspension of the process is released.

As described above, according to the present invention, the process running in each module does not disappear even if the module is replaced. Therefore, the resources held by the process and the state thereof are inherited as they are to the destination module. Also,
Since the programs are replaced on a module-by-module basis, it is possible to use a high-level language to create modified data.

[0015]

Embodiments of the present invention will now be described in detail with reference to the drawings. FIG. 1 is a configuration diagram of a service processing system according to an embodiment of the present invention. Reference numeral 1 is a service processing device that executes a service process according to a predetermined program, 2 is an input device such as a keyboard or mouse, and 3 is module management. It is an external storage device that stores a routine (MMR) file 31 and a program module file 32.

The service processing device 1 has a central processing device 11 for controlling each part in the device, and a main memory 12 for storing data and programs necessary for the above control. In the main memory 12, for example, a loader 121, a service processing program 122, a module management table (MM
T) 123, MMR124, dynamic linker 12
5 and a function management table (FMT) 126 are stored.

The loader 121 reads a service processing program 122 necessary for realizing the service from the program module file 32 of the external storage device 3 and loads it on the main memory 12 in response to a service activation instruction input from the input device 2. . At that time, an MMT entry corresponding to each loaded module is created. Further, in response to a module replacement instruction from the input device 2, the module to be replaced is transferred from the external storage device 3 to the main memory 1
Load on 2. The loader 121 itself is expanded on the main memory 12 at the time of system initialization.

The MMT 123 is a table for managing the status of the service processing program loaded on the main memory 12, and the module name of the service processing program, various flags of each module, and a replacement request message. A sleep queue for queuing a process in a sleep state is associated with each other.

FIG. 2A shows a specific example of the MMT 123. The frag1 indicates a flag (first flag) indicating the number of times the module is called, and the frag2 indicates that the module calls another module. The flag (second flag) indicating the number of existing modules and the replacement request flag are flags (third flag) indicating that replacement of the module is instructed. Also, the replacement request flag
Indicates that there is no replacement request (value 0), it can be replaced only when it is unused (value 1), and it can be replaced while unused or during a call (value 2)
It expresses three states. As described above, the contents of the MMT 123 are created at the time of loading the module by the loader 121 and are updated at the time of the service process moving process and the module replacing process.

The MMR 124 is a routine program (module control means) for managing and controlling the usage status of each module.

Further, the FMT 126 is a table used for linking the loaded module and the MMR 124. As shown in FIG. 2B, the functions (func1, fu) called in other modules within each module are called.
nc2, ...), the function name and the position information (offset within the module) of each function are stored in association with each other. The FMT 126 is created by the loader 121 when each module is loaded into the main memory 12.

It is also possible to use the dynamic link table of the dynamic linker 125 instead of the FMT 126. That is, a compiler that provides a dynamic link function generates a plurality of loadable modules from one or more program files that describe one service. This loadable module is
This is the state before address resolution, and these unresolved addresses will not be resolved by the dynamic linker 1 until just before execution.
Address resolution is performed by 25. Therefore, it can be said that the address resolution of the loadable module is performed dynamically. As a result, the dynamic linker 125 and MMR1
Since the program can be managed as a plurality of modules at 24, when the correction data is created, only the module having the correction needs to be replaced on the storage medium. When the correction data is transferred via the communication line or This is advantageous when carrying modified data on a medium having a small capacity.

Next, in the service processing device 1 having the above configuration, the service processing program 1 on the main memory 12
22. For example, a process of moving a service process running a part of 22, for example, a first module (hereinafter abbreviated as s1) to a second module (hereinafter abbreviated as s2) and returning the module after replacing the module. explain.

In this embodiment, when calling a function for moving between modules, the MMR 124 is linked so as to be called. That is, the link is performed as s1 → MMR → s2. The method for achieving this is, as described above, F
Referring to the contents of MT126, a method of changing the location of calling a function of another module from s1 to call MMR124 with the function name and its argument, or performing address resolution by dynamic link every time the module is moved Thus, any method such as calling the MMR 124 in the dynamic linker 125 may be used.

The overall processing flow of the service processing apparatus 1 will be described below with reference to FIGS. 3 and 4.
The control procedure of 24 will be mainly described. According to FIG. 3, first, the MMR 124 is called from s1 by the above link. The MMR 124 indicates that s1 is calling another module.
Frag2 of "1" is added and (S (processing st
ep, the same applies hereinafter) 101), to refer to the replacement request frag of s1 in the MMT 123 in order to know whether or not a replacement request has occurred in s1 (S102).

Here, if a replacement request is issued for s1, that is, if a replacement request for this s1 and the third module s'1 (see FIG. 1) is made during execution of s1, , Frag1 and frag2 to check the current state of s1 (S103), and if "calling", whether the replacement request frag of s1 is "2", that is, s1 is "unused and calling during call" It is checked whether or not it is possible (S10
4). If the replacement request frag of s1 is "2", the replacement processing of s1 and s'1 is exclusively performed (S105),
After the replacement is completed, the replacement request flag s1 is cleared (S
106) as well as MMT123 and FMT126
The content corresponding to s1 of is updated to the content of s'1. After that, the sleep queue of s1 is released (S10).
7).

When a replacement request is not issued to s1 in S102 (S102), s1 is "running" instead of "calling" (S103), or when the replacement process for s1 is completed (S107). Is in which module the function called in s1 is, ie M
FMT1 indicates which module the destination of the service process is from the function name func1 in the argument of MR124.
Search 26 to find out. In this embodiment, it is grasped that the function func1 is in s2 (S108).

Subsequently, in order to know whether or not a replacement request has been issued to s2, the replacement request frag of s2 in the MMT 123 is referred to (S109). Here, when the replacement request for s2 and the fourth module s'2 (see FIG. 1) has occurred, the flags 1 and fr of the MMT 123 are generated.
The current state of s2 is checked by referring to ag2 (S11
0), "running" or "calling" and the replacement request frag of s2 is not "2" (S1)
11), register in the sleep queue of s2 (S112),
The pause of the process is released (S114) and the process returns to S109. On the other hand, when s2 is "unused", or when "calling" and the replacement request flag of s2 is "2", the replacement processing of s2 and s'2 is exclusively performed (S1).
15) After completion of the replacement, the replacement request frag of s2 is cleared (S116), and the MMT 123 and FM
The content corresponding to s2 of T126 is updated to the content of s'2. After that, the sleep queue of s2 is released (S
117).

If no replacement request is issued to s2 in S109, or if the sleep queue of s2 is released from sleep in S117, it indicates that the call of s2 is being made, so that the fra of s2 in MMT123 is being executed.
"1" is added to g1 (S118). Then, the function func1 in s2 is called (S119), and control is transferred to the function func1. The subsequent processing procedure is shown in FIG.

Referring to FIG. 4, s2 by func1
When the processing of 1 is completed, the control returns to the MMR 124 that called s2. Then, in order to indicate that the calling of s2 has ended, the MMR 124 causes the fr of s2 in the MMT 123 to be displayed.
"1" is subtracted from ag1 (S120).

Next, it is checked whether or not a replacement request is generated in s2 (S121). Here, if the replacement request is generated, it means that the replacement request of s2 is generated during the execution of s2.
The same processing as 3 to S107 is performed (S122 to S12).
6). In this case, since the service process has already completed execution of s2, the service process will not enter the idle state waiting for replacement. If a replacement request for s1 occurs during execution of s2, the replacement process is performed after S124 to S126. In the flowchart shown in the figure, the process suspension process is not performed, but the process suspension process can be performed when the s1 is replaced with "calling".

On the other hand, if no replacement request is issued to s2 in S121, and if s2 is "calling" in S122, or if the replacement request frag of s2 is not "2" in S123, the service process In order to know whether or not there is a replacement request for s1 which is the movement destination, the replacement request frag of s1 in the MMT 124 is referred to (S127). When the replacement request is generated, the above-described processing of S103 to S107 is performed. After the completion of this process, or when the replacement request is not issued to s1 in S127, "1" is subtracted from the flag2 of s1 in the MMT123 to indicate that the call from s1 is completed (S133). The control is returned to s1 which is the calling source of the MMR 124 (S134).

Incidentally, the above-mentioned S105 to S107, S12
In the processing of 4 to S126, by not canceling the actual replacement and canceling the suspension waiting process,
The service process that has been released from suspension can be replaced. By doing this, MMR12
The control procedure of 4 can be simplified. Flow charts in this case are shown in FIGS.

In FIG. 5, the processing of S201 to S203 is the same as the processing of S101 to S103 of FIG.
In 204, when the replacement request frag of s1 is "2", the sleep queue of s1 is canceled without performing exclusive control (S205). Subsequent S206 to S2
The process of 17 is similar to that of FIG. Also in the case of FIG.
In the process of FIG. 4, when the state of s2 is "unused",
Alternatively, it is "running" but the replacement request flag s2
Is "2", the sleep queue of s2 is released from suspension without performing exclusive control (S222), and a replacement request is generated in s1, and the replacement request frag of s1 is "2".
Also in this case, the point that the sleep queue of s1 is released from suspension without performing exclusive control (S132) is different, and the other processing is the same as the other processing of FIG.

As described above, in the service processing system of this embodiment, the programs can be exchanged without stopping or erasing the service process, which causes a problem of inheriting the resources or state held by the process. Never. In addition, for modules that are not directly related to partial modification or addition of programs, the service process can be continued without being affected by maintenance work, and the usage status of modules from the service process can be quickly grasped. There is an advantage that the stop time of the service process to be stopped is minimized and the service stop time due to maintenance is short. Therefore, for example, when a service is provided continuously for 24 hours, the influence of the program maintenance work on the entire service can be reduced. Also, because the program is modified in module units, it is possible to use a high-level language for creating modification data, and there is no restriction on modification size as in the past, so a highly reliable program modification can be done in a short time. Is possible.

[0036]

As is apparent from the above description, in the present invention, the program is divided into a plurality of modules, and the utilization status (running, calling, unused) from each service process and the module are used as a unit. Since the presence or absence of the replacement request is grasped, it becomes extremely easy to grasp the timing of module replacement and process movement according to the status of the service process and individual modules, and the contradiction that occurs before and after the program change is reliably eliminated. There is an effect that is done.

Further, in order to grasp the usage status of the module from the service process and the presence / absence of a replacement request, a module management table is provided, and various flags are set in the module management table so that reference and update can be performed at any time. Compared with the case of using the program counter owned by, the process running position can be grasped easily, and the processing overhead is significantly reduced.

Further, since the correction data of the program can be created in a high-level language, the correction data can be created in a shorter time than the modification at the machine language level by the patch. In this case, there is also an advantage that there are few restrictions on the size of the correction data. As a result, it is possible to reduce the time and money costs associated with the program modification.
Furthermore, since the module can be created by using the dynamic link function, it becomes possible to easily perform address resolution and verification of the validity of the inter-function interface.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a service processing system according to an embodiment of the present invention.

FIG. 2A is an explanatory diagram of contents of a module management table (MMT) used in this embodiment, and FIG. 2B is an explanatory diagram of contents of a function management table (FMT).

FIG. 3 is a flowchart showing the overall processing procedure of the service processing apparatus in this embodiment.

FIG. 4 is a flowchart showing a subsequent procedure of FIG.

FIG. 5 is a flowchart showing another processing procedure in which a part of the processing shown in FIG. 3 is simplified.

6 is a flowchart showing another processing procedure in which a part of the processing shown in FIG. 4 is simplified.

[Explanation of symbols]

1 Service processor 2 input devices 3 external storage 31 Module management routine file 32 program module files 11 Central processing unit 12 main memory 121 loader 122 Service Processing Program 123 Module Management Table (MMT) 124 Module Control Routine (MMR) 125 dynamic linker 126 Function Management Table (FMT)

Front page continuation (58) Fields surveyed (Int.Cl. ⁷ , DB name) G06F 9/06 G06F 9/40 G06F 9/42 G06F 9/46 G06F 11/20 G06F 15/00

Claims (3)

(57) [Claims] 1. A service processing system for executing a predetermined service process using a program loaded in a memory, and a module storing means for storing a plurality of modules obtained by dividing the program, and a required module for storing the module. A loader that reads from the means and loads it into the memory, and the loaded module is called by another module.
The first flag that indicates the number of
A module management table to set the third full <br/> lag representing the presence or absence of replacement request to the second flag and the module that represents the number that is calling module to the module unit, set in the module management table A module control unit that performs reference update processing of each flag, replacement control of the loaded modules, and control of a service process that uses each module, and links the loaded module and the module control unit Link means, and the module control means is configured to run the service process.
From the first module running, by the linking means
Move the process to the linked second module
The second flag corresponding to the first module
Process to the second module by adding the predetermined numbers
The first module corresponding to the second module when it can be moved
By adding a predetermined numerical value to the flag of the to determine whether the module can be replaced with reference to the flag set in the module management table, and executes the module replacement against the replacement state module , Concerned
Return the process from the second module to the first module
The first flag corresponding to the second module
Subtract the number and move the process to the first module
The second module corresponding to the first module when
A service processing system having a configuration for subtracting the numerical value from a lag . 2. The module control means suspends the service process for a module during module replacement or for which a replacement request is generated before module replacement, and when the module replacement is completed, the service process is suspended. The service processing system according to claim 1 , wherein the service processing system is configured to cancel. 3. The third flag is a no replacement request,
It is represented in at least three states that indicate that it can be replaced only when it is unused, and that it can be replaced while unused and while calling.
The module control means checks whether the module is in a running state, a calling state, or an unused state according to the first flag and the second flag set in the module management table, and the state of the module, The service processing system according to claim 1, wherein it is determined whether the module can be replaced based on the state of the third flag.