JPH03229352A - How to change the program - Google Patents

Abstract

PURPOSE:To allow each processor to cope independently with the state of a program in the own device at the time when abnormality is generated in the own environment, etc., by constituting so that each processor autonomously changes a program existing in the own device to the program corresponding to the environment in the own device. CONSTITUTION:Computers 10 - n0 are connected mutually through a transmission line 1, give and receive data and a program, and each computer 10 - n0 is connected to terminal equipments 11 - n1. In such a state, when the CPU 10, etc., inputs a program developed in the environment being different from the own CPU 10, first of all, the original I/O of its program is confirmed. Subsequently, by referring to the own environment management table 109, a state of the I/O being under the own environment is confirmed, and in the case there is no matching of the own environment and the original I/O of the program, it is autonomously changed to the program corresponding to the environment in the own device. In such a way, in the environment such as the time when abnormality is generated, etc., the program in the own device can autonomously be changed to the program corresponding to its environment.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a program modification method for program development, testing, and execution in a distributed system.

[Conventional technology]

Conventionally, in a distributed system consisting of multiple processing devices connected via a network, a method was considered in which only programs compatible with the environment within the processing device were loaded into the processing device. There was no way to change the program to suit the environment.

[Problem to be solved by the invention]

In the above conventional technology, the processing section and the input/output section of the program are not separated in the program structure, so if the input/output edge of a program in the processing device does not correspond to the environment in the processing device, the program is There is a problem in that a person must change the program to match the environment of the processing device.

An object of the present invention is for each processing device to import a program into its own device and autonomously execute the program from the state of the corresponding program.
It is an object of the present invention to provide a program change method for changing a corresponding program to a program corresponding to the environment within its own device.

Another object of the present invention is to provide a program change method that autonomously changes a program in a processing device to a program corresponding to the environment when an abnormality occurs in the processing device.

Still another object of the present invention is to provide a program change method that autonomously changes the above program to a program compatible with the environment when the environment changes due to expansion of a processing device.

Still another object of the present invention is to provide a program changing method in which each processing device autonomously changes the above program into an executable program corresponding to the environment within the device.

Still another object of the present invention is to provide a program change method that autonomously changes a program received from another environment into a program that matches the environment within its own device in terms of its required capacity and required performance. .

[Means to solve the problem]

In order to achieve the above object, the present invention provides: (1) Each processing device imports a program into white meat and autonomously changes the confession program from the state of the white meat program to a program corresponding to the environment within the own device. (2) Each processing device autonomously changes the program existing in white meat to a program compatible with the environment in the environment at the time of abnormality in its own processing device; (3) Each processing device (4) Each processing device autonomously changes the program existing in the white meat to a program corresponding to the environment when the environment changes due to the expansion of its own device. It is characterized by changing the program to an executable program corresponding to the environment within the device itself.

[Effect]

As described above, in the present invention, each processing device autonomously
Since the program existing in its own device is changed to a program that corresponds to its own environment, each processing device will change the white program when an abnormality occurs in its own environment, when expanding, or when executing a program. It becomes possible to independently respond to the situation.

〔Example〕

Embodiments of the present invention will be described below with reference to the drawings.

FIG. 2 shows the configuration of a multi-computer system to which the present invention is applied, with computers 10, 20, .
...no are interconnected via transmission path 1 and exchange data and programs. As described later, each computer has a built-in arithmetic processing unit Llt and a storage device for storing data and programs, and has a terminal device 1.
tll, 21. ...Connected to nl.

FIG. 1 shows the configuration of a computer 10 as a representative. The processing device 100 is connected to the transmission path 1 via an interface 101, and is also connected to the terminal equipment fill via an interface 102. The disposal bag *ioo is
In addition, an input buffer 103, an output buffer 104 . Program storage memory 105. Data storage memory 106. Content code table 107. It is connected to the memory management table 108 and the self-environment management table 109.

Codes indicating the contents of programs that can be processed by this computer are preset in the content code table 107 by an appropriate method, for example, by an operator via the terminal device 11 or from a supervising computer.

Figure 3 shows a program imported from another environment in C.
A flowchart when executed by a PU (computer) is shown. A case will be considered in which a program having the format shown in FIG. 4 is executed.

