JP2001202234A - Download method - Google Patents

Abstract

(57) [Summary] [PROBLEMS] To relate to a method of downloading stored contents in communication, monitoring control, or a CAD system, etc., in particular, to flexibly configure a module constituting stored contents between versions of stored contents whose version is changed. Can be changed,
Provided is a download method capable of reducing the amount of data transmission accompanying a version change. When a version change request of stored contents of a program or data is issued, a list of difference modules which is changed between a version before change and a new version is created, and the list is used to arbitrarily change the version. Creates and stores the difference module acquisition table, which is the list of all difference modules, and stores all the modules of the stored contents of the oldest storable version and the data of the difference module to be updated when the version number is sequentially increased. Store.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a CAD system in which a communication system, a supervisory control system, or a center device and a design terminal are arranged at a long distance, and a program and data are also installed in the design terminal ("" CAD "
Means “Computing” using a computer.
er Aided Design ”. ), Etc., in particular, it is possible to change the modules that make up the program or data between any version of the program whose version is changed or any version of the data that constantly changes. The present invention relates to a download method capable of reducing a data transmission amount accompanying a change.

Since downloading a program and downloading data are essentially the same, the description will be limited to downloading a program. or,
The contents of the program may be called "data".

[0003] Originally, in a communication system or a supervisory control system, devices constituting the system are disposed at a long distance, and programs necessary for operating the system are installed in all the devices constituting the system.

[0004] Initially, the CA operated in such a manner that the program of the center device was shared by the remotely located design terminals.
Also in the D system, a program necessary for operating the system has been installed in a remotely located design terminal.

[0005] The program for operating the above system is:
Versions are often changed for reasons such as adding system functions or fixing bugs in programs. In order to efficiently perform the version change, a so-called download technique of transferring the version-changed program from the device that is the management source of the program to the device that is the distribution destination of the program through a transmission line has been put into practical use. I have.

[0006] By the way, in version change, not only version upgrade, but also version downgrade may be performed especially when a bug is found in a new version of a program. -Regardless of down, not only version change between consecutive versions, but also version change may be made skipping versions.

[0007] Therefore, there is a need for a download system that can flexibly respond to a version change between arbitrary versions.

[0008] Since it is economically disadvantageous to lay a transmission line dedicated to download, a transmission line used for downloading is usually provided with a transmission line provided for transmitting information inherent in the system. Is used.

[0009] Therefore, there is a need for a download system that does not hinder the transmission of information inherent in the system due to the transmission load accompanying the download.

[0010]

2. Description of the Related Art As described above, the present invention is a technique which can be commonly applied to a communication system, a supervisory control system, a CAD system or the like, and the above-mentioned system has an essentially similar configuration. However, the names of the components of the system are different from each other. Moreover, even if it is limited to a communication system, it can be said that the architecture of the system is innumerable. Therefore, it is extremely difficult to describe a general system in mind.

Therefore, in this specification, PDS (Passive), which is an access system using an optical transmission line, is used.
Abbreviation for Double Star. ) Let's take the system as an example.

FIG. 21 shows the configuration of the PDS system.

In FIG. 21, reference numeral 1 denotes an operation system for centrally managing the PDS system (“Op” in the figure).
S ". “OpS” stands for “Operation Syste
Abbreviation for "m". In the drawings, the same applies hereinafter. ).

Reference numerals 2-1 and 2-2 denote an optical line terminator ("OLT" in the figure, which is a master station in the communication function in the PDS system.
ticalSubscriber Line Terminator ". In the figures, the same applies hereinafter. ), The optical line terminator 2-1 has an operation system interface (“O” in the figure) that communicates with the operation system.
pS-IF ". "IF" means "Interface
Is an abbreviation for In the figures, the same applies hereinafter. ) 21, a router interface for performing communication with a router arranged in a communication network to which the PDS system is connected (abbreviated as “router IF” in the figure. In the figure, the same applies hereinafter) .) 22-1 and 22-
2. Communication between the operation system interface 21 and the storage unit 23 for storing programs and data necessary for the operation of the router interfaces 22-1 and 22-2, and the router interface 22-1 or 22-2. The optical subscriber unit to be performed (abbreviated as "OSU" in the figure. "OSU" is an abbreviation for "Optical Subscriber Unit". In the figure, the same applies hereinafter). 1, 24-2 and 24-3, and a maintenance terminal 25 serving as a man-machine interface device with the optical line terminator 2-1.

Reference numerals 3-1, 3-2 and 3-3 denote optical network units (abbreviated as "ONU" in the figure, "O").
NU is an abbreviation for “Optical Network Unit”. In the figures, the same applies hereinafter. )so,
Regarding the optical network unit 3-1, an Ethernet interface for communicating with the optical subscriber unit 24-1 (abbreviated as “Ether IF” in the figure). It comprises a storage unit 32 for storing programs and data required by the Ethernet interface 31. In general, the Ethernet interface is a “line card for computer”.

Focusing on only a part of FIG. 21, the original communication function of the PDS system is that of a router connected to a router arranged in a communication network to which the PDS system is connected.
Interface 22-1, router interface 22
-1 and the optical subscriber unit 24-1 and the Ethernet interface 31.

The supervisory control function in the PDS system is realized by the operation system 1 which supervises the supervisory control, and information transmission for supervisory control including download is transmitted to the entire PDS system via the operation system interface 21. Done.

Now, there are mainly two types of downloading in the conventional PDS system.

The first is a download by an instruction command from the operation system, and the second is an optical line
This is a download from the maintenance terminal of the terminator.

FIG. 22 shows a download sequence according to an instruction command from the operation system. The sequence is as follows.

Download data transfer is performed from the operation system to the operation system interface.

Although the received data may be transferred to the optical network unit as it is, since the versions required for a plurality of optical subscriber units are often different, the operation system interface stores the received data in the storage unit. Hold.

Next, a download instruction command is transferred from the operation system, and the operation
The system interface transfers the download instruction command received from the operation system to the router interface.

The router interface that has received the download instruction command acquires data from the storage unit in accordance with the download instruction and downloads the data to the optical network unit.

The optical network unit that has received the download data transfer returns a download response, and the download response is transferred to the operation system via the router interface and the operation system interface.

In the case of downloading from the maintenance terminal of the optical line terminator, although the sequence is not shown, it is possible to connect the maintenance terminal directly to the router interface and individually designate the Ethernet interface to download. It is considered.

[0027]

Basically, the entire program of a required version is downloaded whether it is downloaded from the operation system or from the maintenance terminal of the optical line terminator.

When the entire required version of the program is downloaded, the amount of transmission associated with downloading the transmission line between the operation system and the optical line terminator and between the optical line terminator and the optical network unit increases.

For this reason, the monitoring and control function of the PDS system by the operation system is hindered, and transmission of original communication information on the user line between the optical line terminator and the optical network unit is hindered.

Although the maintenance terminal in the operation system is not shown in FIG. 22, download from the operation system is actually performed according to an instruction from the maintenance terminal.

Therefore, the transmission line between the operation system and the optical line terminator or the transmission line between the optical line terminator and the optical network unit can be downloaded from the operation system or from the maintenance terminal of the optical line terminator. In order to reduce the transmission load associated with the download of the line, the maintenance person selects and downloads only the program module (hereinafter simply referred to as "module") that should be actually changed from the required version of the program. In this case, there is a high possibility that a defect will enter.

If the wrong module is downloaded, the optical network unit from which the module was downloaded is forced to go down, so that no flaw in the selection of the module to download is allowed.

[0033] An artificial defect caused by the download also occurs when the version is continuously changed in one direction, but the actual version change includes a version up and a version down, and the version must be skipped. There are many things that must be done.

Therefore, it is extremely dangerous for the maintenance person to select a module to be downloaded.

Further, even if the maintenance person does not select the module to be downloaded, for example, if the router interface selects the module to be downloaded based on the version change information, the module management in the program is complicated at present, and the There is a great risk of interfering with other processing functions of the interface.

In view of the above problems, the present invention has a communication system, a supervisory control system, or a center device and a design terminal arranged at a long distance, and a program and data are installed in the design terminal in a semi-independent manner. With respect to a program or data download method in a CAD system or the like, a module constituting a program or data can be arbitrarily and easily changed between a program whose version is changed and an arbitrary version of data that constantly changes. Moreover, it is an object of the present invention to provide a download system capable of reducing the amount of data transmission accompanying a version change.

[0037]

