JPS63106860A - Common information comparing system - Google Patents

Abstract

PURPOSE:To reduce the number of times of checking and to detect only members in which no coincidence can be obtained, by checking common information hierarchically at the time of comparing the common information. CONSTITUTION:The common information 1 is constituted of a data part 2 and an index part 3, and a unique identifier which identifies a generation time and a generator by every member is set on the common information 1, and the checking for coincidence among them is performed step by step. In order words, the hierarchical division of the whole of common information 1, several subgroups dividing the whole, and the subgroups diving the subgroups further, are preformed, and an identifier to coincide only when the members in them coincide with each other is added at every divided unit. The checking of the identifier is started from the identifier for the whole of the common information 1 in order, and it is performed by comparing the subgroups when no coincidence can be obtained, then, all of the members in which no coincidence can be obtained, are defined. In such a way, it is possible to efficiently perform the comparing check of the common information attached on each processor without comparing all of the members.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a method for detecting discrepancies in common information of distributed systems such as directory information in a distributed database system used for LAN, online system, etc.

[Conventional technology]

Conventionally, the consistency of common information in a distributed system has been manually checked using the date of creation, version number, etc. attached to the common information by the creator of the common information.

[Problem that the invention seeks to solve]

In a distributed database system, common information such as an address list of each node or definition information of an externally referenceable database of each node is kept as a duplicate. Conventionally, checking the consistency of common information manually has become increasingly difficult as the amount of common information increases. Additionally, incorrect operations could cause system failure and cause data damage that would be difficult to recover. For example, in an application that uses a nationwide network, the number of members of common information is 100 to 100.
It is estimated that it will be 0. Furthermore, even if the comparison is automated, attempting to perform a complete comparison will result in a large overhead, which poses a problem.

[Means to solve the problem]

The present invention aims to solve the above-mentioned problem by automatically checking the consistency of common information using software, which was conventionally done manually. For the common information, a creation time and a unique identifier for identifying the creator are set for each member, and a match is checked. In order to cope with the increase in the number of members to be checked, we adopted a method of performing checks in stages. In other words, hierarchical division is performed such as the entire common information, subgroups that divide the whole into several subgroups, and subgroups that further divide the subgroups.
An identifier was added to each division unit so that it would match only if the members within it matched. The identifiers are checked in order by starting with the identifier corresponding to the entire common information and comparing the subgroups if they do not match, to determine all the members that do not match.

When each processor updates the common information, it adds its own processor's timestamp and self-processor identifier as a member identifier, and also changes all the identifiers of its upper subgroups to this new identifier. This change is then communicated to other processors to be reflected. If the corresponding identifier of each processor matches the previous content, the change is reflected. This process is performed sequentially for the third-ranked node. Some members of the common information may not exist in all processors. Members that do not exist and nodes that have no subordinate nodes are omitted. When these nodes are compared, the comparison is performed assuming that they have been added with identifiers that do not match the identifiers of nodes existing in correspondence with other processors.

[Effect]

The effect of the present invention is to minimize the number of checks and to detect only members that do not match by performing checks hierarchically when comparing common information. Although it is common information, it is possible to reduce the number of identifiers by omitting the identifier hierarchy for members that are transmitted when used and do not normally need to be held by all processors.

[Embodiments of the invention]

An embodiment of the present invention will be described below. FIG. 6 shows the configuration of the distributed database system in this embodiment. Connected to the network 4 are a processor 4a, a processor 4b, and a processor 4c.

As a distributed database, each processor holds separate databases related to academic papers.

A mathematical paper database 5a and common information 1a are attached to the processor 4a. Similarly processors 4b, 4
c respectively have a physics paper database 5b, an electronic paper database 5c, and common information 1b.

1c is attached. Common information 1a, lb, and lc each include a portion of definition information of databases 5a, 5b, and 5c.

FIG. 1 shows the structure of all common information obtained by combining common information possessed by each processor in a distributed system. The common information 1 consists of a data section 2 and an index section 3. I'm here. The data portion 2 includes members 21, 22, and 23, which are the minimum units of common information. These are mathematics and physics respectively.

Definition information for each electronic paper database. The index section 3 includes nodes 31 that constitute a tree-structured index;
311,312,313,3121゜3122.312
3 is included. Node 31- represents the entire academic paper, and below this node 311- represents literature. Node 312 representing science. A node 313 representing engineering is connected. Under the node 31-2 representing science, there is a node 3 representing mathematics.
1.2],,.

A node 3122 representing physics is connected. Members 21 and 22 containing definition information of the corresponding database are connected to these nodes. Similarly] A node 3131 representing electrons is connected under the node 313 representing science, and a member 23 containing definition information of the electronic paper database is connected below it. Each node can store an identifier representing the time of last update.

FIG. 2 shows common information 1. held by two processors 4a and 4b. This is an example of a and lb. The common information IC stores the definition information of the databases 5a, 5b, and 5c in 21a and 21a, respectively.
Included as 2a and 23a. On the other hand, common information 1b
The database 5a.