The program has an input section (rcv network ms
gL processing section and output section (snd netsark msg
).

It is assumed that the CPU that executes the program has a self-environment management table shown in FIG. 5 set in advance. In the self-environment management table, the input environment is, for example, 1 (eyboard + file.

PI/O, network, and output environment such as CRT, PRINTER, file, P
If there is an I/O network, the I10 instruction is set as shown in FIG. Next, the flowchart of FIG. 3 will be explained in detail. Step 201
Now, when a certain CPU imports a program developed in an environment different from that of its own CPU, it first checks the original Ilo of the program. Step 202
In this step, the CPU refers to the aforementioned self-environment management table shown in FIG. 5 and confirms the state of Ilo under its own environment.

In step 203, the program's original Ilo
Check the current matching of Ilo in the own environment. In Figure 5, the input command (rev keyboard m53) is input to the input environment of the CPU's own environment management table, and the input command (snd CRT msg) is input to the output environment.
There is an output command, the input part of the imported program is (rcvkeyboard msg), and the output part is:
(snd CRT msg), which shows that there is matching in the current situation.

In step 204, the CPU, which confirmed the matching between the original I10 and the current state of the program in step 203, confirms that the original Ilo will be used. In step 205, the CPU converts the program to the original I
At 10, loading starts. Next, the case where there is no matching with the current state at step 203 in FIG. 3 will be described.

FIG. 6 is an example of a remote I10 table created in the CPU when there is no matching between the CPU's own environment and the original I10 of the program.

In the figure, r and s represent an input section (rev) and an output section (snd), respectively.

FIG. 7 is a diagram showing the procedure for creating the remote I10 table shown in FIG. 6. Here, 4 CPUs
Consider a case where (CPUI to CPU4) are connected via a network. Since CPU4 does not have Ilo,
When executing a program on CPU4, use other CPUs (
Ilo of CPUI to CPU3) must be used. In this case, the CPU 4 sends the l10)-rain 901 attached with the content code 900 of the program to be executed onto the network. Each CPU (CPUI to CPU3) sequentially chains messages regarding the confession Ilo to this I10 train 901. The I10 train 901 that has gone around the network is connected to each CPU (CPUI to CPU
3) The message regarding Ilo is conveyed to the CPU 4.

CPU4 has a file on the CPUI, and CPU2 has a CRT.
and keyboard, and a line printer (L/P) for CPU3.
) is connected as the machine 10 from the message 902 of the I10 train 901, and from this message 902, the remote I10 table shown in FIG. 6 mentioned above is created.

The remote I10 shown in FIG. 6 obtained through the above process
The table manages information regarding Ilo of each CPU.

FIG. 8 shows a flowchart when performing the original program I10 remotely. The CPU executing the program checks that there is no matching between the current environment of the CPU and the original I10 of the program, and in step 301, the CPU sends the I10 train to the network and obtains messages regarding the Ilo of other CPUs. Then, from this message, a remote I10 table having a format similar to that shown in FIG. 6 is created in its own CPU.

In step 302, it is checked whether the original I10 exists in the remote e10 table. Step 30
In 2, the original I10 of the program is changed to the remote I10.
If so, in step 303, the CPU transfers the program's original ■10 to the corresponding remote I10.
Convert to Here, the program's original input part (rcvnetwork msg) w output part (sn
d network msg) from the remote I10 table similar to that shown in FIG.
ote keyboard msg) output section to other CP
U's CRT (snd remote CRT msg)
It is said that Next, in step 304, the program with the input/output converted to the remote 110 is compiled. Here, if a compilation error occurs due to conversion of Ilo, the remote I10 must be determined again in order to execute the program.

In this case, along with a compilation error,
Returning to step 302, the remote I10 is determined again.

Then, compiling is performed in step 304, and if no compilation error occurs, program loading is performed in step 305.

As shown in the starting point 6 and above, if the original I10 of the program does not match in each CPU's environment, the CPU will change the Ilo of the other CPU to the program with the program content code 90. train 9
1 to obtain information about other individual Ilo's and create a remote I10 table in its own CP tJ from this information.

This remote I10 table allows you to use the original I10
Convert it to a similar remote I10 and run the program. Next, a case where there is no original I10 in the remote I10 table will be described. If the original I10 is not present in the remote I10, the CPU next checks to see if there is an alternative I10 among itself.

FIG. 9 shows a flowchart regarding self-substitution. In step 302 of FIG. 8, the CPU
When it is confirmed that the original I10 of the program does not exist in the 10 table, a self-substitute management table as shown in FIG. 10 is created in step 404 of FIG. 9 to check whether a self-substitute Ilo exists. do. In the self-substitute management table, for example, keyboard, file, P I/O are input environments as self-substitute input environments.
, network is also a self-substitute output environment,
CRT, PRINTER.

