WO2019195969A1

WO2019195969A1 - Data synchronization processing method and apparatus

Info

Publication number: WO2019195969A1
Application number: PCT/CN2018/082225
Authority: WO
Inventors: 王成; 陈旭升; 崔鹤鸣; 沈伟锋; 白龙; 毕舒展; 刘祖齐
Original assignee: 华为技术有限公司
Priority date: 2018-04-08
Filing date: 2018-04-08
Publication date: 2019-10-17
Also published as: CN110622478A; CN110622478B

Abstract

Provided are a data synchronization processing method and apparatus, which are applied to a master node in a computer system, wherein the computer system further comprises a standby node connected to the master node. The method comprises: acquiring, by means of a first thread, first information to be processed, wherein the first information is a first data packet or first indication information, the first indication information is used to indicate the first data packet, and the first thread is a thread for executing a non-thread security code; writing, by means of the first thread, the first information to be processed in a buffer module; executing, by means of a second thread, consistency negotiation processing on the first information to be processed, wherein the consistency negotiation processing is used to synchronize the orders in which the master node and the standby node process the first data packet; and processing the first packet by means of the first thread according to a result of the consistency negotiation processing. By means of the method and the apparatus, a master node processes other tasks by means of a master virtual machine while carrying out synchronization processing on the master virtual machine and a standby virtual machine, thereby improving the performance of the master node.

Description

Method and device for data synchronization processing

Technical field

The present application relates to the field of computers, and in particular, to a method and apparatus for data synchronization processing.

Background technique

Virtualization is part of a compute node (hereafter referred to as a "node") that provides an isolated virtualized computing environment. A typical example of virtualization is a virtual machine (VM). A virtual machine is a virtual device that is simulated on a physical device by virtual machine software. For applications running in virtual machines, these virtual machines work just like real physical devices, which can have operating systems and applications installed on them, and virtual machines can access network resources.

To improve the reliability of the virtual machine processing service, you can configure the same database (that is, the distributed database) on the active and standby VMs to ensure that the active and standby VMs can handle the same service. The virtual machine automatically takes over the business. The working status of the active and standby VMs is usually not the same. Therefore, the standby VM needs a certain amount of time to synchronize the working status of the active and standby VMs before taking over the services. The smaller the amount of data that the active and standby VMs need to synchronize, the smaller. The shorter the time it takes for the virtual machine to take over the business.

In the prior art, the node where the primary virtual machine is located (that is, the primary node) performs synchronization processing of the active and standby virtual machines based on the consistency negotiation protocol. For example, the active and standby virtual machines process data packets in the same order, periodically or irregularly. Synchronize the status of the active and standby VMs, thus reducing the difference in the working status of the active and standby VMs.

However, the thread of the master node (for example, the main loop thread) needs to occupy the global mutex when performing the synchronization processing of the master and slave VMs. The global mutex lock prohibits other threads from accessing the code corresponding to the master virtual machine, resulting in the master virtual machine. Other tasks cannot be processed while the main thread is synchronizing, resulting in a significant drop in the performance of the primary virtual machine.

Summary of the invention

The present application provides a method and apparatus for data synchronization processing, which enables a master node to use a primary virtual machine to process other tasks while performing synchronization processing of the primary and secondary virtual machines, thereby improving performance of the primary node.

In a first aspect, a data synchronization processing method is provided, which is applied to a simulator of a master node in a computer system, the simulator is used to simulate a hardware device of a first virtual device of a master node, and the computer system further includes a connection with the master node. The standby node, the method includes: acquiring, by the first thread of the simulator, the first to-be-processed information, where the first to-be-processed information is the first data packet or the first indication information, where the first indication information is used to indicate the first data packet, The first thread is a thread that executes the non-thread-safe code; the first to-be-processed information is written into the buffer module by the first thread; and the second pending thread of the simulator performs the consistency negotiation process on the first to-be-processed information, the consistency The sex negotiation process is used to synchronize the order in which the primary node and the standby node process the first data packet; the first data packet is processed by the first thread according to the result of the consistency negotiation process.

The master node can mobilize the first thread and the second thread to execute the code to complete the corresponding task. The first thread is a thread that executes the non-thread-safe code. Therefore, the first thread needs to occupy the mutex when performing the operation. For example, the first thread needs to occupy the global mutex before acquiring the first to-be-processed information. The manner in which the first thread acquires the first to-be-processed information is not limited. After the first thread obtains the first to-be-processed information, the first to-be-processed information is written into the buffer module, where the buffer module may be a buffer queue or a heap or stack for buffering the first to-be-processed information. It may also be another data structure for buffering the first to-be-processed information, which is not limited in this application. After the first thread writes the first pending information to the buffer module, the global mutex can be released, and other threads can occupy the global mutex and schedule the virtual machine to perform other tasks. The second thread reads at least one to-be-processed information in the buffer module, and determines a common order in which the primary and secondary nodes process the data packets based on the consistency negotiation protocol, and then the first thread occupies the global mutex and processes according to the second thread. Process packets in sequence. Because the consistency negotiation between the active and standby nodes is performed by the second thread, the second thread does not need to occupy the global mutex when working. Therefore, the master node can use the primary virtual machine to process the synchronous processing of the active and standby virtual machines. Other tasks improve the performance of the primary node.

Optionally, performing a consistency negotiation process on the first to-be-processed information by the second thread of the simulator, including: reading, by the second thread, the first to-be-processed information from the buffering module; The information execution consistency negotiation process determines the processed order of the first data packet; writes the first pending processing information to the pipeline through the second thread according to the processed order of the first data packet, where the pipeline is used for reading by the first thread A pending message.

The first data packet may be a data packet obtained from the client, or may be a data packet generated by the master node, or may be other data packets. The specific content of the first data packet is not limited in this application. Since some program code of the master node is non-thread-safe, the second thread can not directly call the program code of the master node as a worker thread. The consistency negotiation processing scheme provided in this embodiment is in the first thread and the second thread. A pipeline is established for the connection, and the second thread writes the result of the consistency negotiation to the pipeline, so that the first thread reads the result of the consistency negotiation through the pipeline, thereby avoiding the master node while completing the consistency negotiation. The impact of security.

Optionally, the reading, by the second thread, the first to-be-processed information from the buffer module includes: reading the first to-be-processed information buffer module from the buffer module by using the second thread at a preset time.

In this embodiment, the preset time is, for example, a time corresponding to the timer event, and the second thread may read the first to-be-processed information from the buffer module based on the trigger of the timer event, and the master node may set different timer events. Therefore, the foregoing embodiment can flexibly trigger the second thread to perform the consistency negotiation process.

Optionally, before the first to-be-processed information is read from the buffer module by using the second thread, the method further includes: obtaining, by the second thread, the exclusive permission of the buffer module, where the exclusive permission of the buffer module is used to prohibit two or two More than one thread accesses the buffer module at the same time; after performing the consistency negotiation process on the first to-be-processed information by the second thread, the method further includes: when the number of pieces of information to be processed in the buffer module is 0, releasing the The exclusive permission of the buffer module obtained by the second thread.

When the second thread starts working, it first occupies the exclusive permission of the buffer module. The exclusive permission may also be called a queue mutual exclusion lock, which is used to prohibit two or more threads from accessing the buffer module at the same time. When the number of pending information in the buffer module is 0, the second thread releases the queue mutex, and other threads can continue to write new pending information to the buffer module. The foregoing embodiment can prevent the new pending information from being inserted into the to-be-processed information queue that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

Optionally, performing the consistency negotiation process on the first to-be-processed information by using the second thread, including: determining, by the second thread, the quantity of information to be processed in the buffer module; and when the quantity of the to-be-processed information in the buffer module is greater than 0, The second thread writes the data packet (including the first data packet) corresponding to the to-be-processed information into the consistency log and deletes the to-be-processed information in the buffer module, and the consistency log is used to cache the data packet, and the data packet in the consistency log The sequence corresponds to the processed order of the data packets in the consistency log; the second thread sends a consistency negotiation request including the first data packet, and the consistency negotiation request is used to request the standby node to accept the first data packet. Processing sequence; receiving, by the second thread, a negotiation completion message, the negotiation completion message is used to indicate that the processed sequence of the first data packet has been accepted.

After the second thread reads the to-be-processed information, the consistency negotiation process is performed, and then the to-be-processed information in the buffer module is deleted, so that the indication information in the buffer module read by the second thread each time is new pending information. The second thread is prevented from reading the processed information to be processed, thereby improving the efficiency of the consistency negotiation process.

Optionally, before the first to-be-processed information is written to the buffer module by the first thread, the method further includes: obtaining, by the first thread, exclusive rights of the buffer module, where the exclusive permission of the buffer module is used to prohibit two or two The above-mentioned thread accesses the buffer module at the same time; after the first thread writes the first to-be-processed information to the buffer module, the method further includes: releasing, by the first thread, the exclusive permission of the buffer module acquired by the first thread.

Before the first thread writes to the buffer module, it first occupies the exclusive permission of the buffer module. The exclusive permission may also be called a queue mutual exclusion lock, which is used to prohibit two or more threads from accessing the buffer module at the same time. When the first thread write buffer module completes releasing the queue mutex lock, the second thread can occupy the queue mutex lock and read the pending information in the buffer module. The foregoing embodiment can prevent the new pending information from being inserted into the queue of the information to be processed that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

Optionally, the first virtual device runs a primary database, the standby node is configured with a second virtual device, and the second virtual device runs a standby database, where the first data packet carries the client for sending to the primary node for the primary database. Access request,

Obtaining the first to-be-processed information by using the first thread of the simulator, including: acquiring, by the first thread, the first to-be-processed information from the physical network card of the primary node;

Processing, by the first thread, the first data packet according to the result of the consistency negotiation process, including: sending, by the first thread, the first data packet to the primary database and the standby database simultaneously, so that the primary node and the standby node processing are processed in the same order The first packet.

Optionally, the method further includes:

The third thread of the simulator obtains the load threshold of the master node and the same dirty page ratio of the master node and the standby node in the n-time synchronization operation, and the load threshold of the master node in the n-time synchronization operation is c ₁ , . . . , c _n , same dirty pages proportion to the n-th primary node and the standby node when the synchronization is w _1, ..., w _n, where, c ₁ corresponding to w _1, ..., c _n and W _n corresponds, n is greater than or equal to 2, Positive integer

Determining, by the third thread, w _m , w _{m is} the load threshold of the current time after the n times of synchronization operations, w _m =[(c ₁ ×w ₁ )+...+(c _n ×w _n )]÷n , m is a positive integer;

Obtain L _m through the third thread, and L _m is the load value of the primary node at the current time;

If L _m ≤ w _m , generating a synchronization request by the third thread, the synchronization request is used to request synchronization of dirty pages of the primary node and the standby node;

Writing the synchronization request to the buffer module through the third thread;

Performing a consistency negotiation process on the synchronization request by the second thread, and performing a consistency negotiation process on the synchronization request is used to synchronize the order in which the primary node and the standby node process the synchronization request;

The synchronization request is processed by the first thread according to the result of performing the consistency negotiation process on the synchronization request.

