JPH07282011A - Distributed transaction processing system - Google Patents

Abstract

(57) [Summary] [Purpose] In a distributed transaction processing system,
It is possible to collectively send and receive a plurality of commit control messages between different nodes. [Composition] Depending on the node to which each node 32 sends a commit control message 3482,
A transmission buffer 348 is provided. When a certain amount of commit control messages are stored in the transmission buffer, the transmission management unit 344 collectively transmits a plurality of commit control messages stored in the transmission buffer as one message. Upon receiving the batch-transmitted message, the reception management unit 342 breaks it down into a plurality of original commit control messages.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a distributed transaction processing system in which a plurality of computers are connected in a communication network so that the plurality of computers cooperate to perform transaction processing. Related to the process of sending and receiving transaction commit control messages.

[0002]

Transactions are a concept introduced by many data processing systems. A transaction is a sequence of processing performed by a user or an application program (AP). The data processing system performs exclusive control of data, failure recovery, and the like with a transaction as a management unit. Such a data processing system is generally called a transaction processing system.

A transaction is defined by an AP. The AP requests the start and end of a transaction. Between the start and end of the transaction, AP
Performs various processes on the data possessed by the transaction processing system, and they constitute one transaction. There are two methods of ending a transaction, called commit and rollback. The commit validates all the processes for the data performed in the transaction. Rollback is the opposite and invalidates all processing for the data performed in the transaction.

A distributed system in which a plurality of computers (nodes) are connected by a network and each node has a transaction processing system is called a distributed transaction processing system. In a distributed transaction processing system, a transaction defined by AP is divided into a plurality of transaction groups and processed by a plurality of nodes. Hereinafter, in the distributed transaction processing system, a transaction defined by AP is called a global transaction. On the other hand, a transaction that constitutes a global transaction and is processed by the transaction processing system of each node is called a transaction branch. In the following, global transaction is GTR and transaction branch is TBR.
Express.

The TBRs that compose the GTR have a parent-child relationship. That is, the parent TBR branches into the child TBR group. Bifurcation is generally possible in multiple stages. In this multi-stage parent-child relationship, the transaction processing system that processes the highest TBR is called a coordinator. The coordinator starts GTR commit or rollback processing in response to a global transaction commit or rollback request issued by the AP. A transaction processing system that processes a TBR having a parent TBR is called a subordinate, and a transaction processing system that processes a parent TBR is called a superior.

In order to commit the GTR without causing inconsistency in the data of the distributed transaction processing system, it is not enough for each transaction processing system to commit the TBR belonging to the GTR. If even one of the TBRs could not complete processing due to a failure, all TBRs
This is because the BR has to be rolled back. In order to guarantee this, it is necessary to synchronously control the commits of the TBRs constituting the GTR according to the commit of the GTR. Therefore, the commit control method used by many distributed transaction processing systems is two-phase commit. Hereinafter, the two-phase commit is referred to as 2PC.

The process flow of the 2PC will be described below. First, the case where there is only one stage of branching will be described. AP
However, when the GTR commits, the coordinator sends a prepare request to the subordinate groups. The subordinate sends an acknowledgment to the coordinator if it is in a normal state.
Here, if the status is abnormal due to a factor such as a failure, a negative response is transmitted. When the coordinator receives an acknowledgment from all the subordinates, the coordinator decides to commit the GTR,
Send the BR commit request. On the other hand, if even one subordinate returns a negative response, it decides to roll back the global transaction and sends a TBR abort request to the subordinate group. The subordinate performs commit or rollback processing in response to the received commit request or rollback request, and sends a commit response or rollback response to the coordinator.

If the branching is multi-stage, the following procedure between Superior and Subordinate is applied recursively. The coordinator sends a prepare request to its subordinate group. When the subordinate receives the prepare request from the superior, the subordinate sends the prepare request to its own subordinate group. The subordinate is in a normal state,
And it sends an acknowledgment to Superior only if it receives an acknowledgment from all subordinate groups. Otherwise, send a negative response to Superior. When the coordinator receives an acknowledgment from all of its subordinates, it decides to commit, or otherwise rollback, and sends a commit request or rollback request to its subordinates, respectively. Send to Nate group. When the subordinate receives a commit request or rollback request from Superior, the subordinate transmits the request to its own subordinate group, and then performs commit or rollback processing of the TBR that it has processed. Also, when the subordinate receives a commit response or rollback response from its own subordinate group and completes the TBR commit or rollback processing that it was processing, it sends a commit response to the superior. Or send a rollback response. In the following, in 2PC, requests and responses transmitted and received between transaction processing systems will be collectively referred to as commit control messages.

The distributed transaction processing system processes a plurality of GTRs in parallel. The transaction processing system of each node also processes a plurality of TBRs in parallel. That is, the transaction processing system of a certain node generally transmits / receives a commit control message to / from the transaction processing system of a plurality of nodes in parallel for a plurality of GTRs.

In the distributed transaction processing system using 2PC as described above, reducing the number of times of sending and receiving the commit control message between the nodes improves the throughput of the distributed transaction processing system. Therefore, a commit control method has been proposed in which a plurality of commit control messages are collectively transmitted and received between transaction processing systems of different nodes.

For example, as a first conventional example, Japanese Patent Application No. 5-489.
There is No. 56. In this conventional example, Ts belonging to the same GTR are
When the other parties of the BR group for sending and receiving the commit control messages are the same transaction processing system, the plurality of commit control messages are collectively sent and received.

