JPH0833861B2 - Common information comparison method - Google Patents

Description

The present invention relates to a method for detecting inconsistency in common information of distributed systems such as directory information in a distributed database system used for LANs, online systems and the like.

[Conventional technology]

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

[Problems to be solved by the invention]

In the distributed database system, common information such as an address list of each node or definition information of an externally referable database of each node is held as a copy. Conventionally, the check of the consistency of these common information which has been manually carried out has increased the difficulty as the amount of common information has increased. In addition, there is a possibility that the system may go down due to an erroneous operation and the data may be hard to recover. For example, the number of members of common information is estimated to be 100 to 1000 in an application that uses a national network. Also, even if you automate the comparison,
If you try to compare all the numbers as they are, the overhead becomes large, which is a problem.

[Means for solving problems]

In order to solve the above problems, the present invention is intended to solve the problems by automatically checking the consistency of common information, which was conventionally done manually by software. In the common information, a creation time and a unique identifier for identifying the creator are set for each member, and the matching of these is checked. In order to deal with the increase in the number of members to check, we adopted a method of performing check in stages. That is, when the common information is hierarchically divided into sub-groups in which the entire common information is divided into some sub-groups, sub-groups into which the sub-groups are further divided, and the members in each division unit match. Only the matching identifiers were added. This identifier is checked by a method of comparing the sub-groups in the case where they do not match in order starting from those corresponding to the entire common information, and all unmatched members are determined.

When updating the common information, each processor adds the time stamp of its own processor and its own processor identifier as a member identifier, and also changes the identifiers of its upper subgroups to this new identifier. Then, contact the other processors to reflect this change.
The changes are reflected if the corresponding identifier of each processor matches the previous contents. This process is sequentially performed on the upper node. Some members of the common information may not be present in all processors. Members that do not exist and nodes that have no lower nodes are omitted. If these nodes are to be compared, the comparison is performed on the assumption that an identifier that does not match the identifier of the node existing corresponding to another processor is added.

[Action]

The operation of the present invention makes it possible to minimize the number of times of checking and to detect only non-coincident members by hierarchically checking the common information. Although it is common information, the identifiers can be reduced by omitting the hierarchy of identifiers for members that are transmitted at the time of use and normally do not need to be held by all processors.

Example of Invention

An embodiment of the present invention will be described below. FIG. 6 shows the configuration of the distributed database system in this embodiment. Network 4 processor 4a, processor 4b, processor 4c
Is connected. As a distributed database, each processor divides and holds a database of academic papers. The processor 4a is accompanied by a mathematical article database 5a and common information 1a. Similarly, processors 4b and 4c have physical paper database 5b and electronic paper database 5c, respectively.
And common information 1b and 1c are attached. Common information 1a, 1b, 1c
Contains a part of the definition information of the databases 5a, 5b, 5c, respectively.

FIG. 1 shows the structure of all common information obtained by synthesizing the common information held by each processor in the distributed system.
The common information 1 is composed of a data part 2 and an index part 3. The data section 2 includes members 21, 22, 23 which are the minimum unit of common information. These are definition information of mathematical, physical, and electronic article databases. The index unit 3 includes nodes 31, 311, 312, 313, 3121, 3122, 3123 that form a tree-structured index. A node 31 represents the whole academic paper, and below this, a node 31 representing literature, a node 312 representing science, and a node 31 representing engineering.
3 is connected. Below the node 312 representing science, a node 3121 representing mathematics and a node 3122 representing physics are connected. Members 21 and 22 including definition information of the corresponding database are connected to these nodes. Similarly, a node 3131 representing an electron is connected below the node 313 representing engineering, and a member 23 including definition information of the electronic paper database is connected below the node 3131. Each node can store an identifier indicating the last update time.

Fig. 2 shows common information held by the two processors 4a and 4b 1
It is an example of a, 1b. Common information 1c is database 5a, 5b, 5c
21a, 22a, and 23a, respectively.
On the other hand, the common information 1b includes the definition information 2 of the databases 5a and 5b.
Only 1b and 22b are included. In FIG. 2, the identifier of each node is composed of a processor time stamp and a processor identifier. For example, in the node 31a, the time stamp is "2" and the identifier is "A".

FIG. 3 is a flow of comparison processing. The comparison process can be executed by any of the processor 4a, the processor 4b, or the third processor 4c. Each node is taken out one by one from the index part of the common information 1a and 1b and compared as follows. In the example of FIG. 2, the unmatched members are
It can be seen that it is the definition information 21a of the mathematical database of the processor 4a and the corresponding member 21b of the processor 4b. Further, it can be seen that the member corresponding to the definition information of the electronic database of the processor 4a does not exist in the processor 4b. The comparison process calls the subtree comparison by designating the root node in the index. The subtree comparison returns the found list of unmatched members to the caller, so this is the unmatched member list.

 FIG. 4 shows the flow of subtree comparison processing.