Only definition information 21b and 22b of 5b is included.

In FIG. 2, the identifier of each node is composed of a processor timestamp and a processor identifier.

For example, in the node 31, the timestamp is [3] and the identifier rAJ.

FIG. 3 shows the flow of comparison processing. The comparison process is performed by the processor 4a, the processor 4b, or the third processor 4.
It is possible to execute either c. Common information 1a,
Each node is taken out one by one from the index section of lb and compared as follows. In the example of FIG. 2, the mismatched members are the definition information 21a of the mathematical database of the processor 4a and the corresponding member 21-b of the processor 4b.
It can be seen that it is. In addition, the member corresponding to the definition information of the electronic database of processor 4 n is
It can be seen that it does not exist in b. The comparison process specifies the root node in the index and calls subtree comparison. Subtree comparison returns a list of unmatched members it finds to the caller.

Let this be the list of unmatched members.

FIG. 4 shows the flow of subtree comparison processing.

At 42, node j is obtained from both processors.

In step 43, when the identifiers of the nodes j match, the unmatched member list ■,=empty returns to the caller.

When the identifiers do not match, if the node is the lowest node at 44, the corresponding member is added to the mismatched member list and the process returns. If not, check the child nodes. First, clear the failures and failures 1~. For a node j whose corresponding node is in both processors among the child nodes, sub1-I no comparison is recursively called at 45 to obtain a mismatching member for the child node j, and this is added to the mismatched member list I. − will be added. Next, for a child node without (!l) of the corresponding node, all members that are descendants of this child node are added to the mismatched member list.

After completing the above processing, return to the source with the unmatched member list.

FIG. 5 shows the flow of member update processing. processor 4
Although the case where processor a performs the update is shown, the same applies to the case where the processor 4b performs the update. First, the members of the own processor 4a are updated. Next, in step 52, a node identifier is created by combining the timestamp and identifier of its own processor.

In step 53, the identifiers of the nodes on the path from the node corresponding to the member to the root node are replaced with new identifiers.

At this time, a list of new and old identifiers is created.

At step 54, the member update data and the bare list 1- of the new daily identifier are sent to the processor 4b. The member is updated by the processor 4b. The identifier of the node is compared with the corresponding old identifier of the bare list sent from the node corresponding to the member toward the root node. If the comparison results match in step 57, a new identifier is entered in that node and the process proceeds to the comparison of higher-order nodes. If they do not match, the comparison is aborted. For processors other than the processor 41) in the distributed system 11, the processor 4 b
Perform the same process as .

To add a member, add a node when the node on the bus from the node corresponding to the member to the root node is omitted, and add the system common initialization identifier (time stamp [OJ
, processor identifier "X") is used as in the case of update. Further, deletion of a node is the same as in the case of updating, except that a node that has no child nodes due to deletion is deleted.

〔Effect of the invention〕

According to the present invention, a comparison check of common information held by each processor in a distributed system can be efficiently performed without comparing all members, and a list of members that do not have -M can be obtained with little overhead. It is also possible to omit part of the identifier by not distributing part of the member to all processors, but sending it to the processor that requested it when it is needed.

[Brief explanation of the drawing]

Figure 1 is a configuration diagram of common information, Figure 2 is an example of an index section of common information between two processors, Figure 3 is a flowchart of comparison processing, Figure 4 is a flowchart of subtree comparison processing, and Figure 5 is a flowchart of comparison processing. The figure is a flowchart of member update processing, and FIG. 6 is a configuration diagram of the distributed database system. 1... Common information, 2... Index section, 3... Data section.

Claims (1)

[Scope of Claims] 1. In a distributed system consisting of a plurality of processors in which each processor owns common information, each processor provides a tree-structured index with the same structure for the common information consisting of a plurality of members of each processor, and Each node in the structure has an area for identifiers that has the same value only when its descendants are the same, and when comparing the common information of two processors, the identifiers are compared sequentially from the root of the tree structure, and if the identifiers are different. , a common information comparison method in which similar comparisons are repeated for lower nodes, and if the identifiers are different at the lowest level, the corresponding members are treated as different members. 2. In the above system, the identifier is a combination of a processor-specific timestamp and a processor identifier, and when each member is updated, all the identifiers of the nodes above it are changed, and both the new and old identifiers of the changed node are used for all other nodes. Common information that is sent to a processor, and other processors set the new identifier sent as their own identifier only if the old identifier sent and the identifier of the corresponding node in the self-common information match. The common information comparison method according to item 1, characterized by having a management function. 3. In the above system, addition and deletion of members are allowed, nodes whose lower nodes are no longer deleted due to the deletion of upper nodes are omitted, and all identifiers of nodes that have not been omitted are changed, and the old and new identifiers are shared with all other processors. If the node identifiers do not match, all descendant members of the existing node will be treated as mismatched members, and nodes that were omitted due to the addition of members will be required. If this happens, the common information comparison described in item 1 is characterized in that this is added as a node having an initial setting value common to the system having a value that is not normally used as an identifier, and the identifiers are compared. method.