As a second conventional example, Japanese Patent Laid-Open No. 1-19404
There is No. 0. In this conventional example, when a transaction processing system cannot continue due to a failure, the transaction processing system and the superior and subordinate of the transaction processing system are included in the recovery processing after the failure is recovered. A plurality of commit control messages regarding the TBR group that the transaction processing system, which cannot continue processing, has been processing are collectively transmitted and received between the transaction processing systems.

The common point between the above-mentioned two conventional examples is that a synchronization point is provided between the transmission / reception processing of a plurality of commit control messages, and the batch processing thereof is performed. For the plurality of TBRs processed by the transaction processing system, the periods in which those 2PCs are performed do not necessarily overlap. This is because if a plurality of TBRs belong to different GTRs, their 2PCs are not always performed at the same time. Unless 2PCs of a plurality of TBRs are performed at the same time, it is impossible to collectively send and receive commit control messages for them.

Therefore, in the first conventional example, the same GTR is used.
The target is limited to only the TBR group belonging to. That is, in the case of TBRs belonging to the same GTR, the fact that 2PC is performed at the same time is used, and at the time of transmitting / receiving the commit control message for the GTR, synchronization between the transmission / reception processes of a plurality of commit control messages Is taking.

Further, in the second conventional example, the target is limited to the recovery processing after a failure occurs. In the recovery process,
At the same time, a commit control message for a TBR group to be recovered is transmitted and received between the transaction processing system that has continued processing and another transaction processing system. That is, when the recovery process is performed, the transmission and reception processes of the plurality of commit control messages are synchronized.

On the other hand, in a communication control system used by a transaction processing system of each node, that is, in a system for managing communication via a communication network, a technique for collectively transmitting a plurality of messages between nodes has been proposed. ing. This is, for example, the third conventional example, Comer; “Network construction by TCP / IP V
ol. I, "Kyoritsu Shuppan, 1991. p.140 and p.1
As described in 64, the communication control system on the transmitting side temporarily stores the message to be transmitted for each connection of communication. When a certain amount of messages are stored, the transmission side communication control system collectively transmits the stored plurality of messages to the reception side communication control system.

Here, the communication connection is a concept of connecting a message sending side and a message receiving side. That is, when two programs that send and receive messages multiple times exist in different nodes, and each sends and receives messages to and from each other via the communication control system of its own node, A connection is created with and messages are sent and received. That is, the batch transmission is applied to a series of message groups between the two programs connected by the connection.

Now, consider a distributed transaction processing system to which the third conventional example is applied. Individual node transaction processing systems typically
It has a means for processing BR. The means for processing the TBR is one TBR or a plurality of TBRs at a time.
To process. Further, a plurality of means for processing the above TBR generally exist in a transaction processing system. Here, the program corresponds to a means for processing the TBR. The means for processing the TBR is
Messages are transmitted / received to / from the means for processing the TBR of the transaction processing system of another node via the communication control system. That is, the batch transmission in the communication control system described above is applied to the messages transmitted and received between the means for processing two TBRs of the transaction processing systems of different nodes.

[0019]

The above-mentioned conventional example has the following problems. In the first conventional example, the case where a plurality of commit control messages can be collectively transmitted and received is limited to a special case. That is, a plurality of child TBRs of a TBR processed by a transaction processing system
Are processed by the same transaction processing system, or multiple TBRs belonging to the same GTR are
Each child TB of the plurality of TBRs processed by the same transaction processing system
This is the case when R is processed by the same transaction processing system. In other cases, batch transmission / reception of commit control messages cannot be performed.

Further, in the second conventional example, a plurality of commit control messages can be collectively transmitted and received only in the recovery process after a failure occurs. In 2PC in a normal state, it is not possible to collectively send and receive a plurality of commit control messages.

On the other hand, in the third conventional example, batch transmission / reception of a plurality of commit control messages is performed for each communication connection. That is, a commit control message that is collectively transmitted and received in a certain node is limited to the commit control message that is transmitted and received by one TBR processing means of the transaction processing system of the node. It is not possible to collectively send and receive a plurality of commit control messages sent and received by a plurality of TBR processing means of the transaction processing system.

Further, in the third conventional example, the transaction processing system of each node sends and receives a commit control message for each individual commit control message via the communication control system. Here, in the node, each time the commit control message is passed to the communication control system, the processing of the communication control system is performed. In other words, when the transaction processing system tries to send and receive a plurality of commit control messages for a plurality of TBRs with the transaction processing systems of other nodes at the same time, the communication control corresponding to the number of commit control messages is performed. System processing is required, and the overhead of sending and receiving the commit control message increases.

An object of the present invention is to collectively transmit and receive a plurality of commit control messages for a plurality of TBRs between transaction processing systems regardless of which GTR a TBR processed by the transaction processing system belongs to. The object is to provide a distributed transaction processing system that can do so.

An object of the present invention is to provide a distributed transaction processing system capable of collectively transmitting and receiving a plurality of commit control messages for a plurality of TBRs among transaction processing systems regardless of the state of the distributed transaction processing system. Especially.

Further, an object of the present invention is to control a plurality of commits for a plurality of TBRs among transaction processing systems regardless of which TBR processing means is processing the TBRs processed by the transaction processing system. It is to provide a distributed transaction processing system capable of collectively transmitting and receiving messages.

A further object of the present invention is to reduce the processing overhead added by the communication control system to the transmission / reception processing of the commit control message between the transaction processing systems of different nodes in the distributed transaction processing system.