In the prior art, the master node determines whether to synchronize the synchronization between the active and standby nodes according to the current load value and the fixed load threshold. If the current load value is less than the fixed load threshold, the synchronization between the active and standby nodes is not started. When the load value at the current time is greater than or equal to the fixed load threshold, the synchronization of the active and standby nodes is started. The above prior art has the disadvantage that it is difficult to determine the optimal starting timing for synchronizing the active and standby nodes according to a fixed load threshold, because if the fixed load threshold is set too small, for example, the fixed load threshold is set to 0, although When the load value of the master node meets the condition, the ratio of the same dirty pages of the active and standby nodes is the highest (because the virtual machines of the active and standby nodes are no longer working, the dirty pages are no longer changed), but the virtual machines of the primary and secondary nodes are loaded. The virtual machine resources of the active and standby nodes are wasted when the time between the detection and the data synchronization is idle. If the fixed load threshold is set too large, the virtual machines of the active and standby nodes are still working when the data is synchronized. The virtual machine of the active and standby nodes has a small proportion of the same dirty pages. As a result, the active and standby nodes need to transmit more data (that is, data corresponding to different dirty pages), which results in more data synchronization between the active and standby nodes. Internet resources.

The following is an example to illustrate how the technical solution provided by the present application solves the above problems. For example, in the first load detection, the processor working time of the master node is 10 minutes, the virtual machine of the active and standby nodes has the same dirty page ratio of 80%, and the processor life of the master node of the second load detection is 20 minutes. The virtual machine of the active and standby nodes has the same dirty page ratio of 85%. When the load is detected for the third time, the processor working time of the primary node is 20 minutes, and the virtual machine of the active and standby nodes has the same dirty page ratio of 85%. The above data indicates that the virtual machine of the primary node has stopped working at least during the second load detection. It is possible that the virtual machine of the primary node has stopped working before the second load detection, and starts after the second load detection. Data synchronization will inevitably cause the virtual machine of the primary node to be idle, and the virtual machine resources will be wasted. Therefore, the preferred data synchronization timing is after the first load detection and before the second load detection, when the data synchronization starts, the primary node The virtual machine has completed most of the work or all of its work, which can achieve a better balance between virtual machine resource utilization and the same dirty page ratio.

According to the embodiment provided by the present application, the load threshold is determined according to the load threshold of the primary node and the same dirty page ratio at least two synchronization operations, for example, the same dirty page ratio 80% obtained at the first load detection is used as the weight value. Multiply the load threshold value 5 to obtain the result 4, and the same dirty page ratio 85% obtained at the second load detection is multiplied by the load threshold value 6 to obtain the result 5.1, and the sum of 4 and 5.1 is divided by the load detection number 2 to obtain The weighted average of the load thresholds for the two load tests is 4.55, which is the new load threshold. If the processor working time obtained by the third load detection is 22 minutes, the load value of the master node in the third load detection is 2 (the working time 22 obtained by the third load detection minus the second load detection). The working time 20 obtains the load value of the master node when the load is detected for the third time. 2), the load value is less than the new load threshold of 4.55, indicating that the remaining tasks of the virtual machine of the master node are not much, and the virtual machine of the master node is soon Will enter the idle state, then start the data synchronization operation; if the processor working time of the third load detection is 30, the load value of the master node is 10 when the load is detected for the third time (the work of the third load detection) Time 30 minus the working time 20 obtained by the second load detection to obtain the load value of the master node in the third load detection 2), the load value is greater than the new load threshold 4.55, indicating that the remaining tasks of the virtual machine of the master node are still There are many. If the proportion of the same dirty page of the active and standby nodes is small, the data synchronization operation will not be performed at the current time. After the fourth load detection, the negative according to the determination of the fourth load detection. The new load value threshold of 4.55 is determined whether the magnitude relationship data synchronization operations.

In addition, since the new load threshold in this embodiment is a weighted average determined according to the result of the multiple load measurement, the load threshold will gradually converge to a more preferable load threshold as the number of load detections increases.

In summary, in the data synchronization method provided by the embodiment, the load threshold is a dynamic and preferable threshold, and the virtual machine resource utilization ratio and the same dirty page ratio of the active and standby nodes are better when data synchronization is performed. The balance point.

Optionally, before the third thread obtains the load threshold of the primary node and the same dirty page ratio of the primary node and the standby node, the method further includes:

Obtaining SUM _k through the third thread, SUM _{k is the sum} of the load value obtained from the first load measurement of the primary node to the load value obtained by measuring the kth load, and k is a positive integer;

When k≥T _count , c _{0 is} determined by the third thread, T _count is the load measurement threshold, and c ₀ is the load threshold of the first synchronization operation of the master node, c ₀ =SUM _k ÷k;

When k<T _count , the third thread obtains L _k+1 , L _k+1 is the load value of the primary node obtained by the k+1th load measurement, and T _count is the load measurement number threshold; SUM _k+1 , SUM _k+1 =SUM _k +L _k+1 ; When k+1≥T _count , the third thread determines c ₀ , c ₀ as the load threshold of the first synchronization operation of the master node, c ₀ = SUM _k+1 ÷(k+1).

For example, after the virtual machine of the primary node is started, the number of measurements (COUNT) of the load is equal to 0. After the first load measurement, the first load value L _{1 is obtained} , then SUM ₁ is equal to L ₁ , and after the second load measurement, a second load value L _2, the _{_{_{SUM 2 = SUM 1 + L 2}}} , i.e., SUM ₁ and SUM ₂ positive correlation, and SUM ₂ L ₂ with a positive correlation. If the measurement number threshold T _count is 2, the initial load threshold c ₀ is equal to SUM ₂ divided by 2, that is, the initial load threshold is positively correlated with SUM ₂ , and the initial load threshold is negatively correlated with the number of measurements; if the measurement number threshold T _count is 3. Since only two load measurements have been performed so far, it is necessary to perform another load measurement, that is, to determine the third load value L ₃ , and then calculate SUM ₃ , SUM ₃ =SUM ₂ +L ₃ , ie, SUM3 and SUM ₂ is positively correlated, and SUM ₃ is positively correlated with L ₃ , the initial load threshold c ₀ is equal to SUM ₃ divided by 3, ie, the initial load threshold is positively correlated with SUM ₃ and the initial load threshold is inversely correlated with the number of measurements.

The above embodiment can determine an initial load threshold so that the timing at which the primary node synchronizes data for the first time can be determined.

Optionally, the load value of the primary node includes a processor load value and a memory load value, and the load threshold of the primary node includes a processor load threshold and a memory load threshold.

In this embodiment, the relationship between the processor load value and the processor load threshold may be compared first, and then the relationship between the memory load value and the memory load threshold may be compared, or the relationship between the memory load value and the memory load threshold may be compared first. Then compare the relationship between the processor load value and the processor load threshold, so that the timing of data synchronization between the active and standby nodes can be flexibly determined.

In a second aspect, a data synchronization processing apparatus is provided, which is applied to a simulator of a master node in a computer system, the simulator is used to simulate a hardware device of a first virtual device of a master node, and the computer system further includes a connection with the master node. Standby node, the device includes:

a first thread control unit, configured to acquire first to-be-processed information, where the first to-be-processed information is the first data packet or the first indication information, where the first indication information is used to indicate the first data packet, where the first thread control unit For executing a non-thread-safe code; and writing the first pending information to the buffer module;

a second thread control unit, configured to perform a consistency negotiation process on the first to-be-processed information, where the consistency negotiation process is used to synchronize the order in which the primary node and the standby node process the first data packet;

The first thread control unit is further configured to process the first data packet according to a result of the second thread control unit performing the consistency negotiation process.

The data synchronization processing device can execute the code by the first thread control unit and the second thread control unit to complete the corresponding task. The first thread control unit is configured to execute the non-thread-safe code. Therefore, the first thread control unit needs to occupy the mutex when performing the operation. For example, the first thread control unit needs to occupy the global mutual exclusion before acquiring the first to-be-processed information. The method for obtaining the first to-be-processed information by the first thread control unit is not limited in this application. After acquiring the first to-be-processed information, the first thread control unit writes the first to-be-processed information to the buffer module, where the buffer module may be a buffer queue, or may be a heap or a stack for buffering the first to-be-processed information. (stack), which may be other data structures for buffering the first to-be-processed information, which is not limited in this application. After the first thread control unit writes the first pending information to the buffer module, the global mutex can be released, and other threads can occupy the global mutex and schedule the virtual machine to perform other tasks. The second thread control unit reads at least one to-be-processed information in the buffer module, and determines a common order in which the active and standby nodes process the data packets based on the consistency negotiation protocol, and then the first thread control unit occupies the global mutual exclusion lock and follows the second The processing sequence determined by the thread control unit processes the data packet. Since the work of the consistency negotiation between the active and standby nodes is performed by the second thread control unit, the second thread control unit does not need to occupy the global mutex when working. Therefore, the data synchronization processing device may be the master node performing the active and standby virtual When the machine is synchronized, the main virtual machine is used to process other tasks, which improves the performance of the master node.

Optionally, the second thread control unit is specifically configured to:

Reading the first to-be-processed information from the buffer module;

Performing a consistency negotiation process on the first to-be-processed information to determine a processed order of the first data packet;

The first to-be-processed information is written to the pipeline according to the processed order of the first data packet, and the pipeline is used by the first thread control unit to read the first to-be-processed information.

The first data packet may be a data packet obtained from the client, or may be a data packet generated by the master node, or may be other data packets. The specific content of the first data packet is not limited in this application. Since some program code of the master node is non-thread-safe, the second thread control unit can not directly call the program code of the master node as a worker thread. The consistency negotiation processing scheme provided in this embodiment is in the first thread control unit and A pipeline for establishing a relationship is established between the second thread control units, and the second thread control unit writes the result of the consistency negotiation to the pipeline, so that the first thread control unit reads the result of the consistency negotiation through the pipeline, so that Consistency negotiation is completed while avoiding the impact on the security of the primary node.

Optionally, the second thread control unit is further configured to: read the first to-be-processed information from the buffer module at a preset time.

In this embodiment, the preset time is, for example, a time corresponding to the timer event, and the second thread control unit may read the first to-be-processed information from the buffer module based on the trigger of the timer event, and the master node may set different timers. The event, therefore, the above embodiment can flexibly trigger the second thread control unit to perform the consistency negotiation process.

Optionally, before the first to-be-processed information is read from the buffer module, the second thread control unit is further configured to: obtain exclusive rights of the buffer module, and the exclusive permission of the buffer module is used to prohibit two or more threads. Accessing the buffer module at the same time;

After performing the consistency negotiation process on the first to-be-processed information, the second thread control unit is further configured to: when the number of pieces of information to be processed in the buffer module is 0, release the exclusive permission of the buffer module acquired by the second thread.

When the second thread control unit starts to work, it first occupies the exclusive right of the buffer module, which may also be called a queue mutex lock, for prohibiting two or more thread control units from accessing the buffer module at the same time. When the number of pieces of information to be processed in the buffer module is 0, the second thread control unit releases the queue mutex, and other threads may continue to write new pending information to the buffer module. The foregoing embodiment can prevent the new pending information from being inserted into the to-be-processed information queue that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

Optionally, the second thread control unit is further configured to:

Determining the amount of information to be processed in the buffer module;

When the number of the to-be-processed information is greater than 0, the data packet corresponding to the to-be-processed information is written into the consistency log, and the to-be-processed information is deleted. The consistency log is used to cache the data packet corresponding to the to-be-processed information, and the data in the consistency log. The sequence of the packets corresponds to the processed sequence of the data packets in the consistency log, the information to be processed includes the first to-be-processed information, and the data packet corresponding to the to-be-processed information includes the first data packet.

Sending a consistency negotiation request including the first data packet, where the consistency negotiation request is used to request the standby node to accept the processed sequence of the first data packet;