At 42, node i is obtained from both processors. When the identifiers of the node i match at 43, the unmatched member list L
= Return empty to the caller.

When the identifiers do not match, at 44, if the node has no child node and is the lowest node, the corresponding member is added to the unmatched member list and the process returns.

If not, check the child nodes. First, clear the unmatched member list. When the corresponding nodes among the child nodes are in both processors, the unmatched list L is pushed down to the stack, and the subtree comparison is recursively called at 45 for the child node j to find the unmatched member for the child node j. Get L '.
Then, the unmatched list L is popped up from the stack, and the unmatched member list L ′ is added to the unmatched member list L.

If there is no node corresponding to the child node, the unmatched member list L'in which all members that are descendants of this child node are entered is obtained. Then, the unmatched member list L ′ is added to the unmatched member list L.

If the search for the child node is not completed, the child node j
Return to the search step of.

When the child node search is completed, the processing is terminated,
Return to the original with the unmatched member list L.

FIG. 5 shows the flow of processing for updating a member. Processor
Although the case where 4a updates is shown, the same applies when the processor 4b updates. First, the member of the self-processor 4a is updated. Next, at 52, a combination of the time stamp of the self-processor and the identifier is created as the node identifier. At 53, the identifier of the node on the path from the node corresponding to the member to the root node is replaced with the new identifier. At this time, a pair of old and new identifiers is created as a list. At 54, the processor 4b is sent a list of member update data and a pair of old and new identifiers. Update members with processor 4b. From the node corresponding to the member toward the root node, the identifier of the node is compared with the corresponding old identifier of the list of pairs sent. If the comparison results in 57, then the new identifier is entered in that node and the process proceeds to the comparison of higher nodes. If they do not match, the comparison is aborted. Processors other than the processor 4b in the distributed system are also processed in the same manner as the processor 4b.

A member is added when a node on the path from the node corresponding to the member to the root node is omitted, and a system common initialization identifier (time stamp “O” is used as the old identifier of the added node). , ”And the processor identifier“ X ”) is used. In addition, the deletion of the node is the same as the case of the update, except that the deleted node is deleted.

〔The invention's effect〕

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 inconsistent members can be obtained with a small overhead.
It is also possible to omit a part of the identifier by allocating a part of the members to all the processors without sending them to all the processors and sending them to the requesting processor at the time when they are needed.

[Brief description of drawings]

FIG. 1 is a block diagram of common information, FIG. 2 is an example of an index part of common information in two processors, FIG. 3 is a flow chart of comparison processing, FIG. 4 is a flow chart of subtree comparison processing, and FIG. Is a flow chart of member update processing, and FIG. 6 is a configuration diagram of a distributed database system. 1 ... Common information, 2 ... Index part, 3 ... Data part.

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Hirokata Ogata 5030 Totsuka-cho, Totsuka-ku, Yokohama-shi, Kanagawa Inside the software factory of Hitachi, Ltd. (72) Hiromichi Ishikawa 5030 Totsuka-cho, Totsuka-ku, Yokohama-shi, Kanagawa Hitachi, Ltd. software factory

Claims (3)

[Claims] 1. A common information comparison method in a distributed system comprising a plurality of processors, wherein each processor holds the common information, wherein the common information composed of a plurality of members of each processor has a tree structure index of the same structure in each processor. With each node of the tree structure provided with an area of an identifier that has the same value only when its descendants are the same, when comparing common information of two processors, the identifiers are sequentially compared from the root of the tree structure, A common information comparison method characterized in that if the identifiers are different, the same comparison is repeated for lower nodes and if the identifiers are different at the lowest level, the corresponding members are made different members. 2. The common information comparison method according to claim 1, wherein the identifier is a combination of a processor-specific time stamp and a processor identifier, and when updating each member, all the identifiers of its upper nodes are changed. At the same time, the old and new identifiers of the changed node are sent to all other processors, and the other processors send new and old identifiers only when the old identifier and the corresponding node identifier in the self-common information match. A common information comparison method characterized by performing common information management in which an identifier is set as its own identifier. 3. The common information comparison method according to claim 2, wherein when a member is deleted, a node which has no lower node due to the deletion of upper nodes and a node which is not deleted is deleted. When all the identifiers are changed, the old and new identifiers are sent to all the other processors, the other processors manage the common information, and when adding a member, when a node omitted by adding a member becomes necessary, Is added as a node having an initial value common to the system, which has a value that is not normally used, as an identifier, sends the old and new identifiers to all the other processors, and the other processors perform the common information management. Characteristic common information comparison method.