[0027]

In order to achieve the above object, the distributed transaction processing system of the present invention comprises:
The transaction processing system of each node includes means for temporarily storing the commit control message to be transmitted to the node for each node to which the transaction processing system transmits the commit control message.

Further, the distributed transaction processing system of the present invention, when a commit control message to be transmitted to another node occurs in the transaction processing system of each node, the commit control message is sent to the node. Means for storing the commit control message in the means.

Further, the distributed transaction processing system according to the present invention comprises means for monitoring whether or not a certain amount of commit control messages are stored in the means for storing the commit control messages in the transaction processing system of each node. .

Further, in the distributed transaction processing system of the present invention, the plurality of commit control messages stored in the transaction processing system of each node are stored in the transaction processing system of each node. The above-mentioned means for accumulating the commit control message is provided with a means for collectively transmitting it as one message to the target node.

Furthermore, the distributed transaction processing system of the present invention allows the transaction processing system of each node to receive the message transmitted in a batch, and a plurality of commit control messages including the message. And passing each commit control message to the means for processing the TBR targeted by it.

[0032]

According to the present invention, in the distributed transaction processing system, the transaction processing system of each node commits the commit control message when a certain amount of commit control message is stored in the means for storing the commit control message. A plurality of commit control messages stored in the control message storing means are collectively transmitted to the transaction processing system of the node targeted by the commit control message storing means. As a result, the transaction processing system determines which GBR is the TBR related to the commit control message.
A plurality of commit control messages can be collectively sent to the transaction processing system of another node regardless of whether they belong to TR.

In the transaction processing system, whether the distributed transaction processing system is in a normal state with no fault or in a fault state,
Since the means for storing the commit control message can be used, a plurality of commit control messages can be collectively transmitted to the transaction processing systems of other nodes regardless of the state of the distributed transaction processing system.

Further, according to the present invention, in the distributed transaction processing system, the transaction processing system of each node can execute the commit regardless of which TBR processing means processes the TBR related to the commit control message. For control messages,
A means for storing the commit control message for the node to which the commit control message is transmitted can be used. As a result, the transaction processing system collectively transmits a plurality of commit control messages for a plurality of TBRs to the transaction processing system of another node regardless of which TBR processing means processes the TBR. Can be sent.

Further, according to the present invention, in the distributed transaction processing system, the transaction processing system of each node collects a plurality of commit control messages into one message and collectively transmits it to the communication control system. Can be delivered. This allows
In the transmission and reception of the commit control message between the transaction processing systems of different nodes, the number of times the processing of the communication control system is performed can be reduced.

Further, according to the present invention, in the distributed transaction processing system, when the transaction processing system of each node collectively receives the plurality of commit control messages transmitted in a batch, the transaction processing system of the plurality of original Decompose into commit control messages, and for each TBR targeted by each commit control message,
Processing according to the commit control message can be performed.

[0037]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The first embodiment of the present invention and the difference between the present invention and the first conventional example will be described with reference to FIGS. Figure 1
FIG. 3 is a conceptual diagram of a distributed transaction processing system to which the present invention is applied. The distributed transaction processing system 10 is a distributed system including a plurality of nodes 121 to 126. The nodes 121 to 126
Are connected by a communication network, but the communication network is omitted in this figure. A transaction processing system 14 exists in each node. The transaction processing system is
Transaction branch 16 that has been input to the node
To process. Hereinafter, the transaction processing system will be referred to as TM, and the transaction branch will be referred to as TBR.

FIG. 1 shows the situation of distributed transaction processing system 10 at some point in time. At this time, in this distributed transaction processing system, four global transactions (GTR) 18 are processed. Multiple TBRs belong to each GTR. Their TB
The R group is processed by being distributed to a plurality of nodes. TB
For the GTR that uses R161 as the highest TBR, TBR1
62, TBR163, TBR164, and TBR16
5 belong. GTR with TBR166 as the highest TBR
TBR167, TBR168, TBR169, T
BR 170 belongs. GT with TBR171 at the top
TBR171, TBR172, and TBR173 belong to R. In addition, GTR with TBR174 as the highest rank
Include TBR174, TBR175, and TBR17
6 belongs. The arrow 182 in the figure shows the parent-child relationship of these TBRs depending on the direction of the arrow, but at the same time, it also shows the transmission and reception of the commit control message between the transaction processing systems. Also, TM of each node
14 processes a plurality of TBRs in parallel. For example, the TM of the node A 121 processes the TBR 161 and the TBR 166.

Now, it is assumed that the above two GTR 2PCs are in progress at the same time. Here, the distributed transaction processing system of the present invention collectively transmits and receives a plurality of commit control messages between the transaction processing systems of individual nodes. For example, node A1
21 between the node 21 and the node C123, the TBR 161 and the TBR
162, TBR161 and TBR163, and TBR1
66 and TBR 167, the commit control message for each pair may be sent and received in bulk.

Here, TBR 161, TBR 162, T
BR163, TBR166, and TBR167 belong to different GTRs. According to the present invention, as described above, even the commit control messages regarding the TBRs belonging to different GTRs can be collectively transmitted / received between the transaction processing systems. In FIG. 1, the commit control message transmission / reception processing that can be collectively performed in this way is shown by enclosing it with an ellipse 184.