A negotiation completion message is received, the negotiation completion message is used to indicate that the processed sequence of the first data packet has been accepted.

After the second thread control unit reads the to-be-processed information, the consistency negotiation process is performed, and then the to-be-processed information in the buffer module is deleted, so that the indication information in the buffer module read by the second thread control unit is new. The information to be processed prevents the second thread control unit from reading the processed information to be processed, thereby improving the efficiency of the consistency negotiation process.

Optionally, before the first to-be-processed information is written to the buffer module, the first thread control unit is further configured to: obtain exclusive rights of the buffer module, and the exclusive permission of the buffer module is used to prohibit two or more threads from being in the same Access the buffer module at any time;

After the first to-be-processed information is written to the buffer module, the first thread control unit is further configured to: release the exclusive permission of the buffer module acquired by the first thread control unit.

The first thread control unit first occupies the exclusive permission of the buffer module before writing to the buffer module, and the exclusive authority may also be referred to as a queue mutex lock, for prohibiting two or more thread control units from accessing the buffer at the same time. Module. When the first thread control unit writes the buffer module to complete the release of the queue mutex lock, the second thread control unit can occupy the queue mutex lock and read the pending information in the buffer module. The foregoing embodiment can prevent the new pending information from being inserted into the queue of the information to be processed that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

The first thread control unit is further configured to: obtain first to-be-processed information from the physical network card of the primary node; send the first data packet to the primary database and the standby database simultaneously, so that the primary node and the standby node process the same in the same order. A packet of data.

Optionally, the device further includes a third thread control unit, and the third thread control unit is configured to:

Obtaining the load threshold of the master node and the same dirty page ratio of the master node and the standby node when n times of synchronization operations, and the load threshold of the master node when n times of synchronization operations are c ₁ ,..., c _n , the master node of the n synchronization operations dirty pages same proportion standby node is w _1, ..., w _n, where, c ₁ and w ₁ corresponds, ..., c _n and w _n corresponding to, n is a positive integer equal to or greater than 2;

Determining w _m , w _m is the load threshold at the current time after n synchronization operations, w _m =[(c ₁ ×w ₁ )+...+(c _n ×w _n )]÷n, m is a positive integer ;

Obtain L _m , L _m is the load value of the primary node at the current time;

If L _m ≤ w _m , a synchronization request is generated, the synchronization request is used to request synchronization of dirty pages of the primary node and the standby node;

Writing a synchronization request to the buffer module;

The second thread control unit is also specifically used to:

Performing a consistency negotiation process on the synchronization request, and performing a consistency negotiation process on the synchronization request to synchronize the order in which the primary node and the standby node process the synchronization request;

The first thread control unit is also specifically used to:

The synchronization request is processed according to the result of performing the consistency negotiation process on the synchronization request.

The load threshold used by the device for data synchronization provided in this embodiment is a dynamic and more preferable threshold, and the virtual machine resource utilization ratio and the same dirty page ratio of the active and standby nodes can reach a better balance point when data synchronization is performed. .

Optionally, before acquiring the load threshold of the primary node and the same dirty page ratio of the primary node and the standby node, the third thread control unit is further configured to:

Obtaining SUM _k , SUM _{k is the sum} of the load value obtained from the first load measurement of the master node to the load value obtained by measuring the kth load, and k is a positive integer;

When k≥T _count , it is determined that c ₀ , T _count is the load measurement threshold, and c ₀ is the load threshold of the first synchronization operation of the master node, c ₀ =SUM _k ÷k;

When k<T _count , obtain L _k+1 , L _k+1 is the load value of the primary node obtained by the k+1th load measurement, and T _count is the threshold of the load measurement times; obtain SUM _k+1 , SUM _{k+ 1} =SUM _k +L _k+1 ; When k+1≥T _count , it is determined that c ₀ ,c ₀ is the load threshold of the first synchronization operation of the master node, c ₀ =SUM _k+1 ÷(k+1).

In a third aspect, there is provided a data synchronization processing apparatus having the functionality of an execution device implementing the method of the first aspect, comprising means for performing the steps or functions described in the above method aspects (means ). The steps or functions may be implemented by software, or by hardware (such as a circuit), or by a combination of hardware and software.

In one possible design, the above apparatus includes one or more processing units and one or more communication units. The one or more processing units are configured to support the apparatus to implement a corresponding function of the execution device of the above method, for example, acquiring the first pending information by the first thread. The one or more communication units are configured to support the device to communicate with other devices to implement receiving and/or transmitting functions. For example, the first packet is obtained from the client.

Optionally, the above apparatus may further comprise one or more memories for coupling with the processor, which store program instructions and/or data necessary for the device. The one or more memories may be integrated with the processor or may be separate from the processor. This application is not limited.

The device can be a chip. The communication unit may be an input/output circuit or an interface of the chip.

In another possible design, the above apparatus includes a transceiver, a processor, and a memory. The processor is for controlling a transceiver or an input/output circuit for transmitting and receiving signals, the memory for storing a computer program for executing a computer program in the memory, such that the device performs either of the first aspect or the first aspect Possible methods in the implementation.

In a fourth aspect, a computer system is provided, the computer system comprising the primary node and the standby node according to the first aspect, wherein the primary node is configured to perform the first aspect or any of the possible implementations of the first aspect Methods.

A fifth aspect, a computer readable storage medium for storing a computer program, the computer program comprising instructions for performing the method of the first aspect or any of the possible implementations of the first aspect.

In a sixth aspect, a computer program product is provided, the computer program product comprising: computer program code, when the computer program code is run on a computer, causing the computer to perform any of the first aspect or the first aspect described above Possible methods in the implementation.

DRAWINGS

Figure 1 is a schematic illustration of a computer system suitable for use with the present application;

2 is a schematic diagram of virtual machine state replication suitable for use in the present application;

3 is a schematic diagram of a data synchronization processing method provided by the present application;

4 is a schematic diagram of data synchronization between a primary and secondary virtual machine provided by the present application;

FIG. 5 is a schematic diagram of a method for determining a timing of data synchronization between a primary and a secondary virtual machine according to the present application; FIG.

6 is a schematic diagram of a method for determining an initial load threshold provided by the present application;

7 is a schematic diagram of another data synchronization processing method provided by the present application;

8 is a schematic diagram of a consistency negotiation method provided by the present application;

9 is a schematic diagram of still another data synchronization processing method provided by the present application;

FIG. 10 is a schematic diagram of still another data synchronization processing method provided by the present application; FIG.

11 is a schematic structural diagram of a data synchronization processing apparatus provided by the present application;

FIG. 12 is another schematic structural diagram of a master node provided by the present application.

detailed description

The technical solutions in the present application will be described below with reference to the accompanying drawings.

Figure 1 shows a schematic diagram of a computer system suitable for use in the present application.

As shown in FIG. 1, the computer system 100 includes a host 1 and a host 2. The host 1 includes a hardware platform and a host operating system installed on the hardware platform. The host 1 further includes a virtual machine running on the host operating system. 1 and a quick emulator (Qemu) 1, in which a database 1 is running on the virtual machine 1. .

Qemu emulation hardware devices are provided for use by virtual machines. In addition, Qemu can monitor the workload of virtual machines running on Qemu. The workload of virtual machines includes the occupancy of virtual machines for central processing units (CPUs) and virtual machine disk usage. , where the central processor and disk are set in the hardware platform.

The host 2 includes a hardware platform and a host operating system installed on the hardware platform. The host 2 further includes a virtual machine 2 and a Qemu 2 running on the host operating system, wherein the virtual machine 2 runs a database 2.

In the embodiment of the present invention, the database 1 is the primary database, and the database 2 is the standby database. When the database 1 cannot be used, the database 2 can be referred to as the primary database instead of the database 1 for the client to access.

The virtual machine 1 and the virtual machine 3 can be mutually active virtual machines. Correspondingly, the host 1 and the host 2 are mutually active and standby nodes. Host 1 and host 2 can communicate with each other through a network interface card (NIC) and can communicate with the client separately.

If host 1 is the master node and host 2 is the standby node, when the client sends four data packets to host 1 in the order of 1234, virtual machine 1 can process the four data packets in the order of 1234, and the master node 1 The order of the processing of the four data packets by the virtual machine 3 is determined by the consistency negotiation module of the Qemu1 and the Qemu3 consistency negotiation module in the host 2 to be 1234, so that the virtual machine 1 and the virtual machine 3 process the four data packets. The order is the same, so the primary node and the standby node have only a small amount of memory and dirty pages, and only need to transfer less data when synchronizing.

For example, the consistency negotiation module can implement the consistency negotiation of the data packet processing order by using the paxos algorithm. When the paxos algorithm is used, the observer node is further introduced in FIG. 1, wherein the observer node may include a consistency negotiation. The module's Qemu is described in more detail below.

The above computer system 100 is merely an example, and the computer system applicable to the present application is not limited thereto. For example, the computer system 100 may further include other hosts. In addition, different hosts can communicate via radio waves or communicate over Ethernet.

FIG. 2 is a schematic diagram of a virtual machine state replication provided by the present application.

As shown in Figure 2, the Paxos negotiation module (that is, the consistency negotiation module) is deployed in the Qemu of the active and standby nodes, and all virtual machines run the same database program in parallel. After the data packets from the client reach the primary node, the primary node The Paxos module negotiates the processing order of each packet received with the Paxos module of other standby nodes, so that all virtual machines process the same data packet in the same order, so that the standby node and the primary node have only a small amount of memory dirty pages. Inconsistent, so that only a small amount of data can be transferred during synchronization to complete the synchronization, which improves the efficiency of synchronization.

In Figure 2, the primary node and the standby node run the same database, and the shaded memory dirty pages (also referred to as "dirty pages") represent dirty pages of virtual machine 2 that differ from virtual machine 1.

It should be understood that the Paxos negotiation module shown in FIG. 2 is merely an example, and other consistency algorithms are also applicable to the present application.

As described in the prior art, the prior art deploying the Paxos negotiation module in Qemu brings huge performance loss to the virtual machine. How the data synchronization processing method provided by the present application solves this problem will be described in detail below.

FIG. 3 shows a flow chart of a data synchronization processing method 300 provided by the present application. The method 300 is applied to a master node in a computer system. Specifically, the method 300 is applied to a Qemu1 of a master node in a computer system. The computer system further includes a standby node connected to the master node, and the method 300 includes:

S310, the first to-be-processed information is obtained by the first thread, where the first to-be-processed information is the first data packet or the first indication information, where the first indication information is used to indicate the first data packet, where the first thread is a non-threading The thread of the security code.

For example, the first indication information may be, for example, indication information including a pointer and a data size, the pointer is used to indicate a storage address of the first data packet, and the first thread may be read by the pointer at the storage address of the first data packet. The data size information is used to obtain the first data packet.

S320. Write, by the first thread, the first to-be-processed information to the buffer module. For example, the buffer module is a buffer queue, and may also be a heap or a stack for buffering the first to-be-processed information, and may also be another data structure for buffering the first to-be-processed information. This application does not limit this.

S330. Perform consistency negotiation processing on the first to-be-processed information by using the second thread, where the consistency negotiation process is used to synchronize the order in which the primary node and the standby node process the first data packet.

S340. The first data packet is processed by the first thread according to the result of the consistency negotiation process.

In the method 300, the master node may mobilize the first thread and the second thread to execute the code to complete the corresponding task. For the sake of introduction, in the present application, the above behavior is sometimes described as “complete the task by the first thread” or “first”. The thread completes the task, for example, "obtaining the first to-be-processed information by the first thread" and "the first thread acquiring the first to-be-processed information" can be understood as the master node scheduling the first thread to execute the code to obtain the first to-be-processed Process information.

