JPH03276251A - Decentralized system processing method - Google Patents

Abstract

PURPOSE:To reduce the communication overhead in the transaction processing of a decentralized system by assuring the consistency of resources with the 2-phase commit. CONSTITUTION:The consistency of resources is assured with the 2-phase commit. That is, the processing programs are set at the specific remote nodes 2 and 3 when both nodes 2 and 3 different from a node 1 where an application program 4 is executed have high processing frequencies in the transaction processing of a decentralized system and a large quantity of data on the nodes 2 and 3 are required during the business work processing. Meanwhile a due program is called out of the client side as necessary and the desired information are transferred at one time together with the processing results received from a server. Otherwise only a simple result is transferred. As a result, the communication overhead is reduced.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a distributed system processing method that guarantees consistency while reducing communication overhead in transaction processing in a distributed system.

[Conventional technology]

For example, as described in Japanese Patent Publication No. 58-35297, in a conventional data processing system in a distributed environment, the processing itself that uses the resources of a remote node is performed by another operating system running under the control of a separate operating system. It describes entrusting a transaction to a processing system and receiving the obtained results via a communication circuit, activating a transaction at a remote node, and performing this through a special execution means called a mirror transaction. It also touches on synchronization point processing.

[Problem to be solved by the invention]

The above-mentioned conventional technology does not give consideration to ensuring consistency between resources, such as by using two-phase commit.

In addition, in conventional distributed database processing, if processing requests are frequently made to a specific node other than the node on which the application program is being executed,
Even when a large amount of data is required for that node, it is necessary to send data processing requests one by one, resulting in an increase in communication overhead.

An object of the present invention is to provide a distributed system processing method that solves the above problems.

[Means to solve the problem]

In order to achieve the above purpose, in a distributed database system that calls programs and transactions on a node different from the node on which the program is being executed,
Consistency of resources is guaranteed through two-phase commit, one-phase commit, and asynchronous processing.

[Effect] In transaction processing under a distributed system, the processing frequency is high on a certain remote node that is different from the node on which the application program is being executed.
If a lot of data is required from that node during business processing, a processing program is placed on that node in advance, and the client side calls that program as needed, and the necessary information is collected all at once. This is done by sending a message. Further, processing results from the server are also transferred all at once, or only simple results are transferred.

As for preparing processing programs in advance, if it is a routine job, you can know in advance which nodes will need it. For non-routine work, by transferring the processing program for the server (this processing program does not need to be versatile at all. It should be deleted after execution),
The aim is to optimize the processing nodes.

At the end of the transaction, resource consistency processing is performed like normal distributed DB processing.

〔Example〕

Hereinafter, one embodiment of the present invention will be described in detail with reference to the drawings.

FIG. 1 shows an example of the configuration of a distributed system used to implement the present invention, and shows a state in which a plurality of nodes can communicate via a communication network. Let node A be a client, and node B and node C be servers. Normally, in the system (1) of node A, if a data access request from an application program (4) is for data on the own node, the transaction management unit (5) recognizes that the access is for the own node. , accesses the database (7) of its own node through the data management processing unit (6). If the access request is from another node (node B, node C), the communication processing management unit (8) transmits the access request to the system (2, 3) of node B, node C. Node B and node C recognize this and update their own database (9
, 10) and returns a response to node A. Here, if the request from node A is a program call, node B and node C start the called program and include other node databases if necessary to access the database. ), and sends the processing result back to node A.

FIG. 2 shows the flow of transaction processing using the conventional two-phase commit method. Transaction start (100
) from the application program (4), the transaction management unit (5) generates a data processing request and sends it to a server (for example, node B) that has the necessary information (101). Recognize (
102), executed in database (9) 103
), and sends the result back to the client (node A) (
104). The client should receive this (105),
Data processing is performed in the database (6) of the own node (106). This process is repeated until all data processing in the transaction is completed.

(107 to 108, in the example shown in the figure, a total of three data processing requests are made to node B, and a total of two data processing requests are made to node C.) As can be seen from the figure, one data If the processing request and response fit into the communication buffer, the number of communications is (data processing request) x 2 times.

Next, the transaction management unit (5) receives the start of transaction end processing (120) from the application program (4), generates a commit guarantee request, and
It is sent to the systems of all servers (node B, node C) involved in the transaction (121, 126). Server (Node B.

Node C) recognizes this (122, 127) and issues a commit guarantee request (123, 128).

If the process is successful, a commit guarantee completion response is sent to the client, and if it fails, a commit guarantee failure response is sent to the client (
A reply is sent to node A) (124, 129). The client (node A) performs commit guarantee processing for its own node (131). Although shown separately in the diagram for ease of understanding, the commit guarantee processing (123, 128, 131) is performed in parallel on each node. When the client (node A) receives responses from all servers (125, 130), it determines whether all of the responses are commit guaranteed responses (140). If all nodes are in the commit guaranteed state, the client performs commit processing on its own node (141), generates a commit request in parallel, and sends it to the server (node B, node C) (142, 147).
. The servers (node B, node C) recognize this (143.148) and perform commit processing (144°14).
9) Returns a commit completion response to the client (node A) (145, 150). Upon receiving responses from all servers (146, 151), the client (node A
) ends the transaction (152). On the other hand, if there is a node that fails the commit guarantee, the client sends a roll pack request, rolls back all servers, and ends the transaction.

