JPH07200283A - Exchange system for resident load module - Google Patents

Abstract

PURPOSE:To prevent the deterioration of processing efficiency in a system by rewriting the pointer to be a pointer pointing the address of the other resident load module loaded on a real address space. CONSTITUTION:When a processor 1 becomes to be in an idle state, FW15 rewrites a pointer (3) pointing the resident module 19C stored in the address 6000 of the segment management table 11 of a segment corresponding to an exchange resident load module 21 loaded on the real memory space 7 by a command to a pointer (4) pointing the exchange resident load module 21, and resumes the execution of a process, for example. Then, a processor 3 instructs FW17 to perform task dispatch control. FW15 rewrites the pointer (3) of a segment management table 13 to the pointer (4) pointing the exchange resident load module 21 by the instruction. The processor 3 resumes the execution of the process after the rewriting.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a resident load module that replaces a resident load module that is loaded from a magnetic disk device into a real memory space at the time of initialization of a multiprocessor system and is subsequently resident in the real memory space with another resident load module. The present invention particularly relates to a resident load module replacement system that enables replacement of a resident load module while operating online.

[0002]

2. Description of the Related Art Conventionally, in a virtual memory operating system, a program (load module) is used.
Operating system (hereinafter referred to as OS
Say. ), The program is processed by demand paging to be loaded in the real memory space, the program (load module) is read from the magnetic disk device, and the real memory space is allocated. In addition, the svc routine that executes the function of the OS by the supervisor call,
Dispatching control, interrupt handlers corresponding to various interrupts, etc. are loaded from the magnetic disk device to the real memory space by system initialization or loading processing, and thereafter reside in the real memory space. In the above-mentioned resident load module (hereinafter referred to as resident load module), for example, when executing a system version upgrade or when there is a problem with the OS (resident load module), it is necessary to replace it with another resident load module. There is. When replacing with another resident load module, the replacement is completed by interrupting the processing of the processor and then loading another resident load module from the magnetic disk device into the real memory space and restarting the system. In this case, by interrupting the processing of the processor and replacing another resident load module, for example, the processing of the system connected to the processor is stopped online, so that the processing of the system connected online is There was a risk of delay. This requires a system restart as well in a multiprocessor system.

[0003]

However, since the conventional multiprocessor system has only one segment management table, when the other resident load module is loaded into the real memory space, the OS is not loaded.
There is a problem in that it is difficult to control the switching timing because the control for switching the svc routine from one processor to one processor, the interrupt handler, etc. to another processor becomes complicated. When the system is restarted when the resident load module is replaced, the execution of the process of the one processor is suspended for about several minutes.For example, one processor is connected to various systems online. However, there is a problem in that the processing efficiency of the entire system is lowered and the system is stopped.

The present invention has been made in view of the above conventional problems, and an object of the present invention is to provide each processor with a segment management means corresponding to one to one.
The resident load module is replaced without performing complicated control and operation. Also, by performing it while the system is operating, interruption of the system processing due to replacement of the resident load module is prevented, and the system processing efficiency is reduced. It is to provide a resident load module replacement system that prevents the above.

[0005]

To achieve the above object, the present invention resides in that a multi-processor system having at least two or more processors is loaded into a real memory space at the time of initialization, and thereafter resident in the real memory space. In a system for replacing a resident load module that replaces a load module with another resident load module, the resident load module is provided in a one-to-one correspondence with each processor of the two or more processors. Segment management means for associating an address with an address of a virtual address space that manages the resident load module loaded in the real memory space in units of segments, and the resident load module when replacing the resident load module with another resident load module Multiprocessor system In the real memory space stored in the segment management means corresponding to the one processor that has finished the execution of the process by this processor migration means, the processor migration means for preventing the execution of the process of one processor The summary is provided with segment management rewriting means for rewriting a pointer indicating the address of the loaded resident load module to a pointer indicating the address of another resident load module loaded in the real address space.

[0006]