The first thread is a thread that executes non-thread-safe code. For example, the first thread is Qemu's main loop thread (Qemu main loop), which executes Qemu's core code, is a dedicated event processing loop thread, and the main loop thread is based on The state change of the file descriptor calls the corresponding handler to handle the event, and the second thread is Qemu's Worker thread.

Since Qemu's core code is non-thread-safe, that is, Qemu does not provide data access protection. It is possible that multiple threads of Qemu change the same data to cause inconsistency. Therefore, the first thread needs to occupy each other when performing operations. A mutex, for example, the main loop thread needs to occupy a global mutex before acquiring the first to-be-processed information, and release the global mutex after writing the first to-be-processed information to the buffer module, thereby ensuring At the same time, only the main loop thread occupying the global mutex can perform the operation of acquiring the first to-be-processed information and writing the first to-be-processed information to the buffer module.

In S310, the first to-be-processed information is any information to be processed obtained by the master node, and the first to-be-processed information may be a data packet, or may be a descriptor for indicating the data packet (ie, indication information). . For example, after receiving the data packet from the client, the master node may directly write the data packet to the buffer module, or may generate a descriptor indicating the data packet, and write the descriptor to the buffer module, where the descriptor is A pointer to the packet can be included, along with information indicating the length and type of the packet.

In addition to the above examples, the first data packet may also be a data packet generated locally by the primary node. The application does not limit the specific content of the first data packet and the method for the primary node to acquire the first data packet.

After the first thread acquires the first to-be-processed information, the first to-be-processed information is written to the buffer module.

After the first thread writes the first pending information to the buffer module, the global mutex can be released, and other threads can try to occupy the global mutex and perform other tasks. The second thread reads at least one to-be-processed information in the buffer module, and determines a common order in which the active and standby nodes process the data packets based on a consistency negotiation protocol (eg, Paxos), and then the first thread occupies the global mutex and follows the second The processing sequence determined by the thread processes the packet. The second thread is, for example, a consensus negotiation thread.

For the specific process of the consistency negotiation, refer to the consistency negotiation method in the prior art. For the sake of introduction, details are not described herein again.

In S340, the first thread may process the first data packet according to the type of the first data packet. For example, when the first data packet is a data packet sent by the client, the first thread may send the first data packet to the primary node. The virtual machine performs processing. When the first data packet is requested by the synchronization module of the primary node to perform the request data packet synchronized by the primary and secondary nodes, the primary node may perform the synchronous operation of the active and standby nodes according to the request data packet.

In the above embodiment, since the work of the consistency negotiation between the active and standby nodes is performed by the second thread, the second thread does not need to occupy the global mutex when performing the consistency negotiation work. Therefore, the master node can perform the active and standby virtual The synchronous operation of the machine utilizes the virtual machine of the primary node to process other tasks, improving the performance of the primary node.

Moreover, since the order in which the primary node and the standby node process the first data packet is the same, the database 1 and the database 2 can be guaranteed to perform the same order of access, thereby minimizing the difference of the dirty pages of the active and standby nodes, and reducing the main The number of dirty pages that need to be transferred when preparing for synchronization.

As an optional embodiment, S330 includes:

S331. The first pending information is read from the buffer module by using the second thread.

S332. Perform a consistency negotiation process on the first to-be-processed information by using the second thread to determine a processed sequence of the first data packet.

S333. Write, by the second thread, the first to-be-processed information to the pipeline according to the processed order of the first data packet, where the pipeline is used by the first thread to read the first to-be-processed information.

Since the core program of Qemu is non-thread-safe, in Qemu, the second thread as a worker thread cannot directly call the program code of the master node. The consistency negotiation processing scheme provided in this embodiment is in the first thread and the second thread. Build a pipe for the connection between the threads, and add the pipe to the event loop list of the Qemu main loop thread. When the second thread has a message to notify the Qemu main loop thread, the second thread executes on the file descriptor. A write operation causes the file descriptor to become readable at the end of the Qemu main loop thread. After the Qemu main loop thread reads the file descriptor, the corresponding program can be called to perform subsequent processing.

For example, after S332 is executed, the master node and the standby node have agreed on the processed sequence of the first data packet. At this time, the direct method is that the second thread executes the virtual network card processing code (RTL8139_do_receiver) to perform the first data packet. The logical operation of the virtual network card, however, the processing code of the RTL8139 virtual network card is a non-linear security code. In order to ensure the security of the data of the primary node, the second thread can write the descriptor of the first data packet into the pipeline, and in the description A write operation is performed to make the file descriptor readable at the end of the Qemu main loop thread. After the Qemu main loop thread reads the descriptor, the virtual network card processing code is called to perform subsequent processing on the first data packet. Therefore, the foregoing embodiment can complete the processing task after the consistency negotiation under the premise of ensuring the thread security of the master node.

As an optional embodiment, S331 includes:

S3311: The first to-be-processed information is read from the buffer module by using the second thread at a preset time.

As an optional embodiment, before S331, the method 300 further includes:

S3301: Obtain exclusive permission of the buffer module by using the second thread, and the exclusive permission of the buffer module is used to prohibit two or more threads from accessing the buffer module at the same time.

After S332, method 300 further includes:

S3321: When the number of pieces of information to be processed in the buffer module is 0, releasing the exclusive permission of the buffer module acquired by the second thread.

For example, when the second thread starts working, first obtain the exclusive permission of the buffer queue, which may also be called a queue mutex, for prohibiting two or more threads from accessing at the same time (including write and / or read) buffer queue. When the number of pending information in the buffer queue is 0, the second thread releases the queue mutex, and other threads can continue to write new pending information to the buffer queue. The foregoing embodiment can prevent the new pending information from being inserted into the to-be-processed information queue that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

As an optional embodiment, S332 includes:

S3321. Determine, by the second thread, the quantity of information to be processed in the buffer module.

S3322, when the quantity of the information to be processed in the buffer module is greater than 0, the data packet corresponding to the to-be-processed information (including the first data packet) is written into the consistency log by the second thread, and the to-be-processed information in the buffer module is deleted. The sex log is used to cache the data packets, and the order of the data packets in the consistency log corresponds to the processing order of the data packets in the consistency log.

S3323: Send, by using the second thread, a consistency negotiation request that includes the first data packet, where the consistency negotiation request is used to request the standby node to accept the processed sequence of the first data packet.

S3324. The negotiation completion message is received by the second thread, where the negotiation completion message is used to indicate that the processed sequence of the first data packet has been accepted.

When a timer event or an I/O event is triggered, the second thread first occupies the queue mutex and then checks to see if the buffer queue is empty. If the buffer queue is empty, the queue mutex is released; if the buffer queue is not empty, the second thread sequentially reads the members in the queue (data packet or packet descriptor), and inserts the packet corresponding to the member into the Paxos protocol. The consistency log, then removes the member from the queue and releases the memory occupied by the original packet. The second thread reads until the queue is empty, and then releases the queue mutex. After the queue mutex is released, the second thread sends the data packets in the consistency log to the standby node in sequence, requesting the standby node to process the data packets in the consistency log according to the sequence, and then, when the second thread receives the data from the standby When the node completes the negotiation message, it is determined that the processed sequence of the data packets in the consistency log has been accepted by the standby node.

In this embodiment, the second thread executes the consistency negotiation process after reading the to-be-processed information, and then deletes the to-be-processed information in the buffer module, so that the indication information in the buffer module that the second thread reads each time can be ensured. It is unprocessed information to be processed, and the second thread is prevented from reading the processed information to be processed, thereby improving the efficiency of the consistency negotiation process.

As an optional embodiment, before S320, the method 300 further includes:

S319: Acquire exclusive permission of the buffer module by using the first thread, and the exclusive permission of the buffer module is used to prohibit two or more threads from accessing the buffer module at the same time.

After S320, method 300 further includes:

S321: Release the exclusive permission of the buffer module acquired by the first thread.

As an optional embodiment, the first virtual device runs a primary database, the standby node is configured with a second virtual device, and the second virtual device runs a standby database, where the first data packet carries the client and sends the data to the primary node. Access requests to the primary database,

S310 includes: acquiring, by the first thread, the first to-be-processed information from the physical network card of the primary node.

S340 includes: transmitting, by the first thread, the first data packet to the primary database and the standby database simultaneously, so that the primary node and the standby node process process the first data packet in the same order.

The first data packet sent by the client reaches the Qemu of the master node through the physical network card of the master node. After the consistency negotiation process of the master node, the first data packet is processed by the master node and the standby node in the same processing order, thereby improving The same dirty page ratio of the active and standby nodes.

As an optional embodiment, the method 300 further includes:

S301. Acquire, by the third thread of the simulator, the load threshold of the primary node and the same dirty page ratio of the primary node and the standby node when the synchronization operation is performed n times, and the load threshold of the primary node during the n synchronization operations is c ₁ ,...,c _n, same dirty pages ratio of the primary node and the standby node when the n-th synchronization operation is w _1, ..., w _n, where, c ₁ and w ₁ corresponds, ..., c _n and W _n corresponds, n is greater than or equal to A positive integer of 2.

S302, determining, by the third thread, w _m , w _{m is} a load threshold of the current time after the n times of synchronization operations, w _m =[(c ₁ ×w ₁ )+...+(c _n ×w _n )] ÷n, m is a positive integer.

S303, obtaining a third thread through L _m, L _m is the time value of the current load of the master node.

S304. If L _m ≤ w _m , generate a synchronization request by the third thread, where the synchronization request is used to request synchronization of dirty pages of the primary node and the standby node.

S305. Write the synchronization request to the buffer module by using a third thread.

S306. Perform a consistency negotiation process on the synchronization request by using the second thread, and perform a consistency negotiation process on the synchronization request to synchronize the order in which the primary node and the standby node process the synchronization request.

S307. The synchronization request is processed by the first thread according to a result of performing a consistency negotiation process on the synchronization request.

In the prior art, the master node determines whether to synchronize the synchronization between the active and standby nodes according to the current load value and the fixed load threshold. If the current load value is less than the fixed load threshold, the synchronization between the active and standby nodes is not started. When the load value at the current time is greater than or equal to the fixed load threshold, the synchronization of the active and standby nodes is started. The above prior art has the disadvantage that it is difficult to determine the optimal starting timing for starting the synchronization of the active and standby nodes according to the fixed load threshold, because if the fixed load threshold is set too small, for example, the fixed load threshold is set to 0, although When the load value of the master node meets the condition, the ratio of the same dirty pages of the active and standby nodes is the highest (because the virtual machines of the active and standby nodes are no longer working, the dirty pages are no longer changed), but the virtual machines of the primary and secondary nodes are loaded. The virtual machine resources of the active and standby nodes are wasted when the time between the detection and the data synchronization is idle. If the fixed load threshold is set too large, the virtual machines of the active and standby nodes are still working when the data is synchronized. The virtual machine of the active and standby nodes has a small proportion of the same dirty pages. As a result, the active and standby nodes need to transmit more data (that is, data corresponding to different dirty pages), which results in more data synchronization between the active and standby nodes. Internet resources.