Next, the difference between the present invention and the first conventional example of the present invention will be described with reference to FIG. FIG. 2 is a conceptual diagram of a distributed transaction processing system to which the first conventional example is applied. FIG. 2 has almost the same configuration as FIG. However, the number of ellipses 184 indicating the commit control message transmission / reception processing that can be collectively performed is small. This is because, in this conventional example, the target of batch transmission / reception of the commit control message is limited to TBRs belonging to the same GTR.

For example, node A 121 and node C 123
Between TBR161 and TBR162, TBR161 and TBR
163, the commit control message for each pair is sent and received collectively. TBR162, TBR164, TBR16 between the node C123 and the node E125
The same applies to each pair of 3 and TBR 165. However, unlike the distributed transaction processing system of FIG. 1, the commit control message for the pair of TBR166 and TBR167 is not collectively transmitted and received with the above commit control message. This is TBR161,
TBR162, TBR163, and TBR166, TB
This is because R167 belongs to different GTR. Similarly, between the node B122 and the node D124, the TBR
171, TBR 172, TBR 174 and TBR 175,
TBR172 and TBR173, TBR175 and TBR1 between each pair and between node D124 and node F126
76. Batch transmission / reception of commit control messages is not applied to each pair.

As described above, in the distributed transaction processing system to which the present invention is applied, the T of each node is
If M is a TBR group in which 2PC is performed at the same time, regardless of whether or not they belong to the same GTR,
Commit control messages about them can be collectively transmitted and received with TMs of other nodes. For this reason,
The number of commit control messages to which batch transmission / reception can be applied is increased compared to the distributed transaction processing system to which the first conventional example is applied. Therefore, according to the present invention, the throughput of the distributed transaction processing system can be improved.

Next, a second embodiment of the present invention will be described with reference to FIGS. The present embodiment is for showing the operation of the TM of each node in the distributed transaction processing system to which the present invention is applied.

First, FIG. 3 will be described. FIG. 3 is a configuration diagram of a distributed transaction processing system to which the present invention is applied. The distributed transaction processing system 30 is a distributed system in which a plurality of nodes 32 are connected by a communication network 36. A transaction processing system (TM) 34 and a communication system 35 exist in each node. The communication system 35 manages communication between nodes via the communication network 36. The TM 34 includes a TBR processing unit 340, a reception management unit 342, a transmission management unit 344, and a plurality of transmission buffers 348. In addition,
The send buffer 348 is the core of the present invention, and is a means for storing the commit control message to be sent to another node. Further, the reception management unit 342 and the transmission management unit 344 are
This is a part to which the present invention is applied.

The TBR processing unit 340 processes a plurality of TBRs input to the node in parallel. Therefore, T
The BR processing unit has a plurality of TBR processing processes 3402. At one point in time, one TBR processing process only processes one TBR. When the TBR processing unit accepts a new TBR, the TBR is free
It is processed by the BR processing process. When the TBR processing unit accepts the message, the message is
The message is passed to the TBR processing process that processes the target TBR. Further, the TBR processing process passes a message to be transmitted to the TM of another node to the transmission management unit. Details of the control method of the TBR processing process are omitted because they are not directly related to the present invention.

The transmission buffer 348 is the TM of the node.
However, a plurality of nodes exist for each node to which the commit control message is to be transmitted. For example, node A32
0 TM is node B322, node C324, and
If a commit control message is to be transmitted to the node D 326, the TM of the node A has a transmission buffer for the node B, a transmission buffer for the node C, and a transmission buffer for the node D.

The transmission management unit 344 uses the commit control message 3 for the TBR processed by the TM of the node.
A message such as 482 is received from the TBR processing unit and transmitted to the TM of another node. If the message is a commit control message, the transmission management unit stores the message in the transmission buffer 348 corresponding to the destination node. Further, when the transmission buffer becomes full, the transmission management unit combines a plurality of commit control messages 3482 stored in the transmission buffer into one message, and the transmission buffer stores the same in the TM of the target node. Send.

The reception management unit 342 receives a message such as a commit control message for TBR processed by the TM of the node, and passes the message to the TBR processing unit. Further, if the received message is a bundle of a plurality of commit control messages, the reception management unit decomposes the received message into a plurality of original commit control messages. Further, the reception management unit passes the commit control message restored by the above decomposition to the TBR processing unit.

Next, the configuration of the transmission management unit 344 will be described with reference to FIG. The transmission management unit includes a transmission control unit 3442,
The transmission processing unit 3444 and the transmission buffer management unit 3446 are included. The arrows in the figure show how the commit control message is passed inside the transmission management unit. The transmission control unit 3442 receives the message to be transmitted from the TBR processing unit and passes it to the transmission control unit and the transmission buffer management unit. Here, when the message is a commit control message, the transmission control unit 3442 passes the message 3482 to the transmission buffer management unit. The transmission processing unit 3444 receives the message to be transmitted from the transmission control unit and the transmission buffer management unit, and transmits the message to the destination node of the message. The transmission buffer management unit 3446 stores the commit control message received from the transmission control unit in the transmission buffer 348 for the destination node of the message. Further, when the transmission buffer becomes full, the transmission buffer management unit changes the plurality of commit control messages 3482 stored in the transmission buffer into one message for the node targeted by the transmission buffer. Put together. Further, the transmission buffer management unit passes the above-mentioned one message to the transmission processing unit. Hereinafter, the above-mentioned one message is referred to as a collective message 3484.