If there is a P I/O network,
0 instruction is set. In step 402 of FIG. 9, the CPU performs step 404 if there is one alternative according to the self-alternative management table. For example, if the program's original input is from the keyboard (rev keyboard)
d + *sg), output is CRT (and CRTm
sg), the alternatives in the case of file (rev
file msg) + printer (snd PRIN
TERmsg). Note that if there are multiple input/output alternatives in step 403, a usage order table as shown in No. 1111 is created, and for example, input alternatives include keyboard, file, P I/O,
Alternatives existing in the CPU may be determined in the order of the network, or alternatively, possible alternatives may be determined in time for humans using a CRT, PRINTER, etc., as in step 405. In this case, if no alternative is specified, the default value is set. Once the alternative has been determined in this way, then in step 406 the input/output is
Compile the program converted into a self-substitute of U.

Here, if a compilation error occurs due to Ilo conversion, and if self-substitution must be re-determined in order to execute the program, the process returns to step 402 and the remote Redetermine I10. Compilation is then performed in step 406, and if no compilation error occurs, program loading and start are performed in step 407. As mentioned above, the original I1 of the program
0 does not match the environment of the CPU and other CPUs, the CPU uses the program's original I
10 into its own substitute I10 and execute the program.

Next, Il which is a replacement for the original I10 of the program.
A description will be given of remote substitution that deals with the case where o is not in the CPU's self-substitution.

FIG. 12 shows a flowchart regarding remote substitution. In step 402 of FIG. 9, the CPU confirms that the program's alternative I10 does not exist in the self-replacement management table, and then checks whether the remote alternative Ilo exists in step 501 of FIG. , create a remote alternative management table as shown in FIG.

FIG. 14 is a diagram showing the procedure for creating the remote alternative management table shown in FIG. 13. Here, four C
PU(CPτ]1 to cpτ2]4).

Consider the case where they are connected by a network. CPU
4 is CPU'4 because it does not have Ilo, and is shown in FIG. Input is from the keyboard (rev keyboard)
tasg),.

When executing a program whose output is CRT (snd CRT msg), other CPUs (CPU] to CPU
3) must be used. Let's consider the case where no CPU on the network has the original output of the program. In this case, CP tJ 4 will output the content of the program to be executed with the code 900.
Rain 901 is streamed onto the network. Each CPU (C
The I10 train 901 that has made one circuit around the network sequentially sends messages regarding the remote replacement of the confession to the I10 train 901.
Each CPU (CPU1 to CPU3) (7) Sends a message regarding I104C to CPU4. In CPU4, CP
It is recognized from the message 902 of the I10 train 901 that PRINTER is connected to U 1, file is to CPU 2, and PIlo is connected to CPU 3 as a remote substitute I10, and from this message 902, the above-mentioned FIG. Create a remote alternate management table that shows the confession.

The remote replacement management table shown in FIG. 13 obtained through the above process manages information regarding the replacement I10 of each CPU.

In step 502 of FIG. 12, if there is a remote replacement in the remote replacement management table shown in FIG. 13 for the original I10 of the program, the process proceeds to step 504. msg) as the remote alternative output (snd PRINTERmsg). In addition, if there are multiple remote input/output alternatives.

Possible remote substitutes may be determined using a use order table similar to that shown in FIG. 11 described above as in step 503, or by making arrangements for humans as in step 405. In this case, if no substitute is specified, , set the default value. Once the replacement has been determined in this way, the program in which the input/output has been converted to the remote replacement is then compiled in step 505. If a compilation error occurs due to the conversion of Ilo, the remote replacement must be redetermined in order to execute the program. In such a case, when a compilation error occurs, the process returns to step 502 to redetermine the remote alternative I10. Then, compiling is performed in step 505, and if no compilation error occurs, in step 506,
Program loading, the original I10 of the program as shown in 1 or more as a start is transferred to a CPU other than the CPU
The PU converts it into a remote alternative I10 and executes the program. If there is no substitute for the program's original I10 on any CPU on the network, input (rcv network msg), output (snd
Run the program as network msg).

When compiling and loading the program, take the following into consideration.

FIG. 15 shows the format of the program.

Program 1000 has content code 1001. Application program 1002. Program information 1005
As, program capacity 1003 (bytes), required performance 1004 (MIPS value), and program body 10
Consists of 06.

FIG. 16 shows a flowchart of evaluation and operation procedures when compiling the program 1000. 1st
51ii! Therefore, the program 1000 includes the performance required by the program as program information 1005 in the data. As the required performance 1004, for example, a MIPS value is used. In step 601, CP
U checks the required performance (MIP S value) 1004 of the program 1000. On the other hand, it is assumed that the CPU has performance values in its own environment parameter table.