The following is an example to illustrate how the technical solution provided by the present application solves the above problems. For example, the working time between the primary virtual machine 1 and the first load detection processor is 10 minutes, the virtual machine of the primary and secondary nodes has the same dirty page ratio of 80%, and the primary virtual machine 1 is started to the second time. The processor working time is 20 minutes between load detection, the same dirty page ratio of the virtual machine of the active and standby nodes is 85%, and the processor working time between the primary virtual machine 1 and the third load detection is 20 minutes. The virtual machine of the standby node has the same dirty page ratio of 85%. The above data indicates that the virtual machine 1 of the primary node is already in an idle state at least during the second load detection. It is possible that the virtual machine 1 of the primary node is already in an idle state before the second load detection, and if the second load is detected. After the data synchronization is started, the virtual machine 1 of the primary node is idle for a period of time, and the virtual machine resources are wasted. Therefore, the preferred synchronization time of the primary and secondary nodes is after the first load detection and before the second load detection. During this time period, when the virtual machine 1 of the master node has completed most of the work or all the work, the master-slave synchronization starts, which can obtain a better balance point between the virtual machine resource utilization and the same dirty page ratio.

According to the embodiment provided by the present application, the load threshold is determined according to the load threshold of the primary node and the same dirty page ratio at least two synchronization operations, for example, the same dirty page ratio 80% obtained at the first load detection is used as the weight value. Multiply the load threshold value 5 to obtain the result 4, and the same dirty page ratio 85% obtained at the second load detection is multiplied by the load threshold value 6 to obtain the result 5.1, and the sum of 4 and 5.1 is divided by the load detection number 2 to obtain The weighted average of the load thresholds for the two load tests is 4.55, which is the new load threshold. If the working time of the third load detection processor is 22 minutes, the load value of the master node in the third load detection is 2 (the working time 22 obtained by the third load detection minus the work obtained by the second load detection) Time 20 obtains the load value of the master node during the third load detection 2), and the load value is less than the new load threshold of 4.55, indicating that the remaining tasks of the virtual machine of the primary node are not much, and the virtual machine of the primary node will soon be When the idle state is entered, the data synchronization operation is started; if the processor working time obtained by the third load detection is 30, the load value of the primary node is 10 when the third load is detected (the working time obtained by the third load detection) 30 minus the working time 20 obtained by the second load detection to obtain the load value of the master node in the third load detection 2), the load value is greater than the new load threshold 4.55, indicating that the remaining tasks of the virtual machine of the master node are still Many, if the proportion of the same dirty page of the active and standby nodes is small, the data synchronization operation will not be performed at the current time. After the fourth load detection, the determined load value according to the fourth load detection. The new load threshold is determined whether the magnitude relationship 4.55 data synchronization operations.

In addition, since the new load threshold in this embodiment is a weighted average determined according to the result of the multiple load measurement, the new load threshold will gradually converge to a more preferable load threshold as the number of load detections increases. The third thread is, for example, a worker thread of the active/standby synchronization module in the master node, that is, a thread responsible for synchronization of the active and standby virtual machines.

In summary, in the data synchronization processing method provided by the embodiment, the load threshold is a dynamic and preferable threshold, and the virtual machine resource utilization ratio and the same dirty page ratio of the active and standby nodes are better when data synchronization is performed. The balance point.

As an optional embodiment, before S301, the method 300 further includes:

S3001: Acquire, by the third thread, SUM _k , SUM _{k is the sum} of the load value obtained by the first load measurement of the primary node to the load value obtained by the kth load measurement, and k is a positive integer.

S3002, when k≥T _count , determine c ₀ by the third thread, T _count is the load measurement threshold, and c ₀ is the load threshold of the first synchronization operation of the primary node, and c ₀ =SUM _k ÷k. or,

S3003, when k<T _count , obtain L _k+1 through the third thread, L _k+1 is the load value of the primary node obtained by the k+1th load measurement, and T _count is the threshold of the load measurement times; S3004, The third thread obtains SUM _k+1 , SUM _k+1 =SUM _k +L _k+1 ; S3005, when k+1≥T _count , determines c ₀ , c ₀ as the first synchronization operation of the main node by the third thread. Load threshold, c ₀ =SUM _k+1 ÷(k+1).

In S3001, when k=1, SUM ₁ is equal to the load value obtained by the first load measurement.

As an optional embodiment, the load value of the primary node includes a processor load value and a memory load value, and the load threshold of the primary node includes a processor load threshold and a memory load threshold.

When the processor and memory of the master node are both idle, it can be determined that the master node is idle.

To further explain how the active and standby nodes perform data synchronization, the data synchronization method provided by the present application will be described in detail below with reference to FIGS. 4 to 6.

As shown in Figure 4, the primary virtual machine is a virtual machine running on the primary node, and the standby virtual machine is a virtual machine running on the standby node. The primary and secondary virtual machines are synchronized, that is, the data of the active and standby nodes is synchronized. among them,

T0-T1: The primary virtual machine runs with the standby virtual machine and records a list of dirty pages.

T1-T2: The primary virtual machine and the standby virtual machine stop running, and each computes a hash value of the dirty page.

T2-T3: The primary virtual machine compares the hash value of the dirty page of the standby virtual machine.

T3-T4: The primary virtual machine transfers the different dirty pages to the backup virtual machine.

After the transfer is complete, the primary virtual machine releases the buffered network output (different dirty page data) and resumes operation, and the standby virtual machine resumes operation.

In the foregoing process, T1 is a time for performing synchronization between the active and standby virtual machines. As an optional embodiment, FIG. 5 shows a method flow for triggering synchronization of the active and standby virtual machines.

The method 500 includes:

S510. Record the same dirty page ratio and load threshold when the active and standby virtual machines are synchronized.

The synchronization module of the active and standby virtual machines records the same memory dirty page ratio of the primary virtual machine and the standby virtual machine at each synchronization, and the CPU load threshold and disk (input/output, I/O) load when the primary and backup virtual machines are synchronized. Threshold.

S520: weighting the similar thresholds by using the same dirty page ratio as a weight, and obtaining a load threshold for synchronization of the next active and standby virtual machines.

The corresponding weight is given to the threshold according to the same dirty page ratio. Then multiply the last n load thresholds by their weights, sum the total values, and divide by n to get the load threshold for triggering the synchronization of the active and standby virtual machines next time.

The following takes the CPU as an example. After the synchronization of the jth primary and backup virtual machines is completed, the primary and secondary active and standby synchronization modules of the primary virtual machine are given the CPU threshold according to the same dirty page ratio w _j when the jth primary and secondary virtual machines are synchronized. c _j corresponding weight w _j . Multiply the CPU thresholds of the last n times by the corresponding weights, then sum and get the overall value, and divide by n to get the load value that the CPU needs to achieve when starting the j+1th primary and backup virtual machine synchronization, that is,

The adjustment process of the disk I/O load threshold is the same.

Among them, the initial threshold calculation process is shown in Figure 6:

After the active/standby synchronization module is started, the initial load accumulated value SUM ₀ =0, the initial load value CPU_Tick_A0 is equal to 0, the count value is COUNT=0, and the count value is the number of load measurements performed by the primary virtual machine.

Then, the CPU usage time CPU_Tick_A1 at time A1 is obtained. At this time, SUM ₁ = SUM ₀ + (CPU_Tick_A1 - CPU_Tick_A0), and the CPU usage time CPU_Tick_A2 at time A2 is acquired after waiting for Δt time.

Calculate the load accumulated value SUM2 at time A2 according to SUM _k+1 =SUM _k +L _k+1 , SUM2=SUM1+(CPU_Tick_A2-CPU_Tick_A1), and determine whether COUNT is greater than or equal to the count value of 3. The count value is the number of load measurements. The threshold, if yes, calculates the initial load threshold c ₀ , c ₀ =SUM _k+1 /COUNT, otherwise the load measurement continues until the load measurement count is greater than or equal to the load measurement threshold.

S530: Acquire a current load value, compare the current load value with a set load threshold, and determine whether synchronization is performed.

The active/standby synchronization module obtains the workload of the virtual machine, compares it with the threshold, and starts synchronization. The process is as follows:

1. The master node is responsible for the synchronization of the active and standby virtual machines (that is, the synchronization thread) calls the clock function to obtain the CPU_Tick ₁ time from the startup to the CPU at the first moment.

2. Synchronize thread sleep Δt ₁ . Δt ₁ is a value set in advance by the master node. In order to be able to detect that the virtual machine is idle in a short time and avoid the error caused by the monitoring time being too short, Δt ₁ can be set, for example, to 100 microseconds.

3. The thread that is responsible for the synchronization of the active and standby virtual machines calls the clock function again to get the CPU_Tick ₂ time taken by the virtual machine from the startup to the second time.

4. If CPU_Tick ₁ -CPU_Tick ₁ <c, it means that the CPU is idle, go to step 5, otherwise the synchronous thread sleeps Δt _{1 and} then continue to call the clock function to get the time that the virtual machine takes up the CPU from the startup to the current time, until the current CPU The difference between the occupied time minus the last CPU usage time is less than the CPU load threshold, where c is the CPU load threshold that is required to trigger the active and standby virtual machines to synchronize the CPU.

5. The synchronization thread obtains the time disk_time _{1 of the} virtual machine from the startup to the current disk I/O through the Linux Netlink interface.

6. Synchronize thread sleep Δt ₂ . Δt ₂ is a value set in advance by the master node. Δt _{2 is} determined according to the performance of the physical disk. For example, if the disk I/O operation takes 5 milliseconds, Δt ₂ can be set to 5 milliseconds.

7. Synchronize the thread again to get the disk I/O time of the virtual machine process disk_time ₂ through the Linux Netlink interface.

8. If disk_time ₂ -disk_time ₁ <d, the disk I/O is idle, start the master-slave synchronization, otherwise the synchronization thread sleeps Δt ₂ and continues to get the disk I/O from the boot to the current time through the Linux Netlink interface. Time, until the current disk I/O time minus the previous disk I/O time difference (that is, the current disk I/O load value) is less than the disk I/O load threshold, where d is the trigger master and backup The disk load threshold that the disk needs to reach when the virtual machine synchronizes.

The above process first determines whether the CPU load exceeds the CPU load threshold, and then determines whether the disk I/O load exceeds the disk I/O load threshold. As an optional example, it can also determine whether the disk I/O load exceeds the disk I/O. Load threshold, and then determine whether the CPU load exceeds the CPU load threshold. In addition, if there are other parameters that affect the same dirty page ratio of the active and standby virtual machines, you can also determine whether to synchronize the active and standby virtual machines according to the above method.

When the synchronization is initiated, the master-slave synchronization module generates a special packet descriptor containing a pointer to a null address, which is also used to indicate the length (zero) of the packet and the type of the packet. The synchronization module occupies the mutex of the buffer queue and inserts the packet descriptor into the buffer queue, then releases the queue mutex. During the master/slave synchronization, the primary virtual machine transfers inconsistent dirty pages to the standby virtual machine by comparing the dirty pages of the active and standby virtual machines.

It is to be understood that the various embodiments described above are only partial implementations of the present application. The embodiments included in the data synchronization processing method provided by the present application are not limited thereto. In the following, the present application will be based on the common features described above. The data synchronization processing method provided is further introduced.

FIG. 7 shows another flow chart of the data synchronization processing method provided by the present application.

As shown in FIG. 7, after the data packet from the client enters the master node through the host physical network card, the terminal access point (TAP) string device (/dev/tapX) of the master node becomes readable. When the Qemu main loop thread finds that the TAP string device is readable, it attempts to occupy the global mutex and read out the client packet from the string device. The Qemu main loop thread then generates a descriptor for the packet, the descriptor including a pointer to the packet, and information describing the length of the packet and the type of the packet, wherein the packet type is a client Request.