The first means of the present invention is as follows.
When a version change request is made, the module that changes between the version before the change and the version after the change ("Module that changes between the version before the change and the version after the change" is called the "difference module Is created, and the list is used to create an entire list of difference modules between arbitrary versions (this is called a “difference module acquisition table”). Technology.

According to the first means of the present invention, when a version change is requested, the difference module between the version before the change and the version after the change can be selected by referring to the difference module acquisition table. Therefore, the management of the module is simplified, and the processing functions inherent in the system are not hindered.

The second means of the present invention, when instructing download, refers to the difference module acquisition table, selects a module to be downloaded from the stored difference modules, and selects the selected module. Only download technology.

According to the second means of the present invention, the amount of data transmitted between the device for instructing download and the device for downloading is only download instruction information, and between the device for downloading and the device for receiving download. Is limited to the transmission amount of the difference module between specific versions, so that the transmission load on the transmission line can be reduced.

Moreover, in the first means of the present invention,
Also in the second means, since the maintainer is not directly involved in selecting a difference module to be downloaded, there is no room for a defect in the download.

[0042]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS In order to make the technology of the present invention easy to understand, the description will be made below with specific examples. However, it is needless to say that the technology of the present invention is not limited to the examples described later. Absent.

FIG. 20 shows an example of changing the version of a program.

In FIG. 20, A to H denote the names of the modules constituting the program, and the number attached to the module name denotes the version number of the module version of the module. The version number of the version of the entire program is described as, for example, “version 1”.

Accordingly, in version 1 of the program, the version numbers of all modules are as follows, and as the version advances, the version number of the changed module increases.

Here, as shown by the thick solid line in FIG. 20, it is assumed that the version number of the module is changed as follows when the version is upgraded.

That is, when the version of the program is upgraded from version 1 to version 2, the version numbers of the modules A and C are advanced, and the version numbers of the other modules remain at version 1. Is changed from version 2 to version 3, the version number of module A goes to
When the version number of the other module remains at version 2 and the version of the program changes from version 3 to version 4, the version number of module B advances and the version number of module H increases. It is assumed that the version numbers of the other modules remain at version 3.

Therefore, the difference modules associated with the version change are A, C, A, G, B and H. Then, as described later, a difference module between arbitrary versions can be obtained by the difference module.

FIG. 1 shows a difference module acquisition table for version change and how to create it (No. 1).
This corresponds to the version change shown in FIG.

In FIG. 1, when m and n are positive integers satisfying n> m, R _mn is a list of modules that are changed when the version of the program is upgraded from version m to version n. means. For example, R ₁₂ from the program version 1 Version 2
The module name and version, that is, A and C, which are changed when the version is upgraded. Note that there are cases where "," does not enter between m and n as in _Rmn , and cases where "," enters as in Rm _{, n} , which should be interpreted as having the same meaning. The same applies to S _mn and S _{m, n} described later.

Then, R having a relationship of n = m + 1
_mn is a list of modules that are changed when the version of the program is sequentially upgraded, and R _mn having a relationship of n> m + 1 is a list of modules that are changed when the version of the program is skipped and upgraded. .

Here, skipping and upgrading of the program version means that, for example, when most optical network units are operating with the version 3 program, only a specific optical network unit is version 1 This can happen when the program of the specific optical network unit is aligned to version 3 while it is running.

Now, in order to skip from version 1 to version 3 and upgrade the version, the version of module A is changed to version 1 and the version of module C is changed to version 1 in FIG. , Module G
It can be seen that the version number of should be changed to.

[0054] This makes the A and G is its version number and module name stored in R ₂₃ of Figure 1 after having copied to R _13, the module name is not included in the R ₂₃ in R ₁₂ and the C is its version number it can be seen that obtained by copying to R _13. This is represented by arrows with (1) and (2) in FIG.

Similarly, a list R ₂₄ of difference modules when the version is upgraded by skipping from version 2 to version 4 is obtained by copying B and H from R ₃₄ ,
Be obtained by copying the A and G are not included in the R ₃₄ in R _23. This is represented by arrows with (3) and (4) in FIG.

The list R ₁₄ of the difference modules when the version is upgraded by skipping from version 1 to version 4 is a copy of B and H from R ₃₄ and R ₁₃
A not included in R ₃₄ in, it is obtained by copying the C and G. This is represented by arrows with (5) and (6) in FIG.

As described above, A, C, A, and G, which are information on version change when version upgrade is performed sequentially.
, B, and H, a difference module between any versions can be designated. Therefore, R _mn in FIG.
That is, a table constituted by (m = 1 to 3, n = 2 to 4) is called a difference module acquisition table.

FIG. 2 shows a module (part 1) that is required for a minimum version change.

In FIG. 2, S₀Constitutes a program
Data of all modules₀Store memory
The region will be referred to as a base region. Also, m and n are n>
When m is a positive integer satisfying S_mnIs version m
Version when upgrading to version n
The data of the module to be changed in _mn
Is referred to as a difference area.

As described above, when the version is changed as shown in FIG. 20, A, C, A, G, and B, which are the information of the version change at the time of version upgrade in order.
And H, it is possible to specify a difference module between arbitrary versions.
(In FIG. 2, it is described as “V1”. In the figure, the data S0 may be similarly indicated.) The data S ₀ of all modules is stored in the base area, and the version S is changed from version 1 to version 2. Modified version of module A
(Hereinafter, described as module A in order to simplify the representation.) And module C data S ₁₂ and stored in the differential region, module A and G data to be changed when vary from version 2 to version 3 stores S ₂₃ the difference region, module B and H of the data S ₃₄ to be changed when vary from version 3 to version 4
Is stored in the difference area, the data of the module that needs to be changed between arbitrary versions can be definitely selected by referring to the difference module acquisition table in FIG.

It should be noted that “S ₀ ” is exactly the data of all the modules of version 1 and “S _mn ” means the data of the module that is changed when the version is changed from version m to version n. It should be noted that, for simplicity of expression, “S ₀ ” may be used in the meaning of the base region and “S _mn ” may be used in the meaning of the difference region. Similarly, “R _mn ” exactly means a list of modules that are changed when a change is made from version m to version n, but for simplicity of expression, “R _mn ”
Note that is sometimes used as a difference area.

In the above description, the case where the difference module acquisition table of FIG. 1 is used for version up has been described. However, although the processing is slightly congested, it can be used for version down.

[0063] For example, if the version down from version 4 to version 3 refers to R ₁₄ in FIG. 1, among the data of each module stored in the difference region S ₁₂ to S ₃₄ in FIG. 2 A, B, C, G and H
Is selected, a version 4 program is generated by replacing the module stored in the base area S ₀ of FIG. 2, and the version numbers of the modules B and H changed at the time of transition from version 3 to version 4 are set to By performing the process of returning, version 3 can be generated.

Since the principle of the present invention has been clarified by the above description, the method of generating the difference module acquisition table in FIG. 1 and the module data required for the minimum version change in FIG. 2 will be specifically described below.

FIG. 3 is a diagram for explaining the storage of difference module data conforming to FIG. 1 with an infinite storage area. In the case where only a module to be updated is given, the process of version upgrade of a program will be described. Is shown.

FIG. 3A shows the processing when a request to save version 1 is made for the first time.

Before the first storage of the version 1 is requested, there is no information on the program, so that nothing is stored in the base area or the difference area. Since the storage of all modules of version 1 is requested there, the version 1 program is stored in the base area. Since only version 1 of the program exists, nothing is stored in the difference module yet.

Therefore, after performing the above-described processing, a transition is made to a state in which the data of all the modules constituting the version 1 program is stored in the base area and nothing is stored in the difference area.

FIG. 3B shows version 2 in the above state.
This is the process to be performed when the storage of a file is requested. As described above, when changing from version 1 to version 2, only the data of the module that needs to be changed is supplied.

At this time, the data S _{12 of the} module to be changed when the version 1 is changed to version 2
Is stored in the difference area 1.

Therefore, after the above processing, the data of all the modules constituting the version 1 program is stored in the base area S _0, and the version 1 is stored in the difference area 1.
Module data S ₁₂ of which require changes when changing the version 2 from transits to state stored.

[0072] Then, although not shown in FIG. 3, stores a version 1 version Module name require changes when changing the 2 and version number (this case) is the R ₁₂ of the differential module acquiring table Is done.

FIG. 3C shows version 3 in the above state.
This is the process to be performed when the storage of a file is requested.

At this time, the data S _{23 of the} module changed when the version 2 is changed to the version 3
Is stored in the difference area 2.

Therefore, after the above processing, the data of all the modules constituting the version 1 program is stored in the base area S _0, and the version 1 is stored in the difference area 1.
From stored data S ₁₂ modules require changes when changing the version 2, the data S ₂₃ modules require changes when it is changed in the differential region 2 from version 2 to version 3 is stored Transitions to the

Then, although not shown in FIG. 3, the version 2 is further stored in R ₂₃ in the difference module acquisition table.
Module name and version number require changes when changing the version 3 are stored from, name and version number of the module is stored, which require changes when changing from version 1 to version 3 to R ₁₃ .

FIG. 3D shows version 4 in the above state.
This is the process to be performed when the storage of a file is requested.

At this time, the data S _{34 of the} module changed when the version 3 is changed to version 4
Is stored in the difference area 3.

Therefore, after the above processing, the data of all the modules constituting the version 1 program is stored in the base area S _0, and the version 1 data is stored in the difference area 1.
From stored data S ₁₂ modules require changes when changing the version 2, the data S ₂₃ modules require changes when it is changed in the differential region 2 from version 2 to version 3 is stored , a transition to a state in which data S ₃₄ modules require changes when it is changed in the differential region 3 from version 3 to version 4 is stored.

Then, although not shown in FIG. 3, the difference module acquisition table further stores version 3 in R _34.
Module name and version number require changes when changing the version 4 are stored from, the name and version number of the module need to change is stored when changing from version 1 to version 4 to R ₁₄ .

Here, since it is assumed that the storage area is infinite, when the storage of the version after the change is requested, the same processing as described above may be continued.

FIG. 4 shows a difference module acquisition table and a difference module
5 is a flowchart of data creation and storage. Hereinafter, FIG.
The description will be made along the reference numerals.

S1. Receive a program update request.

S2. The program version number N (N is a positive integer) is read from the program update request.

S4. It is determined whether or not the version number N of the program is 1.

If it is determined that the version number N of the program is 1 (Yes), the process jumps to step S12.

S12. When the version of the program is 1,
Since all the modules of the version 1 of the program is supplied, the process ends by storing all modules of version numbers constituting the version 1 programs the base region S _0.

S5. If it is determined in step S4 that the version number N of the program is not 1 (No), the difference information corresponding to the received update request is stored in _{RN-1, N.} Since the version of the program is changed sequentially, N = 2 in this case, so that the difference information which is the name and version number of the difference module corresponding to the received update request is R
It will be stored in _1.2 .

S6. Then, as described with reference to FIG. 2, it is necessary to store the received difference module, so that the received difference module is stored in the difference area _{SN-1, N.}
Since N = 2 in this case, the received difference module is stored in the difference area S _1,2 .

S7. Since the version number of the program is not 1, in order to generate a difference module acquisition table, it is necessary to generate difference information when the version number is skipped and up in addition to difference information when the version number is sequentially increased. There may be. Therefore, in addition to the difference information when the version number is sequentially increased, it is determined whether it is necessary to generate difference information when the version number is skipped and increased, and whether or not all the difference information is generated. Is set to 1 for a counter K used to perform the operation.

If the version number of the program is 2, the version number is sequentially changed from version 1 to version 2.
Since there is only a case where the program is updated, the process may be terminated. When the version of the program is 3 or more, the program may be skipped and upgraded, so that the difference information corresponding to the skip needs to be stored in the difference module acquisition table. There is. For this, S8. Program version N
And the value of the counter K, that is, whether NK is 1 is determined.

In this case, since the version number of the program is 2 and the value of the counter K is 1, it is naturally determined that NK = 1 (Yes), and the process ends.

Next, when a change to version 3 is requested, No is determined in step S4, and the processing of steps S5 to S7 is performed.

At this time, since N is 3 and K is 1,
In step S8, No is determined, and the process proceeds to step S9.

S9. A difference information stored in the _{R N-1, N, R} N-1, the difference information is not included in the _N R _N-1-K, couples removed from _N-1 (this, in FIG. ' R _{N-1, N} , R
_N-1-K, the difference _{between N} ”. Since then,
In the figure, they are similarly indicated. ).

In this case, since N = 3 and K = 1, R
A difference information stored in the _{2, 3,} the difference information is not included in R ₂ bonded removed from R _{1, 2.} That is, FIG.
Then, the processing shown in (1) and (2) is performed.

S10. The difference information acquired in step S9 is stored in _{RN-1-K, N.}

In this case, since N = 3 and K = 1, R
A difference information stored in the _{2, 3,} the difference information of the difference information not contained in R ₂ bonded removed from R _{1, 2} R
Store in _1,3 .

S11. Add 1 to K to get a new K,
Jump to step S8.

Then, since N = 3 and K = 2, NK
= 1, the determination is Yes, and the process ends.

Similarly, when the program version advances to 4, the difference information is stored in _R3.4 in step S5,
In step S5, the difference module is stored in _S3,4 .

Next, 1 is set to K in step S7.
In this case, since NK is not 1, difference information between version 2 and version 4 is generated in step S9, stored in _R2,4 in step S10, K is incremented to 2, and step S8 is performed. Jump to

[0103] is not a N-K = 1 in this case, it generates the difference information version 1 and version 4 at step S9, and stored in R ₁₄ in step S10, then stepped to K in three steps Jump to S8.

Then, since NK = 1, it is determined to be Yes in step S8, and the process ends.

That is, by the processing shown in the flowchart of FIG. 4, when the storage area shown in FIG. 3 is infinite, the operation of storing the difference module data conforming to FIG. 1 can be realized.

However, since it is usually impossible to secure an infinite storage area for the difference module data, it is necessary to consider a case where the storage area is limited.

FIG. 5 is a view for explaining storage of difference module data conforming to FIG. 1 when the storage area is limited.
In the case where only the update module of the version after the update is given, the processing after the storage area is completely used is shown along the course of the version upgrade of the program.

FIG. 5 shows the processing after the request to save version 5 on the assumption that the storage area is used up when version 4 is saved. And
As a matter of course, the processing before storing all the storage areas after storing the version 1 is the same as the processing shown in FIG.

FIG. 5A shows the processing when a request to save version 5 is made in a state where up to version 4 has been saved.

Since up to version 4 has been saved, the initial state of this state is equal to the state after the state transition of FIG. 3D, and FIG. 5 differs from FIG. 3 in that only three difference areas can be secured. That's what it means.

Since only three difference areas can be secured,
In order to save the version 4 and version 5 difference modules, it is necessary to replace and save the difference modules already stored in the difference area. In this case, the oldest difference module is most likely to be used. So low
It is preferable to store the version 4 and version 5 difference modules in exchange for the version 1 and version 2 difference modules.

However, the difference modules S _1,2 of version 1 and version 2 stored in the difference area 1 are simply deleted, the difference modules of version 4 and version 5 are stored, and the difference areas S _4,5 are stored. alone is, information connecting between the differential module program S ₀ and version 2 or a later version 1 stored in the base region is lost.

Therefore, after the version 1 program S ₀ stored in the base area is overwritten with the difference module S _1,2 stored in the difference area 1 and converted into a version 2 program, The difference modules 4 and 5 are copied to the difference area 1 to obtain new difference modules _S4 and _S5 .

That is, when the state of the storage area is changed by the above processing, the version 2 program is stored in the base area, and the version 4 and version 5 are stored in the difference area 1 in which the difference module of version 1 and version 2 is stored. stored difference module S _{4, 5} are other differences regions remain in the initial state of the process.

FIG. 5B shows the processing when a request to save version 6 is made in a state where up to version 5 has been saved.

In this case, the difference module S _2,3 between version 2 and version 3 stored in the difference area 2
Since but the oldest, the difference module S _2,3 stored in the differential area 2 by overwriting the base region, the program stored in the base region and version 3, has stored the difference module S _2,3 The difference module of version 5 and version 6 is stored in the difference area 2.

FIG. 5C shows the processing when a request to save version 7 is made in a state where up to version 6 has been saved.

In this case, the version 3 and version 4 difference modules S _3,4 stored in the difference area 3
Is the oldest, the difference module S _3,4 stored in the difference area 3 is overwritten on the base area, the program stored in the base area is set to version 4, and the difference area S _3,4 is stored. 3 stores the difference module between version 6 and version 7.

FIG. 5D shows a process when a request to save version 8 is made in a state where up to version 7 has been saved.

In this case, the difference module S _4,5 between version 4 and version 5 stored in the difference area 1
Is the oldest, the difference module S _4,5 stored in the difference area 1 is overwritten on the base area, the program stored in the base area is set to version 5, and the difference area in which S _4,5 is stored 1 stores the difference modules S ₇ , 8 between version 7 and version 8.

That is, when the storage area is finite, the number of difference areas can be limited. Therefore, in order to store a newly given difference module, the oldest difference module is overwritten on the base area and stored in the base area. The version number of the program is advanced, and a new difference module to be given is stored in the difference area storing the oldest difference module.

That is, a finite difference area is used in the order of the ring as a difference area for storing a newly given difference module.

FIG. 6 shows a difference module acquisition table and a difference module
This is a flowchart for creating and storing data, showing processing when only a module to be updated at the time of version update is given. Hereinafter, description will be made along the reference numerals in FIG.

Here, the flowchart of FIG. 6 is obtained by inserting step S3 between steps S2 and S4 in the flowchart of FIG. 4, and adding steps S13 to S22 to the flowchart of FIG.

First, step S3 is a step for determining whether or not the storage area serving as the difference area has been used up due to the upgrade of the program, and the version number N of the program can be stored in the storage area. This is a step inserted to determine whether the number M of program generations has been exceeded.

According to the example of FIG. 5, since there are three difference areas, four generations of programs can be stored together with the base area. Therefore, in the example of FIG. 5, the number M of program generations that can be stored in the storage area is four.

Therefore, after the storage of version 1 is requested for the first time and before the storage of version 4 is requested, the version number N of the program is smaller than or equal to 4, so that it is determined No in step S3 and step S4 The processing from step S12 is performed.

Since the processing in steps S1, S2 and S4 to S12 is exactly the same as the processing in the flowchart shown in FIG. 4, when the version of the program is 4 or less, the processing described with reference to FIG. When the processing of version 4 is completed, the version 1 program is stored in the base area, and the difference module S _1,2 of version 1 and version 2 is stored in the difference area _1.
Is stored in the difference area 2, and the difference module _S3,4 of version 3 and version 4 is stored in the difference area 3, and the difference module _S3,4 of version 3 and version 4 is stored in the difference area 3. I have.

In this state, when a difference module between version 4 and version 5 is given and storage of version 5 is requested, the version number N of the program is 5, and the number M of generations that can be stored is 4, It is determined as Yes in step S3, and the process jumps to step S13.

S13. The difference module S _{NM, N- (M-1)} stored in the difference area is overwritten with a module of the same name stored in the base area.

In this case, since N = 5 and M = 4, in the case of the version update shown in FIG. 20, the version number module A and the version number module C stored in the difference area 1 are the base area. 20 is overwritten on the version 1 program stored therein, and is changed to the version 2 program in FIG.

S14. The difference module _{SNM, N- (M-1)} stored in the difference area is deleted.

In this case, since N = 5 and M = 4, the difference modules S _1,2 stored in the difference area 1 are deleted.

S15. R of difference module acquisition table
_{NM, N- (M-1)} , R _{NM, N- (M-2)} , ..., R
Delete _{NM, N- (M- (M-1))} .

In this case, since N = 5 and M = 4, R
_1,2 , R _1,3 and R _1,4 are deleted.

S16. The difference information corresponding to the received update request is stored in _{RN-1, N.}

In this case, since N = 5, the received difference information is stored in R _4,5 .

S17. Then, since the received difference module S _{N-1, N} is a difference module to be saved, it is stored in the difference area where the difference module deleted earlier is stored.

In this case, since the received difference module is S _4,5 , it is stored in the difference area 1 in which the difference module S _1,2 has been stored.

Here, when a new difference module is received, which difference area is stored after overwriting the difference module stored in the base area can be determined by the following processing.

That is, when the number of difference areas is L, (N-1) is divided by the number L of difference areas by an integer operation, and when a remainder other than 0 remains, a difference of a number equal to the number of the remainder is obtained. An area may be selected, and when divisible, the L-th difference area may be selected. Here, if the number L of difference areas is represented by the number M of generations that can be stored, L = (M−1).

When the version number is 1, (N-1) = 0 and the remainder of (N-1) / L becomes 0. In this case, however, the entire program is simply stored in the base area. Is not stored in the difference area.

For example, consider the case where the number L of difference areas is three.
You. When the version number of the program advances to 2, (N-1) = 1
Since the quotient of (N-1) / L is 0 and the remainder is 1, the difference area
1 to difference module S_1,2Stores the version of the program
Goes to 3, (N-1) = 2 and the quotient of (N-1) / L
Is 0 and the remainder is 2, so the difference module S
_2,3Is stored, and when the version number of the program advances to 4, (N
-1) = 3, the quotient of (N-1) / L is 1 and the remainder is 0
In the difference area 3, the difference module S_3,4Can be stored
No.

When the version number of the program advances to 5, (N-1) = 4, the quotient of (N-1) / L is 1, and the remainder is 1, so that the difference module S stored in the difference area 1 is changed.
After overwriting the base areas ₁ and ₂ and deleting them, the difference modules S ₄ and ₅ are stored in the difference area 1. Further, when the program version number advances to 6, (N-1) = 5 and (N-1)
Since the quotient of / L is 1 and the remainder is 2, the difference module S _{2, 3} stored in the difference area 1 is deleted after overwriting the base area, and the difference modules S ₅ , ₆ are stored in the difference area 2. , When the program version goes to 7, (N-1) =
In step 6, since the quotient of (N-1) / L is 2 and the remainder is 0, the difference module S _3,4 stored in the difference area 3 is deleted after overwriting the base area, and the difference module S _6,7 May be stored in the difference area 3, and then the above processing may be repeated.

Since the flowchart of the above processing can be easily conceived by those skilled in the art, illustration thereof is omitted.
Steps for performing the same processing appear in the following drawings, but will not be described each time.

Now, the description returns to the flowchart of FIG.

S18. The counter K is set to 1.

S19. It is determined whether the number obtained by subtracting 1 from the number M of storable generations is equal to the value of the counter K.

This is a determination for generating all the difference information between versions for which version numbers are to be skipped and for knowing whether or not the difference module acquisition table has been completed. The reason for comparing M-1 and K can be seen in FIG.

That is, when the number of generations is 4, R_3,4Is stored
R after_2,3And R_3,4And from R _2,4To generate R
_1,3And R_3,4And from R_1,4Generates the difference module
File acquisition table is completed. In other words,
If the difference information between the versions is generated twice, the difference module
Since the acquisition table is completed, the difference information is available until K is 2
And if K equals 3 and M-K equals 1,
The generation of the difference information may be ended.

If the number of generations M is 5, if three pieces of difference information between the versions to be skipped are generated, the difference module acquisition table is completed. Therefore, the difference information generation can be terminated only by M-1 = K It is when it became.

Now, since M = 4 and K = 1 in this case, it is determined to be No, and the process shifts to step S20.

S20. Difference information is generated from RN _{-1, N} and _{RN-1-K, N-1} . This meaning is the same as that described in step S9 of FIG.

In this case, difference information is generated from R _4,5 and R _3,4 .

S21. The difference information _{RN-1-K, N} generated in step S20 is stored.

In this case, the difference information R _3,5 is stored in the difference module acquisition table.

S22. Add 1 to K to get a new K,
Jump to step S19.

In this case, since M = 4 and K = 2, No is determined in step S19, and the processes in steps S20 to S22 are performed.

That is, the difference information is stored in the generated R _2,5 from R _4,5 and R _2,4, and 1 is further added to K to obtain K = 3.
And jumps to step S19.

In this case, since M = 4 and K = 3, it is determined to be Yes in step S19, and the process ends.

Here, the case where the version of the program has advanced to 5 has been described. However, even if the version of the program becomes 6 or later, the generation of the difference module acquisition table and the storage of the difference module are performed in the same manner according to the flowchart of FIG. be able to. Even if the number of generations of the program that can be saved is other than four, the generation of the difference module acquisition table and the storage of the difference module can be performed in the same manner according to the flowchart of FIG.

The above description has been directed to the creation of a difference module acquisition table and the storage of difference modules when a difference module between versions is given when a version is changed.

However, the creation of the difference module acquisition table and the storage of the difference modules are possible even when all the modules of the changed version are given when the version is changed.

FIG. 7 is a diagram for explaining the storage of difference modules when the storage area is infinite and all updated modules are provided. It is shown along with the process of upgrading the version of the program.

FIG. 7A shows the processing when the storage of version 1 is requested for the first time. This is exactly the same as FIG. 3A.

FIG. 7B shows version 2 in the above state.
The difference from the process shown in FIG. 3B in the process when the storage of the file is requested is that a difference module must be generated when shifting from version 1 to version 2.

This is done by comparing the version 1 with the version 2 and extracting a module whose version number has been changed (this is expressed as "difference" in the figure), and the difference module S1 _{, 2} is stored in the difference area 1. Therefore, when the above processing is completed, the state changes, and the base area stores the version 1 program, and the difference area 1 stores the difference information _S1,2 .

FIG. 7C shows version 3 in the above state.
This is the process to be performed when the storage of a file is requested.

At this time, first, the version 1 program stored in the base area is compared with the newly provided version 3 program, and a difference module between them is generated. This is shown in (1) of FIG.

Next, a version 2 is obtained from the difference modules of version 1 and version 3 and the difference module of version 1 and version 2 stored in the difference area 1.
And a version 3 difference module. this is,
What is necessary is just to combine the difference modules of version 1 and version 3 with the modules that are not included in the difference modules of version 1 and version 3 among the difference modules of version 1 and version 2.

[0171] Then, store the generated version 2 and the differential module version 3 as described above in the difference region 2 as S _2,3. Therefore, when the above processing is completed, the state transitions to a state where the version 1 is stored in the base area, the difference information S _1,2 is stored in the difference area 1, and the difference information S _2,3 is stored in the difference area 2. become.

When the storage of version 4 in FIG. 7D is requested, the same processing as in FIG. 7C may be performed. Since it is now assumed that the storage area is infinite, if the storage of version 5 or later is requested, the same processing is performed to increase the difference area and store the difference module. Good.

Since the storage of the difference information can be easily inferred from the drawings already described and the description based thereon, the description and illustration are omitted.

FIG. 8 is a flowchart of the creation and storage of a difference module acquisition table and difference module data when the storage area is infinite and all updated modules are provided. Hereinafter, description will be made along the reference numerals in FIG.

S31. Receive a program update request.

S32. From the update request to the program version N
(N is a positive integer).

S34. It is determined whether or not the version number N of the program is 1.

If it is determined that the version number N of the program is 1 (Yes), the process jumps to step S46.

S46. The version 1 program is stored in the base area, and the process ends.

On the other hand, if it is determined in step S34 that the version number N is not 1 (No), the flow shifts to step S35.

S35. Set 0 to the counter K.

S36. Extract the difference between version 1 and version N.

In the case where the versions are successively upgraded, first, N = 2. In this case, the difference between version 1 and version 2 is extracted, and in the case of FIG.
Data of A and C are obtained as a difference module.

S37. Since the difference information can be known from the difference module of version 1 and version N obtained in step S36, the difference information R including A and C
_{1 and N} are stored in the difference module acquisition table.

In this case, since N is 2, the difference information A and C are stored in R _1,2 .

S38. It is determined whether or not the version number N is 2.

When the version number N is 2, the module obtained as the difference between version 1 and version 2 needs to be stored as the difference module S _1,2 , and the version number N is 3
In the above case, since the module obtained as the difference between version 1 and version N is not stored as the difference module, the above determination is made.

S39. When N is determined to be 2 in step S38, the store module obtained in step S36 to the difference module S _{1, 2,} step S4
Go to 0.

On the other hand, if it is determined in step S38 that the version number N is not 2 (No), the process jumps to step S40.

S40. Add 1 to K to get a new K,
It moves to step S41.

In this case, the new value of K is 1.

S41. It is determined whether or not NK = 1.

This determination is for determining whether or not it is necessary to generate difference information between the versions to be skipped and whether or not all the difference information between the versions to be skipped has been generated.

When it is determined that NK is 1 (Yes), the processing is terminated.

In this case, since N is 2 and K is 1, the process ends.

Next, when version 3 is given,
In step S36, the difference between version 1 and version 3
Extracted and the difference information obtained from the difference in step S37
Report R _1,3Is stored in the difference module acquisition table.

In the case of version 3, since there is no need to store the difference module between version 1 and version 3, the process jumps from step S38 to step S40 and increments K to 1.

In this case, No is determined in the step S41, and the process shifts to the step S42.

S42. Difference information is generated from R _{1, N} and R _{1, NK} .

In this case, difference information is generated from R _1,3 and R _1,2 .

S43. The difference information R _{NK, N} is stored in a difference module acquisition table.

In this case, the difference information R _2,3 generated from R _1,3 and R _1,2 is stored in the difference module acquisition table.

S44. Here, it is determined whether or not K is 1.

If K is 1, the difference information obtained in step S42 is difference information between versions having one different version number. Therefore, it is necessary to store a module corresponding to the difference information as a difference module. Is not 1, the difference information obtained in step S42 is the difference information between the versions to be skipped, and there is no need to store the module corresponding to the difference information as the difference module.

In this case, since K is 1, the flow shifts to step S45.

S45. The difference module S _{N−1, N} corresponding to the difference information obtained in step S42 is stored, and
Jump to 40.

In this case, the difference module S _{2, 3} corresponding to the difference information obtained in step S42 is stored. FIG.
In the example of 0, A and C store the difference module S _2,3, it jumps to step S40, to increment a K 2.

In this case, N = 3 and K = 2, and since it is determined as Yes in step S41, the process is terminated.

Further, when the version number advances to 4, step S36
In extracts a difference version 1 and version 4, and stores the difference information R _{1, 4} resulting from the difference extracted in Step S36 At step S37 the difference module acquisition table, jumps to step S40.

[0210] K is determined No in step S41 when the 1, generates differential information from the R _{l, 4} and R _{1, 3} Metropolitan in step S42, difference module acquires said difference information R _{3, 4} in step S43 Store in a table.

In the present case, since K is 1,
The difference module corresponding to the difference information jumps to step S40 again stored in S _{3, 4,} to increment a K 2.

Also in this case, NK = 4-2 ≠ 1.
From step S42, R_1,4And R _1,2And difference information from
Is generated, and in step S43, the difference information is
Stored in the file acquisition table.

In this case, since K is not 1, the process jumps from step S44 to step S40,
Increase K to 3.

In this case, the determination is Yes in step S41, and the process ends.

Thereafter, each time the version number advances, the above processing is repeated. In this case, since the storage area is assumed to be infinite, the newly generated difference module may be stored in the new difference area.

The above processing is the basis of processing when all modules of the updated version are provided, but it is physically impossible to set the storage area to infinity.

[0217] The following describes how to generate a difference module acquisition table and a difference module when the storage area is limited.

FIG. 9 is a flow chart of creating and storing a difference module acquisition table and a difference module when the storage area is limited and all updated modules are provided. Hereinafter, the above processing will be described along the reference numerals in FIG.

Here, the flowchart of FIG. 9 corresponds to steps S32 and S3 in the flowchart of FIG.
Step S33 is inserted between Steps No. 4 and Steps S47 to S58 are added to the flowchart of FIG.

First, step S33 is a step for judging whether or not the version upgrade of the program has progressed and the storage area has been used up, and the version number N of the program is the number of generations of the program that can be stored in the storage area. It is determined whether or not the storage area has been used up by determining whether or not the storage area has been exceeded.

If there are three difference areas as in the previous example,
When combined with the base area, four generations of programs can be stored. Therefore, in this case, the number M of program generations that can be stored in the storage area is four.

Therefore, since the version number N of the program is smaller than or equal to 4 from the first request for storing version 1 to the request for storing version 4, it is determined as No in step S33, and steps S34 to S34 are performed. The process of step S46 is performed.

Since the processing in steps S1, S2 and S34 to S46 is exactly the same as the processing in the flowchart shown in FIG. 8, when the version of the program is 4 or less, it is the same as the processing shown in FIG. When the processing is performed and the processing of the version number 4 is completed, the version 1 program is stored in the base area, and the difference module S _1,2 between the version ₁ and the version 2 and the difference module S _1,2 between the version 2 and the version 3 and S _2,3, in a state where difference module S _3.4 version 3 and version 4 are stored in the differential region.

In this state, when all the modules of the version 5 program are given and the storage of the version 5 is requested, since 5> 4, it is determined to be Yes in step S33 and the process jumps to step S47.

S47. Set 0 to the counter K.

S48. In order to overwrite the program stored in the base area with the oldest difference module and advance the version of the program stored in the base area, the oldest difference module is stored in the difference area _{SNM, N- (M-1)} . Overwrite the difference module with the same module stored in the base area.

In this case, since N = 5 and M = 4, the version number of module A and the version number of module C, which are the contents of the difference modules S _1,2 , are stored in version 1 stored in the base area. The program is overwritten by the module A and the module C on the program of FIG.

S49. To delete the oldest difference module, the difference module _{SNM, N- (M-1)} is deleted.

In this case, since N = 5 and M = 4, the difference module S _1,2 is deleted.

S50. R of difference module acquisition table
_{NM, N- (M-1)} , R _{NM, N- (M-2)} , ..., R
Delete _{NM, N- (M- (M-1)} .

[0231] In the present case, since it is N = 5, M = 4, R 1 from the difference module acquisition _{table, 2,} R _{1, 3} and R
_1,4 are deleted.

S51. The difference between the program stored in the base area and the version N program is extracted.

In this case, since N = 5, the difference between the version 1 program and the version 5 program stored in the base area is extracted.

S52. Then, the difference information _{RN- (M-1 )} corresponding to the difference extracted in step S51 is stored in the _N difference module acquisition table.

In this case, since the difference module extracted in step S51 is _S1,5 , the difference information _R1,5 corresponding to the difference module is stored in the difference module acquisition table.

S53. 1 is added to the counter K to make a new K.

S54. It is determined whether the number obtained by subtracting 1 from the number of generations M is equal to the value K of the counter.

This is a determination for generating all the difference information between the versions to be skipped with respect to the version N and knowing whether or not the difference module acquisition table has been completed. The reason for comparing M-1 and K can be seen in FIG.

That is, when the number of generations is 4, R_3,4Is stored
R after_2,3And R_3,4And from R _2,4To generate R
_1,3And R_3,4And from R_1,4Generates the difference module
File acquisition table is completed. In other words,
If the difference information between the versions is generated twice, the difference module
Since the acquisition table is completed, the difference information is available until K is 2
And if K equals 3 and M-K equals 1,
The generation of the difference information may be ended.

If the number of generations M is 5, if three pieces of difference information between the versions to be skipped are generated, the difference module acquisition table is completed. Therefore, the difference information generation can be terminated only by M-1 = K It is when it became.

Now, since M = 4 and K = 1 in this case, No is determined in step S54 and step S5
Move to 5.

S55. Difference information is generated from RN _{-1, N} and _{RN-1-K, N-1} . This meaning is the same as that described in step S9 of FIG.

In this case, difference information is generated from R _4,5 and R _3,4 .

S56. It is stored in the difference information _{RN-1-K, N} difference module acquisition table generated in step S20.

In this case, as described above, R _4,5 and R _3,4
And the difference information R _3,5 is stored in the difference module acquisition table.

S57. It is determined whether or not the value of the counter K is 1; if K = 1 (Yes), the process proceeds to step S58; otherwise, the process jumps to step S53.

In this case, since K = 1 due to the above setting, the flow shifts to step S58.

S58. The difference module S _{NK, N} corresponding to the difference information generated in step S55 is stored in step S4.
In step 9, the difference module is stored in the deleted difference area, and the process jumps to step S53. In the case of the now jumps to step S53 to store the difference module S _4,5 to the difference area to remove the difference module in step S49.

In this case, since M = 4 and K = 2, No is determined again in step S54, and step S55
Through step S57.

That is, the difference information R is obtained from R _4,5 and R _2,4.
2 , ₅ are generated and stored in the difference module acquisition table, 1 is further added to K to set K = 3, and step S5
From 7 jump to step S53.

In this case, M = 4 and K = 3, so that the determination is Yes in step S54, and the process is terminated.

Here, the case where the version of the program has advanced to 5 has been described. However, even when the version of the program becomes 6 or later, the generation of the difference module acquisition table and the storage of the difference module are performed in the same manner according to the flowchart of FIG. be able to.

When the number M of program generations that can be stored is 4
Other than the above, the difference module acquisition table can be generated and the difference module can be stored in the same manner by the flowchart of FIG. 9 if different values of M are set and the same processing as described above is specifically performed. I understand.

In the description with reference to FIGS. 7 to 9,
In order to be consistent with the description with reference to FIGS. 1 to 5, a difference module between programs of successive versions and not included in an old version program among new version programs is stored in a difference area. Have been described as such.

However, a difference module that is not included in the version 1 program among the new version programs may always be stored in the difference area, based on the version 1 program.

FIG. 10 shows a difference module acquisition table for version change and how to create it (No. 2).

Although the difference module acquisition table itself shown in FIG. 10 is the same as the difference module acquisition table shown in FIG. 1, it is different in how to make it. That is, the difference from FIG. 1 is that the remaining difference information is generated based on the difference information R _1,2 , R _1,3 , and R _1,4 . Hereinafter, it will be specifically described that all the difference information can be generated by the method shown in FIG.

First, the difference information R _2,3 is generated as follows. That is, if the difference information for each module included in the difference information R _1,2 is removed from the difference information for each module included in the difference information R _1,3 , the difference information R _2,3 is obtained. Specifically, the difference information R _1,3 includes A, C and G
Are contained in the difference information _R1,2 , so that if removed, A and G remain, but this is due to the difference information R obtained by following the version update process of FIG. Equal to a _few .

Next, the difference information R _3,4 is generated as follows. That is, if the difference information of each module included in the difference information R _1,3 is removed from the difference information of each module included in the difference information R _1,4 , the difference information R _3,4 is obtained. Specifically, the difference information R _1,4 contains A, B, C
, G and H, of which A, C
Since G and G are included in the difference information R _1,3 , if they are removed, B and H remain, but this is equal to the difference information R _3,4 obtained by following the version update process of FIG.

Further, the difference information R _2,4 is generated as follows. That is, by removing the difference information of each module included in the difference information R _{1,2 from} the difference information of each module included in the difference information R _1,4 , the difference information R _2,4 is obtained. Specifically, the difference information R _1,4 contains A, B, C
, G and H are included, but among them, C is included in the difference information R _1,2 , so if removed, A, B,
Although G and H remain, this is equal to the difference information R _2,4 obtained by following the version update process of FIG.

Therefore, the difference information R _1,2 , R _1,3 and R
_If the difference modules corresponding to ₁ and ₄ are stored in the difference area and the version 1 program is stored in the base area, it can be seen that the version can be changed between arbitrary versions.

In one word, the generation of the difference module acquisition table and the storage of the difference module in the difference area performed in accordance with FIG. 10 are convenient when all the modules of the program of the changed version are provided when a version update is requested. It is.

It should be noted that the creation and storage of the difference module acquisition table and the difference module have already been described with reference to FIGS.
Since it can be inferred from the detailed description in the above, illustration and description are omitted.

Heretofore, regardless of whether the storage area is infinite or finite, the oldest version of the program that can be stored in the base area is stored, and the oldest version of the new version of the program is stored in the difference area. Stores the difference module that is not included in the program, and includes the difference information of the difference module that is not included in the old version of the program of the new version of the program, even when skipping and upgrading the version in the difference module acquisition table. A technique for storing has been described.

As described above, the above technique can be applied when performing version down, but is basically suitable for version up.

Therefore, hereafter, basically, the version
A technique suitable for down will be described.

FIG. 11 shows a difference module acquisition table for version change and how to create it (No. 3).

FIG. 11 differs from FIG. 1 or FIG. 10 in that the stored difference information is information on a difference module to be changed when updating from a higher version program to a lower version program. In other words, when a high-version program and a low-version program are compared, information on a module that is not included in the high-version program among the low-version programs is stored as difference information.

More specifically, referring to FIG. 20, for example, comparing version 2 with version 1, B,
D, E, F, G and H are common to both versions, and A and C are not included in version 2. Therefore, the difference information R _2,1 is generated by A and C.

In FIG. 1, the difference information R _{m, n} is described as meaning the difference information generated by the information of the module to be changed when changing from version m to version n. _{When n and m} change from version n to version m, they mean the same difference information generated by the information of the module to be changed.

Then, even in the case shown in FIG. 11, all the difference information can be generated from the difference information R _2,1 , R _3,2 and R _4,3 .

First, the difference information R _3,1 is the difference information R _2,1
Is copied, and information of a module not included in the difference information R _2,1 in the difference information R _3,2 is added. Specifically, copying the A and C from the differential information R _2,1, be added the information G does not include the module in the difference information R _2,1 are included in the difference information R _3,2 Difference information R _{3, 1}
Is obtained. This matches the information extracted as the module information to be changed when changing from version 3 to version 1 in FIG.

Since the detailed description has already been repeated,
Description is omitted, but the difference information R _4,2Is the difference information R
_3,2And the difference information R_4,3Difference information
R_{3, Two}Can be obtained by adding information of modules not included in
And the difference information R_4,1Is the difference information R_3,1On the copy
And difference information R_4,3Of the difference information R_3,1Not included in
It can be obtained by adding information.

FIG. 12 shows a module (part 2) which is required for the version change at a minimum.

Based on the above matter, if the latest version of the program is stored in the base area at the time and the data of the module to be changed at the time of continuous version down is stored in the difference area, any Version can be changed between programs of different versions.

FIG. 13 is a view for explaining storage of difference module data having an infinite storage area and conforming to FIG.
The case where only the updated module of the updated version is provided is shown along the course of the program version upgrade.

FIG. 13 (a) shows the process when a request to save version 1 is made for the first time.

Before the first storage of version 1 is requested, there is no information on the program, so nothing is stored in the base area or the difference area. Since storage of version 1 is requested there, the version 1 program is stored in the base area. Then, since only version 1 of the program exists, the difference module does not yet exist.

[0279] Therefore, after the above processing, the state transits to a state in which the data of all the modules constituting the version 1 program is stored in the base area and nothing is stored in the difference area.

FIG. 13B shows the processing when the storage of version 2 is requested in the above state.

In this case, from version 1 to version 2
Is supplied with the data of the module to be changed. In the example of FIG. 20, data of A and C is supplied.

By the way, in FIG. 12, module data to be changed when changing from a higher version to a lower version is stored in the difference area, and in FIG. It has been described that information of a module to be changed is stored when changing to.

However, what is actually given when changing the version is the module data to be changed when changing from a lower version to a higher version. Therefore,
The module data to be stored and the difference information must be generated using the module data provided when the version is changed.

For this purpose, first, the data of the same module as the given module data of the version 1 program stored in the base area is replaced with the given module data, and the version 2 program is replaced with the given module data. Generate. This is indicated by (1) in FIG.

Next, the currently generated version 2 program is compared with the version 1 program stored in the base area, and the data of the module to be changed when changing from version 2 to version 1 is extracted and compared. It is stored in area 1. This is indicated by (2) in FIG.

At this time, it is necessary to store the difference information in the difference module acquisition table, but this is not shown in FIG.

Then, the entire generated version 2 program is overwritten on the base area, and the processing is terminated. This is shown in (3) of FIG.

Therefore, when the processing of FIG. 13B is completed, the version 2 program is stored in the base area, and the module data to be changed when changing from version 2 to version 1 is stored in the difference area 1. State.

FIG. 13C shows the processing when the storage of version 3 is requested in the above state.

Also in this case, the same processing as described above is performed, and finally the version 3 program is stored in the base area, and the version 2
And the module data to be changed when changing from version 3 to version 2 is stored in the difference area 2.

Then, in this case, the difference information R _3,2 necessary for changing from version 3 to version 2, and
Difference information R _3,1 necessary for changing from version 3 to version 1 is generated and stored in the difference module acquisition table.

FIG. 13D shows the processing when the storage of version 4 is requested in the above state.

Since the specific processing to be performed in this case can be analogized by the items already described in detail,
Although a detailed description is omitted, a version 4 program is finally stored in the base area, module data to be changed when changing from version 2 to version 1 is stored in the difference area 1, and Modules to be changed when changing from version 3 to version 2
Data is stored, and module data to be changed when changing from version 4 to version 3 is stored in the difference area 3.

Then, in this case, the difference information R _4,3 necessary for changing from version 4 to version 3, and
Difference information R _{4, 1} is generated and stored in the difference module acquisition table required when changing the differential information R _{4, 2} required, from version 4 to version 1 when changing from version 4 to version 2 .

Since the storage area is assumed to be infinite in this case, all the difference module data generated each time the version of the program advances thereafter is stored in the difference area. The latest version of the program is stored in the base area.

FIG. 14 shows a difference module acquisition table and a difference module
This is a flowchart for creating and storing data, showing a process when only a module to be updated with an updated version is given. Hereinafter, description will be made along the reference numerals in FIG.

[0297] However, the specific processing in this case is sufficiently described with reference to FIG. 13. Although the case is different,
4, 6, 8, and 9 have already been described without any omission, and thus, in each step, specific processing and state transition will not be described, and only general description will be given.

S61. Receive a program update request.

S62. From the update request to the program version N
(N is a positive integer).

S64. It is determined whether or not the version number N of the program is 1.

When it is determined that the version number N of the program is 1 (Yes), the process jumps to step S74.

S74. The version 1 program is stored in the base area, and the process ends.

S65. If it is determined in step S64 that N is not 1 (No), the program stored in the base area is copied to the temporary area, and the received difference module is overwritten with a module having the same name in the temporary area. Generate a version N program.

S66. Version N and version (N-
The difference module of 1) is extracted. The difference module referred to here is a module to be changed when changing from version N to version (N-1).

S67. The difference information _{RN, N-1} relating to the difference module is stored in a difference module acquisition table.

S68. The difference module S _{N, N-1} extracted in step S66 is stored in the difference area.

S69. Copy the program stored in the temporary area to the base area.

S70. The counter K is set to 1.

S71. It is determined whether or not NK is 1.

When NK is determined to be 1 (Ye
In s), the process ends.

S72. If it is determined in step S71 that NK is not 1 (No), the difference information _{RN, N-1}
And difference information is generated from RN _{-1, N- (K + 1)} and S73. The difference information RN _{, N- (K + 1)} is stored in the difference module acquisition table.

S87. Add 1 to K to get a new K,
Jump to step S71.

Then, step S is performed until NK becomes 1.
72, the processing of step S73 and step S87 is continued, and when NK becomes 1, the processing is ended.

FIG. 15 is a diagram for explaining storage of difference modules conforming to FIG. 11 with a finite storage area, and sequentially describes a case where only data of a module to be changed when a version is upgraded is provided. .

FIG. 15A shows the processing when a request to save version 5 is made with version 4 stored.

Also in this case, the difference module of version 2 and version 1 stored in the difference area 1 is deleted (1), and the version 4 program stored in the base area is copied to the temporary area. Overwriting the received module data with the module having the same name of the program in the temporary area to generate a version 5 program (2), and generating the generated version 5 program and the version 4 program stored in the base area. Are compared, a difference module of version 5 and version 4 is generated and stored in the difference area 1 (3),
Finally, the version 5 program in the temporary area is copied to the base area, and (4) the processing ends.

Therefore, when this processing is completed, the version 5 program is stored in the base area, the version 5 and version 4 difference modules are stored in the difference area 1, and the version 3 and version 2 are stored in the difference area 2.
Then, a transition is made to a state in which the difference module of version 4 and version 3 are stored in the difference area 3.

FIG. 15 shows the subsequent processing in detail, but since this processing is repeated for different versions, the description is omitted.

FIG. 16 is a flowchart for creating and storing a difference module acquisition table and a difference module conforming to FIG. 11 in the case where the storage area is limited, and shows a case where only the updated module of the updated version is given. Hereinafter, the above processing will be described along the reference numerals in FIG.

However, since specific processing in this case can be inferred from the description already given, specific processing and state transition are not described in each step.
Let's just give a general explanation.

Steps S61, S62, S64 to S74 and S87 have already been described with reference to FIG.
A general description will be given only of step S75 and subsequent steps.

S75. The oldest difference module data S _{N- (M-1), NM} is deleted.

S76. R which is the oldest difference information
_{N- (M-1), NM} , _{RN- (M-2), NM} , _{RN- (M- ( M-1)), NM} are deleted from the difference module acquisition table.

S77. The program stored in the base area is copied to the temporary area, and the received difference module data is overwritten to generate a version N.

S78. Version N and version (N-
The difference module of 1) is extracted.

S79. The difference information _{RN, N-1 corresponding} to the difference module is stored in a difference module acquisition table.

S80. The difference module S _{N, N-1} generated in step S78 is stored in the difference area from which the difference module S _{N- (M-1), NM} has been deleted in step S75.

S81. The version N program in the temporary area is copied to the base area.

S82. The counter K is set to 1.

S83. It is determined whether or not M−K is 1.

When MK is determined to be 1 (Ye
In s), the process ends.

S84. If it is determined in step S83 that M−K is not 1 (No), difference information is generated from the difference information RN _{, N−1} and _{RN−1, N−1−K} , and S85. The difference information _{RN, N-1-K} is stored in a difference module acquisition table.

S86. Add 1 to K to get a new K,
Jump to step S83.

Then, step S is performed until M−K becomes 1.
84 to step S86 are repeated, and M-K becomes 1
When it becomes, the process ends.

The case where only module data to be updated when a program update request is issued has been described. Hereinafter, a case will be described in which all modules of a program to be updated are given when a program update request is issued.

In this case, only the processing of generating an updated version of the program shown in FIG. 13 or FIG. 15 is unnecessary, and the subsequent processing is the processing described in FIG. 13 or FIG. Therefore, the description using the drawings corresponding to FIG. 13 or FIG. 15 is omitted, and only the flowchart is described.

FIG. 17 is a flowchart for creating and storing a difference module acquisition table and a difference module when the storage area is infinite and all updated modules are provided. Hereinafter, the processing related to the generation of the difference module and the difference module acquisition table when the storage area is infinite will be described along the reference numerals in FIG.

However, since the specific processing in this case can be inferred from the description already given, the specific processing and state transition are not described in each step.
Let's just give a general explanation.

S91. Receive a program update request.

S92. From the update request to the program version N
Read.

S94. It is determined whether or not N is 1.

When it is determined that N is 1 (Yes)
Jumps to step S103.

S103. The program is stored in the base area of the version 1 program, and the process ends.

S95. If it is determined in step S94 that N is not 1 (No), 0 is set to the counter K.

S96. The received version N is compared with the version (N-1) already stored in the base area, a difference module is extracted, and stored in the difference area.

S97. The difference information _{RN, N-1 corresponding} to the difference module is stored in a difference module acquisition table.

S98. The received version N program is stored in the base area.

S99. A new K is obtained by adding 1 to K.

S100. It is determined whether or not NK is 1.

If NK is determined to be 1 (Ye
In s), the process ends.

S101. If it is determined in step S100 that NK is not 1 (No), the difference information R
Generating difference information from _{N, N-1} and _{RN-1, N- (K + 1)} ; S102. The difference information _{RN, N- (K + 1)} is stored in the difference module acquisition table, and the process jumps to step S99.

Then, step S is executed until NK becomes 1.
101, the process in step S102 is continued, and NK is 1
When it becomes, the process ends.

FIG. 18 is a flowchart for creating and storing a difference module acquisition table and a difference module when the storage area is finite and all updated modules are provided. Hereinafter, the above processing will be described along the reference numerals in FIG.

However, since specific processing in this case can be inferred from the description already given, specific processing and state transition are not described in each step.
Let's just give a general explanation.

[0355] Steps S91, S92 and S94 to S103 are the same as those in FIG.
7, the description is omitted, and step S
Only the steps after 104 will be described.

S104. Set 0 to the counter K.

S105. The oldest difference module data S _{N- (M-1), NM} is deleted.

S106. R which is the oldest difference information
_{N- (M-1), NM} , _{RN- (M-2), NM} , _{RN- (M- (M-1)), NM} are deleted from the difference module acquisition table.

S107. Version N and version (N
-1) The difference module is extracted.

S108. The difference information _{RN, N-1 corresponding} to the difference module is stored in a difference module acquisition table.

S109. The difference module S _{N, N-1} generated in step S78 is stored in the difference area from which the difference module S _{N- (M-1), NM} has been deleted in step S75.

S110. A new K is obtained by adding 1 to K.

S111. Difference information R _{N, N-1} and R
_The difference information is generated from _{N-1, N-2-K} .

S112. The difference information R _{N, N-2-K} is stored in a difference module acquisition table.

S113. It is determined whether or not M−K is 2.

If M−K is 2, the process ends, and M−K
If is not 2, the process jumps to step S110.

Then, step S is performed until M−K becomes 2.
The processing from step 110 to step S112 is continued, and when M−K becomes 2, the processing ends.

By the way, in the above description, the case where the difference modules between versions having successive versions are stored is described. However, as described with reference to FIG. 10, the difference modules of version N and version 1 are stored. It is also possible to put.

However, since this can be inferred by the items already described, detailed description will be omitted.

In the above description, when a request for a version change is made, a list of difference modules between versions is created, and a difference module acquisition table is created using the list. At that time, it was shown that the difference module between the version before the change and the version after the change can be selected by referring to the difference module acquisition table.

Next, a download sequence performed using the above technique will be described.

FIG. 19 shows a download sequence according to the present invention, for example, a case of downloading from an operation system to an optical network unit.

First, the download data is transferred from the operation system to the operation system interface of the optical line terminator.

The operation system interface that has received the download data creates the difference module acquisition table as described in detail above, stores the created difference module acquisition table in the storage unit, and furthermore, -Data is also stored in the storage unit. This is the same whether all modules of the program are downloaded or only the modules to be updated are downloaded.

Next, upon receiving a download instruction command from the operation system, the operation system interface refers to the difference module acquisition table stored in the storage unit and selects a module to be downloaded to the optical network unit. Issues a download instruction command including information on the selected module to the router interface.

The router interface having received the download instruction command obtains module data to be downloaded from the storage unit and downloads the module data to the optical network unit.

[0377] Thereafter, a download response is issued from the optical network unit, and the download response is transferred to the operation system via the router interface and the operation system interface.

By doing so, except when transferring a new version of module data, the amount of transmission between the operation system and the optical line terminator is only a download instruction command, and the operation system has a supervisory control function. Will not be disturbed.

Also, when transferring a new version of module data, only the data of the module to be updated need be transferred, so that the amount of transmission between the operation system and the optical line terminator does not increase so much. The obstruction of the monitoring and control function of the operation system is reduced.

Further, since the operation system interface creates the difference module acquisition table by the above-mentioned systematic method, the load on the operation system interface is reduced, and the normal communication function is hardly obstructed. .

When downloading from the operation system to the optical line terminator or giving a download instruction, when downloading from the optical line terminator to the optical network unit, the module data to be transferred is stored. In addition to the above, it is necessary to form a frame including the transfer destination specification and transfer it.
When a download instruction is issued to the interface, it is necessary to form and transfer a frame including at least information on the old version and the changed version.

However, since this can be easily conceived by those skilled in the art, detailed description thereof will be omitted.

[0383] Finally, the above description has been made on the assumption that the PDS system is applied to a communication system.
The present invention is not limited to the S system, and can be applied to a CAD system in which a monitoring system, a center device, and a design terminal are arranged at a long distance besides a communication system, and a program is also installed in the design terminal. is there.
Further, the present invention can be applied to data download in addition to program download.

[0384]

According to the first means of the present invention, when a version change request is made, a difference module acquisition table having difference information between all versions is referred to,
Since a difference module between the version before the change and the version after the change can be selected, the management of the module is simplified, and the processing function inherent in the system is less hindered. According to the second aspect of the present invention, the amount of data transmitted between the download instructing device and the download device is only download instruction information or the difference module, and the data transmission amount between the download device and the download receiving device. Since the data transmission amount is limited to the transmission amount of the difference module, the transmission load on the transmission line can be reduced.

[0385] In the first means of the present invention,
Also in the second means, since the maintainer is not directly involved in selecting a difference module to be downloaded, there is no room for a defect in the download.

[Brief description of the drawings]

FIG. 1 shows a difference module acquisition table in version change and how to create it (part 1).

FIG. 2 shows a minimum required module for version change (part 1).

FIG. 3 is a view for explaining storage of difference module data having an infinite storage area and conforming to FIG. 1;

FIG. 4 is a flowchart of creation and storage of a difference module acquisition table and difference module data based on FIG. 1 when the storage area is infinite.

FIG. 5 is a view for explaining storage of difference module data based on FIG. 1 when the storage area is limited.

FIG. 6 is a flowchart of creating and storing a difference module acquisition table and difference module data based on FIG. 1 when the storage area is limited.

FIG. 7 is a view for explaining storage of difference modules when the storage area is infinite and all updated modules are provided;

FIG. 8 is a flowchart of creating and storing a difference module acquisition table and difference module data when the storage area is infinite and all updated modules are provided.

FIG. 9 is a flowchart of creation and storage of a difference module acquisition table and a difference module in a case where a storage area is limited and all updated modules are provided.

FIG. 10 is a diagram illustrating a difference module acquisition table in version change and how to create the table (part 2).

FIG. 11 shows a difference module acquisition table in version change and how to create it (part 3).

FIG. 12 shows a minimum required module for version change (part 2).

FIG. 13 is a view for explaining storage of difference module data having an infinite storage area and conforming to FIG. 11;

FIG. 14 is a flowchart of creation and storage of a difference module acquisition table and difference module data having an infinite storage area and conforming to FIG. 11;

FIG. 15 is a view for explaining storage of a difference module having a finite storage area and conforming to FIG. 11;

FIG. 16 is a flowchart of creation and storage of a difference module acquisition table and a difference module that have a limited storage area and conform to FIG. 11;

FIG. 17 is a flowchart of creation and storage of a difference module acquisition table and a difference module when the storage area is infinite and all updated modules are provided.

FIG. 18 is a flowchart of creation and storage of a difference module acquisition table and a difference module when the storage area is limited and all updated modules are provided.

FIG. 19 shows a download sequence according to the present invention.

FIG. 20 shows an example of changing a program version.

FIG. 21 shows a configuration of a PDS system.

FIG. 22 shows a download sequence by an instruction command from the operation system.

[Explanation of symbols]

1 Operation System (OpS) 2-1 Optical Line Terminator (OLT) 2-2 Optical Line Terminator (OLT) 3-1 Optical Network Unit (ONU) 3-2 Optical Network Unit (ONU) 3-3 Optical Network Unit (ONU) 21 Operation System Interface (O
pS-IF) 22-1 Router interface (router IF) 22-2 Router interface (router IF) 23 Storage unit 24-1 Optical subscriber unit (OSU) 24-2 Optical subscriber unit (OSU) 24-3 Optical subscriber unit (OSU) 25 Maintenance terminal 31 Ethernet interface (Ether IF) 32 Storage unit

 ────────────────────────────────────────────────── ─── Continuing on the front page (72) Inventor Eiji Imai 2-2-6 Jomi, Chuo-ku, Osaka-shi, Osaka Prefecture Fujitsu Kansai Digital Technology Co., Ltd. In-house F-term (reference) 5B076 AC04 BB06

Claims (5)

[Claims] 1. A list of difference modules that is changed between a version before a change and a new version when a version change request of stored contents of a program or data is made, and an arbitrary version is used by using the list. Creates and stores a difference module acquisition table that is a list of all difference modules between the modules, and also increases the number of versions of all modules of the stored contents of the oldest storable version and the oldest storable version A download method characterized by storing data of a difference module to be updated sometimes. 2. A list of difference modules that is changed between a version before a change and a new version when a version change request of stored contents of a program or data is made, and an arbitrary version is used by using the list. Creates and stores a difference module acquisition table that is a list of all difference modules between the modules, and stores all modules of the stored contents of the oldest version that can be stored, and any version from the stored contents of the oldest version that can be stored. A download method for storing data of a difference module to be updated when the version number is advanced. 3. When a version change request is made for a stored content of a program or data, a list of difference modules to be changed between a version before change and a new version is created, and an arbitrary version is created using the list. Create and store a difference module acquisition table, which is a list of all difference modules between the modules, and also store all modules with the latest version of stored contents and data on storable difference modules that should be updated when the version number is sequentially reduced A download method characterized by storing. 4. A list of difference modules which is changed between a version before a change and a new version when a version change request of stored contents of a program or data is made, and an arbitrary version is used by using the list. Create and store a difference module acquisition table, which is a list of all difference modules between them, and also downgrade the version number from the stored contents of the latest version to the oldest version that can be stored from the stored contents of any version A download method characterized by storing data of a difference module to be updated at the time of execution. 5. A difference module to be downloaded from stored difference modules by referring to the difference module acquisition table according to claim 1 when instructing download of a program or data. A download method characterized by selecting and downloading only the selected difference module.