Next, referring to FIG. 5, a commit control message 3482 and a batch message 348 in this embodiment.
The structure of No. 4 will be described. FIG. 5 shows an example of the commit control message and the batch message. In this embodiment, the commit control message 3482 is the destination node 34822, GTR identifier 34824, TBR identifier 3
It is composed of fields such as 4826 and message type 34828. The destination node 34822 is
Indicates the destination node to which the commit control message should be sent. The GTR identifier 34824 indicates the GTR to which the TBR of the destination to which the commit control message should be transmitted belongs. The TBR identifier 34826 indicates the TBR of the destination to which the commit control message should be transmitted. In this embodiment, the TBR is uniquely identified in the distributed transaction processing system of this embodiment by the combination of the GTR identifier and the TBR identifier. The message type 34828 indicates the type of the commit control message. Types of the commit control message 3482 include prepare request, prepare response, commit request, commit response, rollback request, rollback response, and the like.
As is clear from the above description of the structure, in the distributed transaction processing system of this embodiment, all commit control messages have the same size.

A collective message 3484 is a destination node 34822, a message type 34824, and a message number 34.
830 and a plurality of commit control messages 3482
It is composed of fields such as. Destination node 34
Reference numeral 822 denotes a destination node to which the batch message should be transmitted. The message type 34824 indicates that the message is a collective message. Number of messages 3
Reference numeral 4830 indicates the number of commit control messages included in the batch message.

In the distributed transaction processing system of this embodiment, messages other than the commit control message and the batch message are also transmitted and received between TMs of different nodes. Although detailed description of such messages is omitted, it is assumed that these messages also have a destination node 34822 in the first field and a message type 34824 in the second field, like the commit control message and the batch message.

Next, the control data used by the transmission buffer management unit 3446 to manage the transmission buffer 348 will be described with reference to FIG. FIG. 6 shows a transmission buffer management table 34 provided in the transmission buffer management unit 3446.
The structure of 62 is shown. The transmission buffer management table is a table having records according to each transmission buffer. Each record of the transmission buffer management table is composed of a transmission buffer number 34620, a destination node 34622, and a message number 34624. The transmission buffer number 34620 is a serial number attached to the transmission buffer. The transmission buffer number is unique in the TM of each node. The destination node 34622 indicates a node targeted by the transmission buffer. For example, in FIG. 6, the transmission buffer with the transmission buffer number 01 is a transmission buffer provided for the node “NODE-B”. Number of messages 34624
Indicates the number of commit control messages stored in the transmission buffer. In the distributed transaction processing system of this embodiment, all the transmission buffers 348 have the same size. As described above, since all commit control messages 3482 have the same size, it is possible to judge whether or not the transmission buffer is full by the message number 34624.

Next, the transmission management unit 3 will be described with reference to FIGS.
The processing flow of 44 will be described. First, FIG. 7 will be described.
FIG. 7 shows a processing flow of the transmission control unit 3442. The transmission controller receives the message from the TBR processor 340 (702). The message is the TBR processing unit T
The BR processing process 3402 generates a TBR processed by the TBR processing process as a commit control message for its child TBR or parent TBR. Next, the transmission control unit checks whether the message is a commit control message (704). This is possible by referring to the message type 34828 in the message. Here, if the message is not the commit control message, the message is passed to the transmission processing unit 3444 (708) and the process ends. If the message is a commit control message, the commit control message is passed to the transmission buffer management unit 3446 (706), and the process ends.

Next, the processing flow of the transmission buffer management unit 3446 will be described with reference to FIG. The transmission buffer management unit receives the commit control message 34 from the transmission control unit 3442.
Receive 82 (802). Here, the transmission buffer management unit determines the destination node of the commit control message (804). This is possible by referring to the destination node 34822 in the commit control message 3482 shown in FIG. Next, the transmission buffer management unit scans the transmission buffer management table 3462 to find a record for the transmission buffer 348 for the destination node (806). Thereby, the transmission buffer management unit specifies the transmission buffer for the destination node of the commit control message. Next, the transmission buffer management unit increments the commit control message number 34624 stored in the transmission buffer for the destination node in the record of the transmission buffer management table (808). Next, the transmission buffer management unit stores the commit control message received in step 802 in the transmission buffer (810).

Next, the transmission buffer management unit determines whether or not the transmission buffer is full (812).
This is done by determining whether the number of commit control messages 34624 incremented in step 808 is the same as the number of commit control messages that can be stored in the send buffer 348 in the record of the send buffer management table found in step 806. It is possible. Here, if the transmission buffer is not full, the process ends. On the other hand, if the transmission buffer is full, the transmission buffer management unit creates a batch message 3484 with all the commit control messages stored in the transmission buffer (814). Next, the transmission buffer management unit passes the batch message to the transmission processing unit 3444 (816). After that, the transmission buffer management unit erases all commit control messages stored in the transmission buffer (818). Finally, the transmission buffer management unit sets the commit control message number 34624 stored in the transmission buffer in the record of the transmission buffer management table found in step 806 to 0 (820), and ends.

FIG. 9 shows a processing flow of the transmission processing unit 3444. The transmission processing unit is the transmission control unit 3442, or
Receives a message from the transmission buffer management unit 3446
(902). The transmission processing unit determines the destination node of the message (904). This is possible by referring to the destination node 34822 in the message. Next, the transmission processing unit transmits the message to the node determined in step 904 (906), and ends.