The two-phase commit described above guarantees consistency between resources in all cases, but has the drawback of high communication overhead. As shown in Japanese Unexamined Patent Publication No. 63-259742, when the data processing request is only for reference, when the data is updated only on one node, and in other cases, - temporal inconsistency is not allowed. 1 if
It is possible to optimize for phase commit.

FIG. 3 shows the flow of transaction processing in the present invention. The transaction initiation (100) is similar to that of FIG. Application program (4)
From there, the transaction management section (5) executes the program code.
) L/ (200, 207), it sends the program identifier and information equivalent to a data processing request in normal distributed DB processing to the server that has the called program all at once. Transfer (2
01.208). The server does not simply return data in the database as a processing result for one data processing request to the client as is, as in normal distributed DB processing;
) and execute it using the given information and the data in the local node database 203, 210), and only the execution results of that program (11, 12) are sent to the client (node) at once. Reply to A) (204, 211). (However, if it is a data reference, it goes without saying that the data will be returned as is.) If the data is not available only on the own node, then the resources of other nodes will be used again, so distributed DB processing, etc. It is also possible to make program calls (nested processing)
. As can be seen from the figure, if the data to be sent all at once is stored in the communication buffer, the number of communications required is x2 times (the number of remote nodes involved in the transaction). When there is a lot of processing on one server, compared to normal distributed DB processing, this
This results in a significant reduction in the number of communications.

After the transaction management unit (5) receives the transaction end processing start (120), the processing is performed between resources.
When using two-phase commit as a method for ensuring consistency, the process is the same as normal processing (120 to 152 and Figure 4).
. In addition, - as a method that does not guarantee consistency for boat fishing,
One-phase commit method (FIG. 5) and asynchronous (submit) method (FIG. 6) can be considered.

FIG. 5 shows a one-phase commit method. The usage may be different from normal distributed DB processing.

This is because the server runs its own program, which allows for its own control within the server. For example, when giving commit guarantee processing or commit processing authority to a program executed on a server, commit guarantee is performed at the end of execution on the server, and the client is made to respond with a commit guarantee completion response or a commit guarantee failure response. A single-phase unit can reduce communication overhead and ensure consistency.

In addition, when the processing on the server is only data reference,
Among all nodes involved in transaction processing,
If data updates occur only on one node, −
If temporal inconsistency is allowed, consistency can be guaranteed even if the server performs commit processing at its own discretion after returning the processing results to the client and releases resources.

If the above authority is not given to the server, the same optimization as the one-phase commit in the normal transaction processing described above is possible.

FIG. 6 shows asynchronous (submit) processing.

For example, if the client does not need to process the results of server processing, and even if data is updated, it does not need to be reflected in the database at the same time as other nodes; in other words, data updates are synchronized with other nodes. In cases where it is not necessary to perform such processing, asynchronous (submit) processing can significantly reduce communication overhead and ensure resource consistency.

In this case, the client-side node can, if necessary, update the operations performed on that node by the command.
It shall be possible to confirm success/failure.

Regarding failure recovery, the above processing is based on transaction processing under a distributed system, and therefore similar failure recovery is possible.

〔Effect of the invention〕

Transaction processing using program calls as described above is used to reduce communication overhead when the frequency of processing at a specific remote node, which is different from the node on which the application program is being executed, is much higher than processing at the own node. effective. Also in this case,
Two-phase commit, l-phase commit, and submit can be considered as inter-resource-quality processing methods, and by selecting a method suitable for the business to be executed, it is possible to reduce the number of communications for transaction termination processing. In this way, especially in routine work where a large amount of data is processed, the data is processed on a fixed node, and the processing program can be stored in advance on each node, the communication overhead can be reduced by
The invention is effective. The present invention is also useful for optimizing execution nodes in non-routine tasks.

[Brief explanation of drawings]

FIG. 1 is a diagram showing the configuration of a distributed system in which there are three nodes that can communicate with each other via a communication network according to an embodiment of the present invention. FIG. 2 is a diagram showing the flow of conventional transaction processing when two-phase commit is used. FIG. 3 is a diagram showing the flow of transaction processing by program calls when two-phase commit is used. FIG. 4 is a diagram showing program calls and two-phase commit processing. FIG. 5 is a diagram showing program calls and one-phase commit processing. FIG. 6 is a diagram showing asynchronous (submit) processing. Note Hanote I3 C No FA 2-Do B 1J1 timeKon51ko26NodeC

Claims (1)

[Claims] 1. In a distributed database system that calls a program or transaction on a node other than the node on which the program is being executed, a distributed database system is characterized in that consistency of resources is guaranteed by two-phase commit. System processing method. 2. A distributed system processing method characterized by guaranteeing resource consistency through one-phase commit in a distributed database system that calls a program or transaction on a node other than the node on which the program is being executed. 3. A distributed system processing method characterized by ensuring consistency of resources through asynchronous processing in a distributed database system that calls programs and transactions on a node other than the node on which the program is being executed.