The primary node occupies the mutex of the buffer queue and populates the packet descriptor into the buffer queue, then releases the queue mutex. The middle-tier module is responsible for the consistency negotiation thread occupying the mutex of the buffer queue, and then checking whether the buffer queue is empty. If the buffer queue is not empty, the members in the queue (ie, descriptors) are read in turn, the packets described by the members are filled into the consistency log of the Paxos protocol, and then the members are deleted from the queue and the original data packets are released. Occupied memory. The thread responsible for the consistency negotiation reads until the queue is empty, and then releases the mutex of the queue. After the queue mutex is released, the thread responsible for the consistency negotiation checks whether there are members waiting to be processed (not negotiated) in the consistency log of the Paxos protocol. If so, the member negotiates with other nodes according to the Paxos algorithm.

The active/standby synchronization module determines the timing of the synchronization between the active and standby virtual machines according to the methods shown in FIG. 5 and FIG. 6. When the active/standby synchronization module determines to trigger the synchronization of the active and standby virtual machines, the primary and secondary synchronization modules generate an active/standby synchronization request, and After the mutex that occupies the buffer queue, the packet is inserted into the buffer queue, and then the queue mutex is released. Both the active and standby synchronization requests and the data from the client must be negotiated in a consistent manner before they can be processed.

The thread responsible for the consistency negotiation is determined by the Paxos algorithm. After the data packet negotiation is completed, the descriptor of the data packet is written to the pipeline, so that the Qemu main loop thread reads the descriptor from the pipeline. After the Qemu main loop thread reads the descriptor from the pipeline, the packet is processed according to the type of the packet indicated by the descriptor. For example, when the packet is a packet from the client, the packet is virtualized. The NIC is sent to the virtual machine for processing.

FIG. 8 is a schematic diagram of a consistency negotiation method provided by the present application.

Since the Paxos algorithm requires at least three nodes, the distributed system shown in FIG. 8 includes an observer node in addition to the primary node and the standby node, so that the requirements of the Paxos algorithm can be satisfied, and the observer node can also be replaced with Standby node. In addition to this, a distributed system suitable for the present application may also include more standby nodes.

The primary and standby virtual machines are in hot standby and run the same distributed database program in parallel. The observer node virtual machine is in a standby state. The Qemu of the three nodes all have a consistency negotiation module, and the client network request and the master-slave synchronization request are negotiated according to the Paxos algorithm. Observer nodes only participate in Paxos negotiation work and do not participate in active/standby synchronization.

On the standby node, the middle layer software module is responsible for the consistency negotiation thread based on the network I/O event triggered by the Paxos algorithm message delivery. When the thread responsible for the consistency negotiation receives the negotiation message sent from other nodes, it processes according to the Paxos algorithm. The thread responsible for the consistency negotiation determines that after the data packet has been consistently negotiated, if the data packet is a client request, the data packet is sent to the virtual machine, and if the data packet is an active/standby synchronization request, it is responsible for consistency negotiation. The thread notifies the active and standby synchronization modules to initiate synchronization.

On the observer node, the thread responsible for consistency negotiation of the middle layer software module is also based on the network I/O event triggered by the Paxos algorithm message delivery. When the thread responsible for the consistency negotiation receives the negotiation message sent from other nodes, it processes according to the Paxos algorithm. Since the observer node virtual machine is in the standby state, after the thread responsible for the consistency negotiation determines that the data packet has completed the consistency negotiation, the data packet that is negotiated is either the client request or the active/standby synchronization request, and is discarded.

FIG. 9 is still another flowchart of the data synchronization processing method provided by the present application.

S1: The master node reads the client data packet.

When the client data packet arrives at the physical network card of the master node, the master node (ie, the host operating system) invokes the driver of the physical network card, in which the software bridge in the Linux kernel is utilized to implement data forwarding. On the software bridge layer, the master node will determine which device the packet is sent to, and at the same time call the bridge's send function to send the packet to the corresponding port number. If the packet is destined for the virtual machine, it is forwarded through the TAP device. The TAP is equivalent to an Ethernet device that operates on Layer 2 packets, the Ethernet data frame. The character device (/dev/tapX) of the TAP device is responsible for forwarding packets in kernel space and user space.

The Qemu main loop thread keeps looping through the "select system call" function to determine which file descriptors have changed state, including the state of the TAP device file descriptor and pipe device file description. When the Qemu main loop thread finds that the TAP string device is readable, it attempts to occupy the global mutex and read out the client packet from the string device. The Qemu main loop then generates a descriptor for the packet, the descriptor containing a pointer to the packet, and information indicating the length of the packet and the type of the packet, where the type of the packet is the client data pack.

S2: The master node initiates the master-slave synchronization to generate a synchronization request packet.

An automatic threshold adjustment algorithm is deployed in the active/standby synchronization module of the primary node Qemu (as shown in S301 to S304). The active/standby synchronization module of the master node monitors the CPU load and disk I/O load of the virtual machine, and compares the load threshold and the virtual machine load to determine whether to initiate synchronization.

The process in which the master node initiates the master-slave synchronization is shown in Figure 4 to Figure 6.

When the master node initiates synchronization, the master-slave synchronization module generates a special packet descriptor containing a pointer to the null address, and also information indicating the length (zero) of the packet and the type of the packet. The type of the packet here is the primary and secondary synchronization request. The synchronization module occupies the mutex of the buffer queue and populates the packet descriptor into the buffer queue, then releases the queue mutex. When the primary virtual machine synchronizes, it compares the dirty pages of the active and standby virtual machines, and only transmits the inconsistent dirty pages to the standby virtual machine.

S3: The master node inserts the packet descriptor into the buffer queue and performs consistency negotiation on the data packet.

The process of inserting the packet descriptor into the buffer queue and performing a consistency negotiation on the packet is shown in FIG.

Figure 10 consists of two parts, one part is the processing flow of the Qemu main loop thread. The processing flow consists of three steps, namely the mutex that holds the buffer queue, fills the packet descriptor into the buffer queue, and then releases the queue mutually exclusive. lock.

The other part is the processing flow of the consistency negotiation thread. The middle-tier thread responsible for consistency negotiation is driven based on events (timer events or network I/O events). For example, when a timer event is triggered, the consistency negotiation thread first occupies the mutex of the buffer queue, and then checks to see if the buffer queue is empty. If the buffer queue is not empty, the consistency negotiation thread reads the members in the queue in turn, inserts the packet described by the member into the consistency log of the Paxos protocol, and then removes the member from the queue and releases the memory occupied by the original packet. The consistency negotiation thread reads until the queue is empty, and then releases the mutex of the queue. After the queue mutex is released, the consistency negotiation thread checks whether there are members waiting to be processed (not negotiated) in the consistency log of the Paxos protocol. If so, the members to be processed negotiate with other nodes according to the Paxos algorithm.

S4: The master node determines the type of the data packet after the negotiation is reached.

The consistency negotiation thread needs to listen for network I/O events that are triggered by the received Paxos algorithm message. When the consistency negotiation thread receives the negotiation message sent by other nodes, it needs to be processed according to the Paxos algorithm. If the consistency negotiation thread determines that a data packet has been consistently negotiated by the Paxos algorithm, the type is determined according to the information contained in the data packet, wherein the consistency negotiation thread is in the original data packet (the data packet before the buffer queue is inserted) When the consistency negotiation is performed, the original data packet is encapsulated, and the encapsulated data packet contains other information in addition to the original data packet, and the other information is, for example, information indicating the original data packet type, and the consistency negotiation thread encapsulates the information. The subsequent packets are sent to the standby node.

S5: The client data packet is forwarded to the Qemu main loop, and the Qemu main loop performs a logical operation of the virtual network card (such as RTL8139) on the client data packet.

If the negotiated packet is a client packet, the consistency negotiation thread first writes the length of the packet in the pipe associated with the Qemu main loop and then writes the packet content.

When the Qemu main loop thread finds that the file descriptor of the pipeline becomes readable, it takes up the global mutex and reads out an integer type of data from the pipeline. This data is the length of the packet sent in the pipeline. . According to the obtained integer, the Qemu main loop thread reads the corresponding length data, that is, the data packet, from the pipeline.

The Qemu main loop thread then calls the RTL8139_do_receiver function, which performs the logical operation equivalent to the hardware RTL8139 NIC in this function. The kernel-based virtual machine (KVM) operates the virtual RTL8139 by analog I/O instructions to copy the packet to the client address space and place it in the corresponding I/O address. After the operation is complete, the Qemu main loop thread releases the global mutex.

S6: The application in the virtual machine processes the client data packet.

If the client data packet is a data query request, the database program in the virtual machine performs the query action after receiving the client data packet, and returns the execution result.

S7: Start virtual machine master-slave synchronization (data packet is synchronization request).

If the negotiated data packet is an active/standby synchronization request, the consistency negotiation thread notifies the active/standby synchronization module to initiate synchronization. The virtual machine is generated to prepare a synchronization data frame, and the data frame is placed in a buffer queue of the primary node for transmission.

The system architecture and the service scenario described in the foregoing embodiments are for the purpose of more clearly illustrating the technical solutions of the present application, and do not constitute a limitation on the technical solutions of the present application. Those skilled in the art may know that with the evolution of the system architecture and new services. The appearance of the scenario, the technical solution provided by the present application is equally applicable to similar technical problems.

It should be noted that, in the embodiment of the present invention, the master-slave synchronization module can be implemented by the third thread of Qemu, and the consistency negotiation layer module can be implemented by the second thread of Qemu, wherein the second thread and the third thread are both Qemu. Worker thread.

The method of data synchronization processing provided by the present application is described in detail above with reference to FIGS. 1 through 10. It can be understood that, in order to implement the above functions, the master node includes corresponding hardware structures and/or software modules for performing various functions. Those skilled in the art will readily appreciate that the present application can be implemented in a combination of hardware or hardware and computer software in combination with the elements and algorithm steps of the various examples described in the embodiments disclosed herein. Whether a function is implemented in hardware or computer software to drive hardware depends on the specific application and design constraints of the solution. A person skilled in the art can use different methods to implement the described functions for each particular application, but such implementation should not be considered to be beyond the scope of the present application.

The present application may divide a functional unit into a master node according to the above method example. For example, each functional unit may be divided according to each function, or two or more functions may be integrated into one processing unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit. It should be noted that the division of the unit in the present application is schematic, and is only a logical function division, and the actual implementation may have another division manner.

FIG. 11 is a schematic structural diagram of a possible data synchronization processing apparatus provided by the present application. The data synchronization processing device 1100 may be a software module or a hardware module included in the master node, and the data synchronization processing device 1100 includes a first thread control unit 1101 and a first thread control unit 1102. The first thread control unit 1101 and the first thread control unit 1102 are used to control and manage the actions of the data synchronization processing device 1100. For example, the first thread control unit 1101 and the first thread control unit 1102 are configured to support the data synchronization processing device 1100. The various steps of Figure 3 and/or other processes for the techniques described herein are performed.

Several embodiments of the data synchronization processing apparatus 1100 are listed below.

The first thread control unit 1101 is configured to acquire the first to-be-processed information, where the first to-be-processed information is the first data packet or the first indication information, where the first indication information is used to indicate the first data packet, where the first thread control The unit 1101 is configured to execute the non-thread-safe code; and write the first to-be-processed information into the buffer module;