Next, with reference to FIG. 10, the reception management unit 342
The processing flow of is described. The reception management unit receives a message from the TM 34 of another node via the communication network (1002). Next, the reception management unit determines whether the message is a batch message (1004). This is possible by referring to the message type 34828 in the message. Here, if the message is not the collective message, the message is passed to the TBR processing unit 340 (1014) and the process ends. On the other hand, if the message is a batch message, the reception management unit determines the number of commit control messages included in the batch message (1006). This is the collective message 3 shown in FIG.
This is possible by referring to the message number 34830 in 484. Next, the reception management unit extracts one commit control message 3482 from the batch message (1008). Further, the reception management unit changes the commit control message extracted in step 1008 to TBR.
It is passed to the processing unit 340 (1010). In the TBR processing unit, the commit control message is passed to the TBR processing process 3402 which processes the TBR targeted by the commit control message. This is because the TBR processing unit
GT in the commit control message 3482 shown in FIG.
This is possible by referring to the R identifier 34824 and the TBR identifier 34826.

Next, the reception management unit determines whether or not all the commit control messages included in the batch message have been extracted from the batch message (101).
2) If extraction has not been completed, return to step 1008. This is possible by using the number of commit control messages 34830 included in the batch message determined in step 1006. That is, the reception management unit repeats Step 1008 and Step 1010 as many times as the number of commit control messages 34830. Thereby, the reception management unit decomposes the collective message received from the TM of the other node into the commit control message group included in the collective message, and
The commit control message can be passed to the TBR processing process 3402 that processes the target TBR.
If it is determined in step 1012 that all the commit control messages have been extracted from the batch message, the reception manager ends the process.

As can be seen from the second embodiment, according to the present invention, in the distributed transaction processing system,
The TM of each node can collectively send a plurality of commit control messages to be sent to the node by using the send buffer 348 provided for the node to which the commit control message is sent. Become.

Further, according to the present invention, in the distributed transaction processing system, the TM of each node uses the send buffer 348 regardless of the states of the TM and other TMs to batch commit control messages. Can send and receive.

Here, the difference between the present invention and the third conventional example of the present invention will be described. The distributed transaction processing system to which the third conventional example of the present invention is applied is the same as the distributed transaction processing system of FIG.
2, the transmission management unit 344 and the transmission buffer 348 are excluded. In the distributed transaction processing system of the third conventional example, the TBR processing process 3402 that processes each TBR transmits / receives a message to / from the TBR processing process 3402 of the TM 34 of another node via the communication system 35. . The communication system 35 temporarily stores the messages transmitted and received between the two TBR processing processes, and then collectively transmits the plurality of messages. However, in the distributed transaction processing system of the third conventional example, it is not possible to collectively transmit the commit control messages to be transmitted by a plurality of TBR processing processes in the TM of each node.

On the other hand, as can be seen from the second embodiment,
In the distributed transaction processing system of the present invention, the reception management unit 342 and the transmission management unit are provided in the TM 34 of each node.
By providing the transmission buffer 348 for each destination node 344 and 344, the commit control message for a plurality of TBRs, that is, the commit control message that a plurality of TBR processing processes try to transmit, is transmitted by the TMs of the two nodes. In between, it is possible to collectively send and receive.

In the third conventional distributed transaction processing system, the TM34 is used in each node.
However, each time the commit control message 3482 is transmitted and received via the communication system 35, the processing of the communication system is performed. On the other hand, as can be seen from the second embodiment,
In the distributed transaction processing system of the present invention, the processing of the communication system is performed every time the TM 34 transmits / receives the collective message 3484 via the communication system in each node. The batch message is
Since a plurality of commit control messages stored in the transmission buffer 348 for each destination node are collected, the present invention can reduce the number of times the communication system performs processing in the commit control message transmission / reception processing. it can.

Next, a third embodiment of the present invention will be described.
In the second embodiment, the TM34 of each node is
A send buffer 348 was provided for every node 32 that could be the destination of the commit control message. That is, the TM of the individual node may or may not actually generate the commit control message 3482 to be transmitted to a certain node, but if there is a possibility of transmitting the commit control message to the node in the future, A transmission buffer 348 for the node is provided. Here, in the distributed transaction processing system according to the third embodiment, the transmission buffer management unit 344 in the TM of each node.
6 receives a commit control message to be sent to a node, the send buffer 348 for that node
If there is not, a new transmission buffer is created. On the other hand, if there is a transmission buffer for the node, the commit control message is stored in the transmission buffer. Further, the transmission buffer management unit erases the transmission buffer when the batch transmission of the commit control message is completed for the transmission buffer.

The transmission buffer management unit manages the generation and deletion of the above transmission buffer using the transmission buffer management table 3462 shown in FIG. When the transmission buffer management unit generates a transmission buffer for a certain node, it adds a record for the transmission buffer to the transmission buffer management table 3462. Further, the transmission buffer management unit deletes a record for the transmission buffer from the transmission buffer management table when deleting a certain transmission buffer. Further, the transmission buffer management unit can determine whether or not the transmission buffer for the node exists by determining whether or not the above record exists in the transmission buffer management table.

According to the third embodiment, in each TM of the distributed transaction processing system of the present invention, the send buffer 348 is maintained for the node for which the process of sending the commit control message is actually unnecessary. It is possible to avoid wasting memory.

Next, a fourth embodiment of the present invention will be described.
In the third embodiment, the TM34 of each node is
It was creating and erasing send buffers as needed. In the distributed transaction processing system according to the fourth embodiment of the present invention, the TM of each node always has a fixed number of transmission buffers 348. However, in the initial state, the transmission buffer does not target a specific node. In the fourth embodiment, a transmission buffer that does not target a specific node as described above is called an empty transmission buffer.