In step 602, the CPU checks the performance value (here, β) in the parameter table of its own environment. In step 603, the required performance "(MIps value) 1
Compare the performance value (fj) of 004 and the CPU's own environment,
If the required performance of the program (MP$) 1004 is smaller than the performance value (β), the program is compiled as is. Otherwise, in step 604, program 1000 is modified. In this case, program 10
00, reduce the repeated calculations by the ratio of the MIPS values in Figure 15, or by the predetermined ratio, and program 10.
Adjust the required performance 1004 of 00 to your own environment.

Next, referring to FIG. 15, loading of the program will be explained. As shown in FIG. 15, the program 1000 includes program capacity (bytes) 1003 in the data as program information 10o5. Its capacity is C
If it is smaller than the predetermined capacity of the PU's own environment table,
Must reside in core memory. In addition, program capacity 1003
If it is larger than the predetermined capacity, it is stored on the disk (core non-resident). In other words, the former is loaded into the permanent area, and the latter is loaded into the non-resident area.

As described above, the CPU autonomously compiles and loads programs received from other environments according to its own environment in terms of the required capacity and performance.

According to this embodiment, (1) each processing device checks the program in its own device and autonomously changes the program from those states to a program compatible with the environment in its own device; ) Each processing device autonomously changes the program to a program corresponding to the environment within its own device in the environment when an abnormality occurs within its own device; (3)
) When each processing device changes its environment due to expansion of its own device,
(4) Each processing device can change the program in its own device into an executable program compatible with its environment and operate it.

Furthermore, each processing device can independently respond to overload or underload.

C Effects of the Invention] According to the present invention, each CPU'U autonomously changes the program existing in its own CPU to a program having an input/output section corresponding to the environment within its own CPU. Each C
Programs can be run regardless of the PU environment.

In addition, each CPU stores programs existing in its own CPU.
When an abnormality occurs in your own environment or when expanding, you can change to a program that is compatible with your own and run the program.

Further, each CPU can compile and load programs received from others autonomously in accordance with its own environment in terms of its required capacity and performance.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of one computer in a multi-computer system to which the present invention is applied, FIG. 2 is a block diagram showing the overall configuration of the multi-computer system to which the present invention is applied, and FIG. A flowchart when a certain CPU executes a program imported from another environment, FIG. 4 is a diagram showing the program format, FIG. 5 is a diagram showing the self-environment management table, FIG. 6 is a diagram showing the remote I10 table, Figure 7 is a diagram showing the procedure for creating a remote I10 table, Figure 8 is a flowchart when performing the original program I10 remotely, Figure 9 is a flowchart when performing self-substitution, and Figure 10 is a diagram showing the self-substitution management table. Figure 11
The figure shows a usage order table, Figure 12 is a remote replacement flowchart, Figure 13 is a diagram showing a remote replacement management table, Figure 14 is a procedure diagram for creating a remote replacement management table, and Figure 15 is a program configuration diagram. . FIG. 16 is a flowchart when compiling a program. 1... transmission line, 10, 20. No...computer. 11.21. nl...Terminal device, 100...Processing device, 105...Program #4 storage memory, ]o゛7...Contents code table, 108...Memory management team. ]09...Self environment management table, 90]...l1
0 (-Rain. Figure 1 ■ Figure 5) Figure '-/P RT Key - F Phi 1 ■ Figure hole concave lθ Figure 1 Figure Z Figure nest 3 Figure 14 Country 5 6 Figure

Claims (1)

[Claims] 1. A plurality of processing devices are connected via a network,
In a distributed processing system that transmits programs between processing devices, each processing device imports a program into its own device, checks the program, and autonomously converts the program into a program that can run in its own environment. A method for changing a program characterized by changing the program. 2. Distributed processing according to claim 1, characterized in that each processing device autonomously changes the program in its own device to a program compatible with the environment when an abnormality occurs in its own device. How to reprogram the system. 3. The program changing method for a distributed processing system according to claim 1, wherein each processing device autonomously changes the program to a program compatible with the environment when the environment changes due to expansion of its own device. 4. Claims 1 to 4, characterized in that the program is changed to an executable program corresponding to the environment within the device itself.
3. The method for changing a program in a distributed processing system according to any one of 3. 5. The program for a distributed processing system according to claim 1, claim 2, or claim 3, wherein if the performance required by the program is not satisfied, the program is changed. Modification method. 6. Required capacity for programs received from other environments,
4. The method of changing a program for a distributed processing system according to claim 1, 2 or 3, wherein the program is adapted autonomously to the environment within the own device in terms of required performance.