The second thread control unit 1102 is configured to perform a consistency negotiation process on the first to-be-processed information, where the consistency negotiation process is used to synchronize the order in which the primary node and the standby node process the first data packet;

The first thread control unit 1101 is further configured to process the first data packet according to the result of the second thread control unit 1102 performing the consistency negotiation process.

The data synchronization processing device 1100 can execute code by the first thread control unit 1101 and the second thread control unit 1102 to complete the corresponding task. The first thread control unit 1101 is configured to execute the non-thread-safe code, and therefore, the first thread control unit 1101 needs to occupy the mutex when performing the operation, for example, the first thread control unit 1101 needs to occupy before acquiring the first to-be-processed information. The global mutex is not limited in this application. The manner in which the first thread control unit 1101 acquires the first to-be-processed information is not limited. After acquiring the first to-be-processed information, the first thread control unit 1101 writes the first to-be-processed information to the buffer module, where the buffer module may be a buffer queue, or may be a heap for buffering the first to-be-processed information or The stack is also a data structure for buffering the first to-be-processed information, which is not limited in this application. After the first thread control unit 1101 writes the first to-be-processed information to the buffer module, the global mutex can be released, and other threads can occupy the global mutex and schedule the virtual machine to perform other tasks. The second thread control unit 1102 reads at least one to-be-processed information in the buffer module, and determines a common order in which the active and standby nodes process the data packets based on the consistency negotiation protocol. Subsequently, the first thread control unit 1101 occupies the global mutex and follows The processing sequence determined by the second thread control unit 1102 processes the data packet. Since the work of the consistency negotiation of the active and standby nodes is performed by the second thread control unit 1102, the second thread control unit 1102 does not need to occupy the global mutex when working, and therefore, the master node configured with the data synchronization processing device 1100 is performing. The synchronization process of the active and standby virtual machines utilizes the primary virtual machine to process other tasks, and has higher performance than the primary nodes in the prior art.

Optionally, the second thread control unit 1102 is specifically configured to:

Reading the first to-be-processed information from the buffer module;

The first to-be-processed information is written to the pipeline according to the processed order of the first data packet, and the pipeline is used by the first thread control unit 1101 to read the first to-be-processed information.

The first data packet may be a data packet obtained from the client, or may be a data packet generated by the master node, or may be other data packets. The specific content of the first data packet is not limited in this application. Since some program code executed by the data synchronization processing device 1100 is not thread-safe, the second thread control unit 1102 cannot directly call the program code of the data synchronization processing device 1100 as a worker thread, and the consistency negotiation process provided in this embodiment The scheme establishes a pipe for contacting between the first thread control unit 1101 and the second thread control unit 1102, and the second thread control unit 1102 writes the result of the consistency negotiation to the pipeline so that the first thread control unit 1101 passes The pipeline reads the result of the consistency negotiation, so that the consistency of the data synchronization processing device 1100 can be avoided while completing the consistency negotiation.

Optionally, the second thread control unit 1102 is further configured to: read the first to-be-processed information from the buffer module at a preset time.

In this embodiment, the preset time is, for example, the time corresponding to the timer event, and the second thread control unit 1102 can read the first to-be-processed information from the buffer module based on the trigger of the timer event, and the master node can set different timings. The event, therefore, the above embodiment can flexibly trigger the second thread control unit 1102 to perform the consistency negotiation process.

Optionally, before the first to-be-processed information is read from the buffer module, the second thread control unit 1102 is further configured to: obtain exclusive rights of the buffer module, and the exclusive permission of the buffer module is used to prohibit two or more The thread accesses the buffer module at the same time;

After performing the consistency negotiation process on the first to-be-processed information, the second thread control unit 1102 is further configured to: when the number of pieces of information to be processed in the buffer module is 0, release the exclusive right of the buffer module acquired by the second thread.

When the second thread control unit 1102 starts to work, it first occupies exclusive rights of the buffer module, which may also be called a queue mutex lock, for prohibiting two or more thread control units from accessing the buffer module at the same time. . When the number of pieces of information to be processed in the buffer module is 0, the second thread control unit 1102 releases the queue mutex, and other threads may continue to write new pending information to the buffer module. The foregoing embodiment can prevent the new pending information from being inserted into the to-be-processed information queue that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

Optionally, the second thread control unit 1102 is further specifically configured to:

Determining the amount of information to be processed in the buffer module;

After the second thread control unit 1102 reads the information to be processed, the consistency negotiation process is executed, and the information to be processed in the buffer module is deleted, so that the instruction information in the buffer module read by the second thread control unit 1102 can be ensured. It is new to-be-processed information, and the second thread control unit 1102 is prevented from reading the processed information to be processed, thereby improving the efficiency of the consistency negotiation process.

Optionally, before the first to-be-processed information is written to the buffer module, the first thread control unit 1101 is further configured to: acquire exclusive rights of the buffer module, where the exclusive permission of the buffer module is used to prohibit two or more threads from being Accessing the buffer module at the same time;

After the first to-be-processed information is written to the buffer module, the first thread control unit 1101 is further configured to: release the exclusive permission of the buffer module acquired by the first thread control unit 1101.

The first thread control unit 1101 first occupies exclusive rights of the buffer module before writing to the buffer module, and the exclusive authority may also be referred to as a queue mutex lock for prohibiting two or more thread control units from accessing at the same time. Buffer module. When the first thread control unit 1101 releases the queue mutex lock after the write buffer module is completed, the second thread control unit 1102 can occupy the queue mutex lock and read the pending information in the buffer module. The foregoing embodiment can prevent the new pending information from being inserted into the queue of the information to be processed that has completed the consistency negotiation process, thereby improving the reliability and efficiency of the consistency negotiation process.

The first thread control unit 1101 is further configured to: obtain first to-be-processed information from the physical network card of the primary node; send the first data packet to the primary database and the standby database simultaneously, so that the primary node and the standby node are processed in the same order. The first packet.

Obtain L _m , L _m is the load value of the primary node at the current time;

Writing a synchronization request to the buffer module;

The second thread control unit 1102 is further specifically configured to:

The first thread control unit 1101 is further specifically configured to:

Obtain SUM _k , SUM _{k is the sum} of the load value obtained from the first load measurement of the master node to the load value obtained from the kth load measurement, and k is a positive integer.

When k≥T _count , it is determined that c ₀ , T _count is the load measurement threshold, and c ₀ is the load threshold of the first synchronization operation of the master node, and c ₀ =SUM _k ÷k. or,

FIG. 12 shows another possible schematic diagram of the master node involved in the present application.

Referring to FIG. 12, the master node 1200 includes a processor 1202, a transceiver 1203, and a memory 1201. The transceiver 1203, the processor 1202, and the memory 1201 can communicate with each other through an internal connection path to transfer control and/or data signals.

The processing unit 1102 can be a processor or a controller, for example, can be a central processing unit (CPU), a general-purpose processor, a digital signal processor (DSP), and an application-specific integrated circuit. , ASIC), field programmable gate array (FPGA) or other programmable logic device, transistor logic device, hardware component, or any combination thereof. It is possible to implement or carry out the various illustrative logical blocks, modules and circuits described in connection with the present disclosure. The processor may also be a combination of computing functions, for example, including one or more microprocessor combinations, a combination of a DSP and a microprocessor, and the like. The communication unit 1103 can be a transceiver, a transceiver circuit, or the like. The storage unit 1101 may be a memory.

A person skilled in the art can clearly understand that for the convenience and brevity of the description, the specific working process of the device and the unit described above can refer to the corresponding process in the foregoing method embodiment, and no further details are provided herein.

The master node 1200 provided by the present application processes the consistency negotiation of the active and standby nodes by using the second thread, and the second thread does not need to occupy the global mutex when working. Therefore, the master node 1200 can utilize the synchronous operation of the active and standby virtual machines. The virtual machine handles other tasks and improves the performance of the primary node.

The master node in the device and the method embodiment corresponds completely, and the corresponding module performs corresponding steps, for example, the communication module method performs the steps of sending or receiving in the method embodiment, and the steps other than sending and receiving may be performed by the processing module or the processor. carried out. For the function of the specific module, reference may be made to the corresponding method embodiment, which is not described in detail.

In the various embodiments of the present application, the size of the sequence number of each process does not mean the order of execution sequence, and the order of execution of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the present application.

It should be noted that, in the embodiment of the present invention, the function of the virtual machine may also be implemented by using a container, where the container and the virtual machine may be referred to as a virtual device.

In addition, the term "and/or" herein is merely an association relationship describing an associated object, indicating that there may be three relationships, for example, A and/or B, which may indicate that A exists separately, and A and B exist at the same time. There are three cases of B alone. In addition, the character "/" in this article generally indicates that the contextual object is an "or" relationship.