When the transmission buffer management unit 3446 receives the commit control message 3482 to be transmitted to a certain node, if there is no transmission buffer 348 for the node, one transmission buffer is selected from the transmission buffers in the empty state. , Assign for the node. On the other hand, if there is a transmission buffer for the node, the commit control message is stored in the transmission buffer. Further, when the transmission buffer management unit completes the batch transmission of the commit control message for the transmission buffer, the transmission buffer management unit sets the transmission buffer to the empty state again.

The transmission buffer management section 3446 allocates the above-mentioned empty state of the transmission buffer and allocation to the node.
It manages using the transmission buffer management table 3462 shown in FIG. Records for all the transmission buffers 348 are resident in the transmission buffer management table. Here, in the record for the transmission buffer in the empty state, data indicating the empty state is set in the destination node 34622. On the other hand, in the record for the transmission buffer assigned to a certain node, the data indicating the node is set in the destination node. The transmission buffer management unit can determine whether the transmission buffer is empty by referring to the destination node 34622.

According to the fourth embodiment, in each TM of the distributed transaction processing system of the present invention, it is possible to maintain more than the actual required number of the transmission buffers 348 to avoid wasteful occupation of the memory, and at the same time, to perform transmission. The buffer
It is possible to avoid an increase in the overhead for creating and deleting many times.

In the fourth embodiment, the TM 34 of each node is always provided with a fixed number of transmission buffers 348. However, if the TM is required, the number of the transmission buffers is A configuration that changes dynamically is also conceivable.

Next, a fifth embodiment of the present invention will be described.
In the second embodiment, the TM34 of each node is
When the send buffer 348 for a node is full,
All the commit control messages 3482 stored in the transmission buffer have been collectively transmitted to the node. Here, in the distributed transaction processing system according to the fifth embodiment of the present invention, in the TM of each node,
The transmission management unit 344 uses the transmission buffer 34 for a certain node.
When a fixed number of commit control messages are stored in 8, all the commit control messages stored in the transmission buffer are collectively transmitted to the node. In this embodiment, the TM of each node may use a different number of commit control messages as a reference for starting the batch transmission of the commit control messages for each send buffer. Also, the number of commit control messages serving as the reference may be dynamically changed.

According to the fifth embodiment, in the distributed transaction processing system of the present invention, T of each node is
The M34 can determine the number of commit control messages to be collectively transmitted and received according to the frequency of transmission and reception of commit control messages between the TM and another TM.

In the fifth embodiment, when the TM 34 of each node stores a certain number of commit control messages in the send buffer 348, the TM 34 stores all commit control messages stored in the send buffer. Although it is assumed that the TM34s are collectively transmitted, the TM 34 changes the size of the transmission buffer 348 according to the frequency of sending and receiving the commit control message between the TM and another TM, and the transmission buffer is full. It is also conceivable that all the commit control messages stored in the transmission buffer are collectively transmitted when this happens.

Next, a sixth embodiment of the present invention will be described.
In the second embodiment, the TM34 of each node is
Only when the transmission buffer 348 for a certain node is full, all the commit control messages 3482 stored in the transmission buffer are transmitted to the node at once. Here, in the distributed transaction processing system of the sixth exemplary embodiment of the present invention, when the transmission buffer management unit 3446 in the TM of each node stores the first commit control message in the transmission buffer 348 for a certain node. , Start time monitoring. Here, the transmission buffer management unit collectively transmits all the commit control messages stored in the transmission buffer to the node after a certain period of time elapses. On the other hand, if the transmission buffer becomes full before the elapse of the fixed time, all commit control messages stored in the transmission buffer are collectively transmitted to the node.
In addition, the transmission buffer management unit, after completing the batch transmission of the commit control message for the transmission buffer,
The time monitoring is finished.

According to the sixth embodiment, in the distributed transaction processing system of the present invention, T of each node is
The M34 can apply batch transmission / reception of commit control messages according to the frequency of transmission / reception of commit control messages between the TM and another TM. In particular,
If the frequency of transmission and reception is not constant, it is possible to prevent the transmission of the commit control message from being delayed.

Next, a seventh embodiment of the present invention will be described.
In the second embodiment, the TM34 of each node is
Commit control message 34 with TM of another node
For 82 transmission / reception, batch transmission / reception was always applied. Here, in the distributed transaction processing system of the seventh embodiment of the present invention, in the TM of each node,
When receiving the commit control message, the transmission control unit 3442 normally passes the commit control message to the transmission processing unit 3444. However, the transmission control unit monitors the frequency of transmission of commit control messages to other nodes. When the transmission control unit receives a new commit control message when the frequency of transmission of the commit control message to a certain node is equal to or higher than a certain frequency, the transmission control unit sends the commit control message to the transmission buffer management unit 344.
Pass to 6. The transmission buffer management unit performs the same processing as in the second embodiment. When the transmission frequency of the transmission of the commit control message to a certain node is equal to or lower than a certain frequency, the transmission control unit receives the new commit control message and passes the commit control message to the transmission processing unit. In the present embodiment, the transmission control unit sets a different value for the frequency of transmission of the commit control message for each node to which the commit control message is transmitted,
It can be used as a reference value for deciding whether to collectively send and receive commit control messages.

According to the seventh embodiment, in the distributed transaction processing system of the present invention, T of each node is
The M34 can apply batch transmission / reception of commit control messages according to the frequency of transmission / reception of commit control messages between the TM and another TM.