According to the above configuration, the resident load module that is loaded into the real memory space at the time of initialization of the multiprocessor system having at least two or more processors, and then resident in the real memory space is replaced with another resident load module. When the resident load module is replaced, the process of one processor in the multiprocessor system is not executed, and the process executed by the one processor is transferred to another processor.

A pointer that points to a resident load module loaded in the real memory space stored in the segment management means corresponding to the one processor that has finished executing the above process is loaded into the real address space. Rewrite it with a pointer to the address of the resident load module of. Since the above processing is sequentially executed on all processors of the multiprocessor system, the resident load module can be replaced without performing complicated control and operation, and the resident load module can be replaced by performing it while the system is operating. It is possible to prevent the accompanying interruption of the processing of the system and prevent the deterioration of the processing efficiency of the system and the suspension of the processing of the system.

[0008]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 is a functional block diagram showing an embodiment of the resident load module replacement system of the present invention.

The system for replacing the resident load module has a processor 1, a processor 3, a magnetic disk device 5, a real memory space 7, a virtual address space 9, a segment management table 11 and a segment management table 13.
Is equipped with.

The processor 1 and the processor 3 are
A multiprocessor system allows each processor to execute processes in parallel. At the time of system startup (initialization), resident load modules 19a to 19c, which will be described later, are loaded from the magnetic disk device 5 into the real memory space 7 by initialization processing. Further, the processor 1 and the processor 3 read a program (load module) from the magnetic disk device 5 and allocate a real memory space 7 at the request of a management program of a virtual memory type operating system (hereinafter referred to as OS). Furthermore,
The processor 1 is provided with firmware 15 that executes processing in accordance with a command, and the processor 3 is also provided with firmware 17. The firmware (hereinafter, referred to as FW) 15 stores programs that execute various controls, and executes, for example, task dispatcher control that terminates a process of a processor and shifts execution of the process to another processor.

The magnetic disk device 5 is stored in various resident load modules 19a to 19c and a replacement resident load module 21, and the resident load modules 19a to 19c are loaded into the real memory space 7 when the system is started up. The replacement load module 21
Is loaded from the magnetic disk device 5 into the real memory space 7 by the initialization process when the system version is updated.

The real memory space 7 actually stores the resident load module 19a and the like. The resident load module 19a stored in the magnetic disk device 5 when the system is started up is also stored in the address indicated by the pointer. The resident load module 19b is stored at the address pointed to by the pointer, and the resident load module 19c is stored at the address pointed to by the pointer. Further, the actual memory space 7 stores, for example, the replacement resident load module 21 loaded from the magnetic disk device 5 at the address indicated by the pointer when the system version upgrade is executed. The virtual address space 9 is the resident load modules 19a to 19c loaded in the real memory space 7.
Is managed in segment units. Specifically, for example, the address indicated by the pointer in the real memory space 7 is 4000, and the address indicated by the pointer is 5
Address 000, 600 for the address indicated by the pointer
Address 0 is assigned.

Segment management tables 11 and 13
Is a pointer that is provided in a one-to-one correspondence with the processors 1 and 3 and that points to the addresses of the resident load modules 19a to 19c loaded in the real memory space 7.
I remember. Further, the segment management tables 11 and 13 store a flag indicating "1" when the processor is free, that is, when the processor is executing a process, and "0" when the processor terminates the process. There is.

Next, the operation of this embodiment will be described with reference to the flow charts of FIGS.

First, when the system is activated after powering on the device, the resident load modules 19a to 19c stored in the magnetic disk device 5 are loaded into the real memory space 7 by initialization processing (step 100). When the resident load modules 19a to 19c are loaded, the processor 1 and the processor 3 operate in the segment management table 1
A pointer pointing to an address stored in the real memory space 7 of the load modules 19a to 19c resident in Nos. 1 and 13
Memorize Stored resident load module 19a-
System initialization processing and the like by 19c is executed (step 110).

Here, for example, when the system version is updated, the replacement resident load module 21 is loaded from the magnetic disk device 5 into the real memory space 7 by the software for performing the load process (step 120).