The steps of a method or algorithm described in connection with the present disclosure may be implemented in a hardware or may be implemented by a processor executing software instructions. The software instructions may be composed of corresponding software modules, which may be stored in a random access memory (RAM), a flash memory, a read only memory (ROM), an erasable programmable read only memory ( Erasable programmable ROM (EPROM), electrically erasable programmable read only memory (EEPROM), registers, hard disk, removable hard disk, compact disk read only (CD-ROM) or any other form of storage medium known in the art. An exemplary storage medium is coupled to the processor to enable the processor to read information from, and write information to, the storage medium. Of course, the storage medium can also be an integral part of the processor. The processor and the storage medium can be located in an ASIC. Additionally, the ASIC can be located in the master node. Of course, the processor and the storage medium can also exist as discrete components in the master node.

In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, it may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions described in accordance with the present application are generated in whole or in part. The computer can be a general purpose computer, a special purpose computer, a computer network, or other programmable device. The computer instructions can be stored in or transmitted by a computer readable storage medium. The computer instructions may be from a website site, computer, server or data center via a wired (eg, coaxial cable, fiber optic, digital subscriber line (DSL)) or wireless (eg, infrared, wireless, microwave, etc.) Another website site, computer, server, or data center for transmission. The computer readable storage medium can be any available media that can be accessed by a computer or a data storage device such as a server, data center, or the like that includes one or more available media. The usable medium may be a magnetic medium (eg, a floppy disk, a hard disk, a magnetic tape), an optical medium (eg, a digital versatile disc (DVD), or a semiconductor medium (eg, a solid state disk (SSD)). Wait.

The specific embodiments of the present invention have been described in detail with reference to the specific embodiments of the present application. It is to be understood that the foregoing description is only The scope of protection, any modifications, equivalent substitutions, improvements, etc. made on the basis of the technical solutions of the present application are included in the scope of protection of the present application.

Claims

A data synchronization processing method, characterized by being applied to a simulator of a master node in a computer system, the simulator for simulating a hardware device for a first virtual device of the master node, the computer system further comprising The standby node connected to the master node, where the method includes:

Acquiring, by the first thread of the simulator, the first to-be-processed information, where the first to-be-processed information is the first data packet or the first indication information, where the first indication information is used to indicate the first data packet, Wherein the first thread is a thread that executes a non-thread-safe code;

Writing, by the first thread, the first to-be-processed information into a buffer module;

And performing, by the second thread of the simulator, a consistency negotiation process on the first to-be-processed information, where the consistency negotiation process is used to synchronize the sequence of processing the first data packet by the primary node and the standby node ;

The first data packet is processed by the first thread according to a result of the consistency negotiation process.
The method according to claim 1, wherein the performing, by the second thread of the simulator, the consistency negotiation process on the first to-be-processed information comprises:

Reading, by the second thread, the first to-be-processed information from the buffer module;

Performing a consistency negotiation process on the first to-be-processed information by the second thread, determining a processed sequence of the first data packet;

And writing, by the second thread, the first to-be-processed information to a pipeline according to the processed sequence of the first data packet, where the pipeline is used by the first thread to read the first to-be-processed information.
The method according to claim 2, wherein the reading, by the second thread, the first to-be-processed information from the buffer module comprises:

The first to-be-processed information is read from the buffer module by the second thread at a preset time.
Method according to claim 2 or 3, characterized in that

Before the reading, by the second thread, the first to-be-processed information from the buffer module, the method further includes:

Acquiring exclusive rights of the buffer module by using the second thread, the exclusive permission of the buffer module is for prohibiting two or more threads from accessing the buffer module at the same time;

After the performing the consistency negotiation process on the first to-be-processed information by the second thread, the method further includes:

When the number of pieces of information to be processed in the buffer module is 0, the exclusive permission of the buffer module acquired by the second thread is released by the second thread.
The method according to any one of claims 2 to 4, wherein the performing the consistency negotiation process on the first to-be-processed information by the second thread comprises:

Determining, by the second thread, the quantity of information to be processed in the buffer module;

When the number of the to-be-processed information is greater than 0, the data packet corresponding to the to-be-processed information is written into the consistency log by the second thread, and the to-be-processed information is deleted, where the consistency log is used for the cache a data packet corresponding to the processing information, the sequence of the data packets in the consistency log is corresponding to the processed sequence of the data packets in the consistency log, and the to-be-processed information includes the first to-be-processed Information, the data packet corresponding to the to-be-processed information includes the first data packet;

And sending, by the second thread, a consistency negotiation request that includes the first data packet, where the consistency negotiation request is used to request the standby node to accept a processed sequence of the first data packet;

And receiving, by the second thread, a negotiation completion message, where the negotiation completion message is used to indicate that a processed sequence of the first data packet has been accepted.
The method according to any one of claims 1 to 5, characterized in that

Before the first thread writes the first to-be-processed information to the buffer module, the method further includes:

Obtaining the exclusive permission of the buffer module by using the first thread, the exclusive permission of the buffer module is for prohibiting two or more threads from accessing the buffer module at the same time;

After the first thread writes the first to-be-processed information to the buffer module, the method further includes:

The exclusive permission of the buffer module acquired by the first thread is released by the first thread.
The method according to any one of claims 1 to 6, wherein the first virtual device runs a primary database, the standby node is provided with a second virtual device, and the second virtual device runs Having a standby database, the first data packet carrying an access request for the primary database sent by the client to the primary node,

The obtaining, by the first thread of the simulator, the first to-be-processed information includes:

Obtaining, by the first thread, the first to-be-processed information from a physical network card of the primary node;

Processing, by the first thread, the first data packet according to a result of the consistency negotiation process, including:

And transmitting, by the first thread, the first data packet to the primary database and the standby database, so that the primary node and the standby node process the first data packet in the same order.
The method according to any one of claims 1 to 7, wherein the method further comprises:

Obtaining, by the third thread of the simulator, the load threshold of the primary node and the same dirty page ratio of the primary node and the standby node when the synchronization operation is performed n times, and the n-th synchronization operation is performed by the primary node load threshold value c 1, ..., c n, the same proportion of dirty pages standby master node and the node w 1 is said synchronous operation n times, ..., W n, wherein, c 1 and w 1 corresponds, ..., c n corresponds to w n , and n is a positive integer greater than or equal to 2;

Determining, by the third thread, w m , w m is a load threshold of the current time after the n times of synchronization operations, w m =[(c 1 ×w 1 )+...+(c n ×w n ) ]÷n, m is a positive integer;

Obtaining, by the third thread, L m , L m is a load value of the primary node at the current moment;

If L m ≤ w m , generating a synchronization request by using the third thread, where the synchronization request is used to request synchronization of dirty pages of the primary node and the standby node;

Writing the synchronization request to the buffer module by the third thread;

And performing, by the second thread, a consistency negotiation process on the synchronization request, and performing a consistency negotiation process on the synchronization request to synchronize an order in which the primary node and the standby node process the synchronization request;

The synchronization request is processed by the first thread according to a result of performing a consistency negotiation process on the synchronization request.
The method according to claim 8, wherein the third thread obtains the load threshold of the master node and the same dirty page ratio of the master node and the standby node when n times of synchronization operations are acquired. The method also includes:

Obtaining SUM k by the third thread, SUM k is a sum of a load value obtained by the first load measurement of the primary node to a load value obtained by measuring the kth load, and k is a positive integer;

When k≥T count , the third thread determines c 0 , T count is the load measurement number threshold, and c 0 is the load threshold of the primary node for the first synchronous operation, c 0 =SUM k ÷k;

When k<T count , the third thread acquires L k+1 , L k+1 is the load value of the primary node obtained by the k+1th load measurement, and T count is the threshold of the load measurement times; The third thread acquires SUM k+1 , SUM k+1 =SUM k +L k+1 ; when k+1≥T count , it is determined by the third thread that c 0 , c 0 is the master node The load threshold for the first synchronization operation, c 0 =SUM k+1 ÷(k+1).
The method of claim 8 or 9, wherein the load value of the primary node comprises a processor load value memory, and the load threshold of the primary node comprises a processor load threshold memory.
The method of claim 8 or 9, wherein the load value of the primary node comprises a memory load value and the load threshold of the primary node comprises a memory load threshold.
A data synchronization processing device, characterized by being applied to a simulator of a master node in a computer system, the simulator for simulating a hardware device for a first virtual device of the master node, the computer system further comprising The standby node connected to the master node, the device includes:

a first thread control unit, configured to acquire first to-be-processed information, where the first to-be-processed information is a first data packet or first indication information, where the first indication information is used to indicate the first data packet, where The first thread control unit is configured to execute the non-thread-safe code; and write the first to-be-processed information into the buffer module;

a second thread control unit, configured to perform a consistency negotiation process on the first to-be-processed information, where the consistency negotiation process is used to synchronize an order in which the primary node and the standby node process the first data packet;

The first thread control unit is further configured to process the first data packet according to a result of performing a consistency negotiation process by the second thread control unit.
The device according to claim 12, wherein the second thread control unit is specifically configured to:

Reading the first to-be-processed information from the buffer module;

Performing a consistency negotiation process on the first to-be-processed information, determining a processed order of the first data packet;

And writing the first to-be-processed information to a pipeline according to a processed order of the first data packet, where the pipeline is used by the first thread control unit to read the first to-be-processed information.
The device according to claim 13, wherein the second thread control unit is further configured to:

The first to-be-processed information is read from the buffer module at a preset time.
Device according to claim 13 or 14, characterized in that

Before the reading the first to-be-processed information from the buffer module, the second thread control unit is further configured to:

Obtaining exclusive rights of the buffer module, the exclusive permission of the buffer module is for prohibiting two or more threads from accessing the buffer module at the same time;

After performing the consistency negotiation process on the first to-be-processed information, the second thread control unit is further configured to:

When the number of pieces of information to be processed in the buffer module is 0, the exclusive right of the buffer module acquired by the second thread is released.
The device according to any one of claims 13 to 15, wherein the second thread control unit is further configured to:

Determining the amount of information to be processed in the buffer module;

When the number of the to-be-processed information is greater than 0, the data packet corresponding to the to-be-processed information is written into the consistency log, and the to-be-processed information is deleted, where the consistency log is used to cache the corresponding information to be processed. a data packet, the sequence of the data packets in the consistency log corresponding to the processed sequence of the data packets in the consistency log, the to-be-processed information including the first to-be-processed information, the to-be-processed The data packet corresponding to the information includes the first data packet;

Sending a consistency negotiation request including the first data packet, where the consistency negotiation request is used to request the standby node to accept a processed sequence of the first data packet;

Receiving a negotiation completion message, the negotiation completion message is used to indicate that the processed sequence of the first data packet has been accepted.
Apparatus according to any one of claims 12 to 16 wherein:

Before the first to-be-processed information is written to the buffer module, the first thread control unit is further configured to:

Obtaining exclusive rights of the buffer module, the exclusive permission of the buffer module is for prohibiting two or more threads from accessing the buffer module at the same time;

After the first to-be-processed information is written to the buffer module, the first thread control unit is further configured to:

Release exclusive rights of the buffer module acquired by the first thread control unit.
The device according to any one of claims 12 to 17, wherein the first virtual device runs a primary database, the standby node is provided with a second virtual device, and the second virtual device runs Having a standby database, the first data packet carrying an access request for the primary database sent by the client to the primary node,

The first thread control unit is further specifically configured to:

Obtaining the first to-be-processed information from a physical network card of the primary node;

And transmitting the first data packet to the primary database and the standby database simultaneously, so that the primary node and the standby node process the first data packet in the same order.
Apparatus according to any one of claims 12 to 18, wherein said apparatus further comprises a third thread control unit,

The third thread control unit is configured to:

Obtaining a load threshold of the primary node and a same dirty page ratio of the primary node and the standby node when the synchronization operation is performed n times, and the load threshold of the primary node is c 1 ,...,c during the n synchronization operations n, said n-th synchronous operation when the same proportion of dirty pages of the standby master node and the node is w 1, ..., W n, wherein, c 1 and w 1 corresponds, ..., C n corresponding to n and W, n is a positive integer greater than or equal to 2;

Determining w m , w m is the load threshold of the current time after the n times of synchronization operations, w m =[(c 1 ×w 1 )+...+(c n ×w n )]÷n,m is Positive integer

Obtaining L m , L m is a load value of the primary node at the current moment;

If L m ≤ w m , generating a synchronization request, the synchronization request is used to request synchronization of dirty pages of the primary node and the standby node;

Writing the synchronization request to the buffer module;

The second thread control unit is further specifically configured to:

Performing a consistency negotiation process on the synchronization request, and performing a consistency negotiation process on the synchronization request to synchronize the order in which the primary node and the standby node process the synchronization request;

The first thread control unit is further specifically configured to:

The synchronization request is processed according to a result of performing a consistency negotiation process on the synchronization request.
The apparatus according to claim 19, wherein said third thread is obtained before said acquiring a load threshold of said master node and a same dirty page ratio of said master node and said standby node at n times of synchronization operation The control unit is also specifically used to:

Obtaining SUM k , SUM k is the sum of the load value obtained by the first load measurement of the primary node to the load value obtained by measuring the kth load, and k is a positive integer;

When k≥T count , it is determined that c 0 , T count is the load measurement number threshold, and c 0 is the load threshold of the first synchronization operation of the primary node, c 0 =SUM k ÷k;

When k<T count , obtain L k+1 , L k+1 is the load value of the primary node obtained by the k+1th load measurement, and T count is the threshold of the load measurement times; acquire SUM k+1 , SUM K+1 = SUM k + L k+1 ; when k+1≥T count , it is determined that c 0 , c 0 is the load threshold of the first synchronization operation of the primary node, c 0 =SUM k+1 ÷(k+ 1).
The apparatus of claim 19 or 20, wherein the load value of the primary node comprises a processor load value memory, and the load threshold of the primary node comprises a processor load threshold memory.
The apparatus of claim 19 or 20, wherein the load value of the primary node comprises a memory load value and the load threshold of the primary node comprises a memory load threshold.
A data synchronization processing apparatus, comprising: a processor, wherein the processor is coupled to a memory;

The memory is for storing a computer program;

The processor is operative to execute a computer program stored in the memory to cause the apparatus to perform the method of any of claims 1-11.