[0081]

According to the present invention, in a distributed transaction processing system, if the transaction processing system of each node is a group of transaction branches that are processed at the same time, the commit control messages for them are sent to other nodes. You can send and receive to and from TMs at once. As a result, the throughput of the distributed transaction processing system can be improved.

[Brief description of drawings]

FIG. 1 is a conceptual diagram showing a first embodiment of a distributed transaction processing system to which the present invention is applied.

FIG. 2 is a conceptual diagram of a distributed transaction processing system to which a first conventional example is applied.

FIG. 3 is a configuration diagram of a distributed transaction processing system according to a second embodiment of this invention.

FIG. 4 is a block diagram showing a configuration of a transmission management unit of each node in the second exemplary embodiment of the present invention.

FIG. 5 is an explanatory diagram showing structures of a commit control message and a batch message in the second embodiment of the present invention.

FIG. 6 is an explanatory diagram showing the structure of a transmission buffer management table in the second embodiment of the present invention.

FIG. 7 is a flowchart showing a processing flow of a transmission control unit according to the second embodiment of the present invention.

FIG. 8 is a flowchart showing a processing flow of a transmission buffer management unit in the second exemplary embodiment of the present invention.

FIG. 9 is a flowchart showing a processing flow of a transmission processing unit in the second embodiment of the present invention.

FIG. 10 is a flowchart showing a processing flow of a reception management unit in the second exemplary embodiment of the present invention.

[Explanation of symbols]

10 ... Distributed transaction processing system, 14 ... Transaction processing system (TM), 16 ... Transaction branch (TBR), 18 ... Global transaction (GTR), 30 ... Distributed transaction processing system, 32 ... Node, 34 ... Transaction processing system (TM) ) ... 340 ... TBR processing section, 342 ... reception management section, 344 ... transmission management section, 3442 ... transmission control section,
3444 ... Transmission processing unit, 3446 ... Transmission buffer management unit, 3462 ... Transmission buffer management table, 348 ... Transmission buffer, 3482 ... Commit control message, 34
84 ... Collective message.

Claims (10)

[Claims] 1. A transaction which operates in a distributed system in which a plurality of computers having communication control means are connected by a communication network, branches into a distributed transaction input by a user or an application program, and is processed by the plurality of computers. Is a distributed transaction processing system having a means for processing multiple transactions in parallel by each computer, and a destination to which the computer sends a commit control message to the means for processing the transactions of each computer in parallel. For each node, means for temporarily storing a commit control message to be transmitted to the node, and a plurality of commit control messages stored in the means for storing the commit control message, a means for storing the commit control message Target Distributed transaction processing system to de, characterized in that it comprises means for transmitting collectively as a single message. 2. A means for processing transactions of individual computers according to claim 1 in parallel is provided for a node to which the commit control message is sent when the computer attempts to send a commit control message. A distributed transaction processing system comprising: means for storing a commit control message; and means for storing the commit control message. 3. The means for processing transactions of individual computers according to claim 2 in parallel, the means for checking the number of commit control messages stored in the means for storing the commit control message, and the commit control message. When a certain amount of commit control messages are stored in the storing means, a means for requesting the means for collectively transmitting the commit control messages to transmit the stored commit control messages is provided. Distributed transaction processing system. 4. A means for processing transactions of individual computers in parallel according to claim 3, and a means for receiving the collectively sent messages, and a plurality of commit control messages included in the messages. And the decomposed commit control message,
A distributed transaction processing system comprising means for passing a transaction related to the commit control message to a means for processing. 5. The means for processing transactions of individual computers according to claim 1 in parallel, when a commit control message to be sent to a node occurs, means for storing the commit control message for the node. A distributed transaction processing system comprising: a means for generating and a means for deleting the means for storing the commit control message when the commit control messages stored in the means for storing the commit control message are collectively transmitted. 6. A means for concurrently processing transactions of individual computers according to claim 1, when the commit control message to be transmitted to a certain node is generated, the means for storing the commit control message which is not used. , A distributed transaction processing system comprising means for defining means for storing the commit control message for the node. 7. A means for processing transactions of individual computers according to claim 2 in parallel, a means for monitoring an occurrence frequency of transmission of a commit control message to another node, and the occurrence frequency being a certain fixed frequency. When the commit control message is reached, means for passing the commit control message to the means for storing the commit control message, and when the occurrence frequency falls below a certain fixed frequency, the means for sending the commit control message to another node. A distributed transaction processing system characterized by: 8. The number of commit control messages used by the means for requesting transmission of the commit control message according to claim 3 as a reference for requesting transmission to the means for collectively transmitting the commit control messages, A distributed transaction processing system characterized by being dynamically changed. 9. When a certain period of time has elapsed since the first commit control message was stored in the means for storing the commit control message in the means for concurrently processing transactions of the individual computers according to claim 3, A distributed transaction processing system comprising: means for requesting transmission of the stored commit control message to means for collectively transmitting the commit control message. 10. A transaction which operates in a distributed system in which a plurality of computers having communication control means are connected by a communication network, branches into a distributed transaction input by a user or an application program, and is processed by the plurality of computers. Is a distributed transaction processing system which has a means for processing multiple transactions in parallel by each computer, wherein the means for processing the transactions of two computers in parallel includes a plurality of commit control messages as a single message. A distributed transaction processing system characterized by transmitting and receiving as a batch.