The replacement resident load module 21 for replacement
Is loaded into the real memory space 7, the processor 1
W15 is instructed to execute the task dispatcher control, and the processor 1 does not execute the process of the relevant processor, thereby shifting to another processor (step 1).
30). The process of shifting to the other processor will be described with reference to the flowchart of FIG. Processor 1 to FW
When the task dispatcher control execution is instructed to 15, the FW 15 refers to the flag of the segment management table 11 (steps 132 to 134). When the flag is "0", the FW 15 executes the process by the task of its own processor (step 136), and when the flag is "1", the FW 15 causes the processor 1 to execute the process currently requested by the OS. The process is terminated and another processor is executed (step 138).

Returning to FIG. 2, the processor 1 is empty, that is,
FW15 until the processing of the processor 1 ends
Repeats the process transition (step 14
0).

When the processor 1 becomes idle, FW
15 is, for example, 600 of the segment management table 11 of the segment corresponding to the replacement resident load module 21 loaded in the real memory space 7 by a command.
A pointer for the resident load module 19c stored at address 0 is replaced with the resident load module 2 for replacement.
The pointer is rewritten to 1 (step 150).

When the pointer of the segment management table 11 is rewritten, the processor 1 restarts the execution of the process (step 160).

After resuming the execution of the process of processor 1,
The processor 3 commands the FW 17 to perform task dispatch control. In response to the command, the FW 15 performs steps 130 to 1
The processing of 60 is executed to rewrite the pointer of the segment management table 13 to the pointer pointing to the replacement resident load module 21. After rewriting, processor 3
Restarts the execution of the process (step 170).

The above is the case of the processors 1 and 3, but the same effect can be obtained in a multiprocessor system having n processors. In this case, one to one for each processor from processor 1 to processor n
N segment management tables corresponding to are provided, and the pointer of the segment management table is rewritten to the pointer pointing to the replacement resident load module 21.

As a result, the resident load module can be replaced without performing complicated control and operation, and the system processing can be prevented from being interrupted due to the replacement of the resident load module because it can be performed while the system is operating. Thus, it is possible to prevent a decrease in system processing efficiency.

[0025]

As described above, according to the present invention, each processor is provided with a segment management means corresponding to one-to-one, and when a resident load module for replacing a resident load module with another resident load module is replaced, Prevents the execution of the process of one processor in a multiprocessor system. A pointer pointing to a resident load module stored in the segment management means corresponding to the one processor that has finished executing the process is set to a pointer pointing to an address of another resident load module loaded in the real address space. Since it is rewritten, the resident load module can be replaced without performing complicated control and operation.Because this can be done while the system is operating, the system processing is prevented from being interrupted due to the replacement of the resident load module. It is possible to prevent a decrease in processing efficiency.

[Brief description of drawings]

FIG. 1 is a functional block diagram showing an embodiment of a resident load module replacement system of the present invention.

FIG. 2 is a flowchart showing the operation of the present invention.

FIG. 3 is a flowchart showing the operation of the present invention.

[Explanation of symbols]

 1, 3 processor 5 magnetic disk 7 real memory space 9 virtual address space 11, 13 segment management table 15 FW

Claims (1)

[Claims] 1. Replacing a resident load module that replaces a resident load module that is loaded into a real memory space at the time of initialization of a multiprocessor system having at least two or more processors and then resides in the real memory space with another resident load module. In the system, the address of the real memory space in which the resident load module is loaded and the resident load module loaded in the real memory space, which are provided in a one-to-one correspondence with each processor of the two or more processors, are segmented. Segment management means for associating addresses in the virtual address space managed in units, and not executing the process of one processor of the multiprocessor system when replacing the resident load module with another resident load module So And a pointer indicating the address of the resident load module loaded in the real memory space stored in the segment management means corresponding to the one processor that has finished executing the process by the processor migration means. A system for replacing a resident load module, comprising: segment management rewriting means for rewriting a pointer to the address of another resident load module loaded in the real address space.