WO2019000423A1 - Data storage method and device - Google Patents

Abstract

A data storage method and device, used to reduce the time required by a distributed storage system to respond to a client with respect to a write request. In the method, after a network adapter in a first node determines that the first node and at least one secondary node intending to store first data have both buffered a first write request comprising the first data, a response message is returned to a client informing of the success of the buffering operation. The method not only decreases the time required by the distributed storage system to respond to the client, but also reduces the time consumed by the node to store the first data, thereby maximally reducing the time required by the distributed storage system to respond to the client with respect to the first write request.

Description

Data storage method and device Technical field

The present application relates to the field of storage technologies, and in particular, to a data storage method and device.

Background technique

Currently, distributed storage systems include the Hadoop Distributed File System (HDFS), Ceph, and the like. In order to ensure data reliability, a distributed storage system usually adopts a copy mechanism to improve the reliability of data stored in the system, and saves the data to a plurality of storage nodes in the distributed storage system. The plurality of storage nodes include one primary node and at least one secondary node.

In the process of storing data in the distributed storage system by the client, each storage node (for example, a master node or a slave node) to store the data needs to write the write request after receiving the write request of the client. Storing to the memory of the storage node, and then saving the data in the write request to the disk of the storage node; the master node determines that the master node and each slave node successfully save the data to the disk Thereafter, a success response message is returned to the client, thereby notifying the client that the primary node and the at least one secondary node have successfully stored the data.

Since any one of the storage nodes stores the data in the write request for persistence, the write request needs to be first transferred to the memory, and then the data in the write request in the memory is stored locally. Disk. Therefore, the process of saving the data to the disk by the storage node takes a long time. And, the master node or the slave node needs to send the write request to another slave node after the data storage in the write request is successful, thereby causing the distributed storage system to respond to the client after receiving the write request. The end of the time is longer.

Summary of the invention

The embodiment of the present application provides a data storage method and device to reduce the time for a distributed storage system to respond to a write request to a client.

In a first aspect, the embodiment of the present application provides a data storage method, where the method is applied to a distributed storage system, where the distributed storage system includes multiple storage nodes, and the first of the multiple storage nodes The node includes a network card, the network card includes a first memory, and the first memory is a non-volatile memory, and the method includes the following steps:

After the network card caches the received first write request in the first memory, sends the first write request to at least one slave node that is to store the first data, so that the at least one slave node caches The first write request, wherein the first write request carries first data to be stored, the first node is a primary node to store the first data, and the network card is receiving the at least one After the first cache success message returned by the node, the success response message is returned to the client, where the first cache success message is used to indicate that the at least one slave node has successfully cached the first write request, the success The response message is used to indicate that the first data has been stored in a primary node to which the first data is to be stored and the at least one secondary node.

Through the above method, the network card in the first node returns to the client after determining that the first node and at least one slave node that is to store the first data have successfully cached the first write request that includes the first data. Successful response message. Therefore, the method can not only reduce the time that the distributed storage system responds to the client by the first The time taken by the node to save the first data may also reduce the time consumed by the slave node to save the first data, so that the distributed storage system may be minimized to respond to the first write to the client. The time of the request.

In a possible design, the first write request further includes an identifier of the data object to which the first data belongs, in which case the network card sends the first write request to the to-be-stored Before the at least one slave node of the first data, the first node may be determined as a master node to store the first data (ie, a master node storing the data object), and in the distribution Determining, in the storage system, the at least one slave node to store the first data (ie, storing at least one slave node of the data object):

The network card calculates the identifier of the data object according to a set data distribution algorithm (for example, a CRUSH algorithm, etc.), and obtains a plurality of storage nodes that store the data object, where the multiple storage nodes that store the data object include The first node;

Determining, by the network card, the first node as a primary node storing the data object according to the set primary node selection rule, and determining, among the plurality of storage nodes storing the data object, other than the first node The other storage nodes are slave nodes that store the data objects.

With this design, the network card can determine that the first node is a primary node that stores the data object and at least one secondary node that stores the data object.

In a possible design, the network card may further determine, according to the data object replica distribution topology information, a plurality of storage nodes that store the data object, where the topology information includes the storage in the distributed storage system. All nodes of the data object corresponding to the identifier of the data object, and the connection status of the nodes.

The design can ensure that the plurality of storage nodes of the data object determined by the network card can communicate, that is, the first write request can be transmitted.

In one possible design, the first node further includes a processor and a second memory, and the second memory is a non-volatile memory (eg, memory or external memory of the first node), the method It also includes the following steps:

The processor reads the first write request from the first memory, and writes the first data into the second memory according to the first write request, the identifier of the data object Corresponding to the data object.

With this design, the first node can successfully store the first data into the data object.

In one possible design, the processor reads a plurality of write requests including the first write request from the first memory. For example, the processor may read the set number of write requests (including the first write request) when the unread write request stored in the first memory reaches a set number; The processor may read the unread write request (including the first write request) stored in the second memory according to a set read cycle.

With this design, the signaling overhead of the processor can be saved, and the number of times the processor performs a read write request can be reduced, so that the power consumption of the processor can be reduced.

In a possible design, the first memory stores the first write request according to the identifier of the data object; in this case, the first data is sent by the processor according to the first write request After writing the data object in the second memory, the processor may further send a space release message including the identifier of the data object to the network card, such that the network card is identified according to the identifier of the data object Deleting the first write request in the first memory.

Through the above method, the network card can release the storage space occupied by the first write request in the first memory, so that the storage space in the first memory can be recycled.

In a possible design, after reading the first write request, the processor notifying the network card to add a corresponding read flag to the first write request; the network card is according to the data object. Identifying the deleted first memory In the first write request, only the first write request containing the identifier of the data object and corresponding to the read flag is deleted.

In a possible design, after receiving the first write request, the network card determines a receiving timestamp of the first write request, and stores the first write request and the corresponding receiving timestamp simultaneously The first memory, wherein the receiving timestamp includes a time when the network card receives the first write request; the processor simultaneously reads the receiving timestamp when reading the first write request, And adding the receiving timestamp to the space release message; the network card deleting the first write request that includes the identifier of the data object and corresponding to the receiving timestamp.

With the above two designs, the network card can accurately delete the first write request that has been read by the processor, and avoid erroneous deletion of the identifier containing the data object and is not read by the processor. Other write requests, thereby ensuring that the first node can subsequently store data in the other write requests into the second memory.

In a possible design, when the first node is a slave node of the second data to be stored, the method further includes:

After the network card caches the received second write request in the first memory, the second cache success message is sent to the second node of the multiple storage nodes, where the second write request is carried in the second write request. The stored second data, the second cache success message is used to indicate that the first node has successfully cached the second write request, and the second node is a primary node to store the second data.

With the design, the network card in the first node feeds back the second cache success message to the second node after determining that the first node has successfully cached the second write request that includes the second data. Therefore, the design can reduce the time consumed by the distributed storage system to save the second data by the first node in response to the time of the client, thereby minimizing the distributed storage system to the client. The time at which the end responds to the second write request.

In a second aspect, the embodiment of the present application further provides a storage node, where the storage node has a function of implementing the behavior of the first node in the foregoing method instance. The functions may be implemented by hardware or by corresponding software implemented by hardware. The hardware or software includes one or more modules corresponding to the functions described above.

In a possible design, the structure of the storage node includes a communication unit (including a first storage unit), a processing unit, and a second storage unit, and the units may perform corresponding functions in the foregoing method examples, and specifically refer to the method. The detailed description in the examples is not described here.

In a third aspect, the embodiment of the present application further provides a storage device, where the storage device is a storage node in a distributed storage system, and the distributed storage system includes multiple storage nodes. The storage device has a function of implementing the behavior of the first node in the above method example. The storage device includes an interface card, a processor, and at least one memory. The interface card includes a first memory for buffering a write request. The at least one memory includes a second memory for storing data. The interface card, and the processor, are configured to support the storage device to perform a corresponding function in the above method. The first memory and the second memory are non-volatile memories.

In a fourth aspect, the embodiment of the present application further provides a network card, where the network card has a function of implementing a behavior of a network card in a first node in the foregoing method instance. The functions may be implemented by hardware or by corresponding software implemented by hardware. The hardware or software includes one or more modules corresponding to the functions described above.

In a possible design, the structure of the network card includes a receiving unit, a sending unit, and a first memory, where the first memory is a non-volatile memory, and the units can perform corresponding functions in the foregoing method examples, specifically See the detailed description in the method example, which is not described here.

In a possible design, the network card includes a communication interface, a processor, and at least one memory, the at least one memory includes a first memory, and the first memory is a non-volatile memory, Processor It is configured to support the network card to perform the corresponding functions in the above method. The at least one memory is coupled to the processor, which stores program instructions (or applications) necessary for the processor to save a write request.

In a fifth aspect, the embodiment of the present application further provides a distributed storage system, where the distributed storage system includes multiple storage nodes, and each storage node has the function of the behavior of the first node in the foregoing method instance.

In a sixth aspect, the embodiment of the present application further provides a computer storage medium, where the software program stores a software program, where the software program can be read and executed by one or more processors to implement the first aspect. Methods.

In a seventh aspect, the embodiment of the present application further provides a computer program product comprising instructions, when executed on a computer, causing the computer to perform the method described in the first aspect above.

In the embodiment of the present application, the network card in the first node determines that the first node and the at least one slave node that is to store the first data have successfully cached the first write request that includes the first data, that is, to the client. The terminal returns a success response message. Therefore, the method can not only reduce the time consumed by the first storage node to save the first data in the time when the distributed storage system responds to the client, but also reduce the saving of the first data by the slave node. The time consumed so that the time that the distributed storage system responds to the first write request to the client can be minimized.

DRAWINGS

FIG. 1 is a schematic structural diagram of a write request according to an embodiment of the present application;

2 is a schematic structural diagram of a distributed storage system according to an embodiment of the present application;

FIG. 3 is a flowchart of a data storage method according to an embodiment of the present application;

4 is a flowchart of an example of data storage provided by an embodiment of the present application;

FIG. 5 is a structural diagram of a storage node according to an embodiment of the present application;

FIG. 6 is a structural diagram of a storage device according to an embodiment of the present disclosure;

FIG. 7 is a schematic diagram of a distributed storage system according to an embodiment of the present application.

Detailed ways

The embodiment of the present application provides a data storage method and device, which are used to reduce the time for a distributed storage system to respond to a write request to a client. The method and the device are based on the same inventive concept. Since the method and the device solve the problem are similar, the implementation of the device and the method can be referred to each other, and the repeated description is not repeated.

Hereinafter, some of the terms in the present application will be explained to be understood by those skilled in the art.

1) A distributed storage system according to an embodiment of the present application includes a plurality of independent storage nodes. The distributed storage system stores data in a plurality of independent storage nodes, which can improve data reliability and security. Optionally, the distributed storage system may be an HDFS, a Ceph, or the like, which is not limited in this application.

2) The storage node involved in the embodiment of the present application is a device for storing data in a distributed storage system, and the device may be a device having an analysis processing function and a data storage function, such as a server.

In a distributed storage system that uses a copy mechanism to store data, each data must have multiple copies distributed across multiple storage nodes. Wherein, the copy stored to the master node is the master copy, and the copy stored to the slave node is the slave copy.

The master node to store the data is used to store a master copy of the data, has a communication connection with all of the slave nodes to which the data is to be stored, and has a communication connection with the client that initiated the write request containing the data. The client may distribute the data to all the slave nodes that are to store the data through the master node, that is, the master node needs to save the data to the local after receiving the write request including the data, and Also need to transfer the write request to be stored The slave node of the data.

The slave node to store the data is used to store the slave copy of the data, and has a communication connection with the master node to store the data, and after receiving the write request containing the data transmitted by the master node, the data is saved to the local .

When a storage node in a distributed storage system uses a data object as a basic unit for storing data, the primary node of the data to be stored is a primary node that stores the data object to which the data belongs; correspondingly, the slave node to which the data is to be stored is stored. The slave node of the data object to which the data belongs.

It should be noted that the master node and the slave node are for one data (or one data object). For example, when a plurality of data are stored in a storage node in a distributed storage system, the storage node may be a primary node of a part of the plurality of data and a slave node of another partial data. For another example, when a plurality of data objects are stored in a storage node in the distributed storage system, the storage node may be a master node of a part of the plurality of data objects and a slave node of another part of the data object.

3) The data object involved in the embodiment of the present application can be used as a basic unit for storing data in a storage node in a distributed storage system. The data object is a basic data storage management unit in the object storage, which is actually a combination of data and a set of meta data, wherein the attribute information may include a redundant array of inexpensive disks (RAID). Information such as parameters, data distribution, and quality of service parameters. Therefore, data objects can not only store data, but also organize and manage the distribution structure of data.

Each data object corresponds to a unique identifier, so that the storage node or the client does not need to pass the physical address of the data, but can retrieve and determine the corresponding data object by the identifier of the data object.

4) A client (client), which is also referred to as a client, is a program for providing services to a client, and corresponds to a storage node (server) in a distributed storage system. A communication connection needs to be established between the client and the storage node to ensure that the program can operate normally and provide services for customers. Optionally, the client can be installed in a normal client.

The client, as an initiating device of the write request, may generate a write request including data to be stored according to the data indication of the client or the program, and send the write request to the storage node in the distributed storage system, Implementing storing data contained in the write request into the distributed storage system.

5) The first memory involved in the embodiment of the present application is a non-volatile memory (NVM), and is set as a cache of the network card inside the network card. The first memory can persist the storage write request and have features that are not lost when power is lost. Optionally, the first memory may include a phase change memory (PCM), a resistive random access memory (RRAM), and a magnetic random access memory (MRAM). Spin torque transfer magnetic random access memory (SPT-RAM), flash memory (Flash Memory) and so on.

6) The second memory involved in the embodiment of the present application is also a non-volatile memory (NVM), which may be a memory or an external memory in the storage node. The second memory can persist the stored data and has features that are not lost when powered down. Optionally, the second memory may be PCM, RRAM, MRAM, STT MRAM, Flash Memory, magnetic disk, floppy disk, hard disk, magneto-optical disk, optical disk, or the like. Optionally, the second memory may use a data object as a basic unit for storing data.

7) A network interface card (NIC) in a storage node according to an embodiment of the present application, for communicating with other devices (including other storage nodes or clients). For example, receiving a write request sent by a client or other storage node, sending a write request or other information to other storage nodes. The network card is provided with a first memory, and after the network card receives a write request, the write request may be stored in the first memory.

8) The write request related to the present application is initiated by the client to the distributed storage system, and is used to notify the storage node that receives the write request to store the data to be stored included in the write request.

Optionally, when the storage node in the distributed storage system uses the data object as a basic unit for storing data, the write request further includes an identifier indicating a data object to which the data belongs. In this way, the storage node can determine the data object corresponding to the identifier of the data object, so that the data in the write request can be stored into the data object.

Optionally, when the write request includes the identifier of the data object, the write request may further include an offset address and a data length in the data object, where the offset address in the data object is a storage node. An offset of a starting address of the data stored relative to a starting address of the data object in the data object; the data length being a length of the data.

Optionally, since the write request needs to be transmitted to the distributed storage system through the network, the write request further includes a network protocol stack level required for network transmission: a transport layer, a network layer, and a data link layer. For example, the write request shown in FIG. 1 includes data, a data semantic layer, a transport layer, a network layer, and a data link layer. The data semantic layer may include a data object identifier, and may also include an offset address, a data length, and the like in the data object.

9) The cache success message according to the embodiment of the present application is used to indicate that the slave node has successfully cached the write request, and after the network card in the slave node of the data to be stored buffers the received write request to the first memory of the network card, The NIC sends the primary node to the data to be stored.

10) The success response message related to the embodiment of the present application, after the master node that is to store the data determines that the master node and all the slave nodes to be stored have successfully cached the write request, send the request to the client that initiates the write request. . Therefore, the success response message is sent to the originating client after the network card in the primary node receives the cache success message sent by all the slave nodes.

Since the success response message is sent after the master node and all the slave nodes have successfully cached the write request, the master node and the slave node's network card have been sent before the master node sends the success response message. The write request is successfully cached in the first memory in the network card. Moreover, since the first memory in the network card is a non-volatile memory, the master node and the slave node can subsequently save the data in the write request to its own second memory according to the saved write request. Furthermore, the data is successfully included in the write request that is successfully cached. In summary, the success response message can also be used to indicate that the data in the write request has been stored in the primary node and all the secondary nodes where the data is to be stored.

11) A plurality of the embodiments of the present application refer to two or more.

In addition, it should be understood that in the description of the present application, the terms "first", "second" and the like are used only to distinguish the purpose of description, and are not to be understood as indicating or implying relative importance, nor as an indication. Or suggest the order.

The embodiments of the present application will be further described in detail below with reference to the accompanying drawings.

FIG. 2 shows a distributed storage system to which the data storage method provided by the embodiment of the present application is applicable. Referring to FIG. 2, a plurality of storage nodes 201 (such as storage node a201, storage node b201, storage node c201, and storage node n201) are included in the distributed storage system. among them,

There is a communication connection between each storage node 201 in the distributed storage system and at least one other storage node 201 to enable communication between the storage nodes 201. As shown in the figure, the storage node a201 has a communication connection with the storage node b201 and the storage node c201, respectively; and a communication connection exists between the storage node c201 and the storage node n201.

In addition, at least one storage node 201 in the distributed storage system is connected to the client 202 to implement the Communication between the storage node 201 and the client 202. As shown, there is a communication connection between the storage node a201 and the client 202.

In the process of storing the data in the write request by the distributed storage system:

After the master node of the plurality of storage nodes 201 to store the data receives the write request, after the network card of the master node successfully caches the write request (before successfully storing the data to the local disk) Sending the write request to at least one slave node of the plurality of storage nodes 201 to be stored, and successfully storing the data after transmitting the write request to the at least one slave node ;

After receiving the write request, each slave node may return a cache success message to the master node after the slave node's network card successfully caches the write request (before successfully storing the data to the local disk), Notifying the master node that the slave node has successfully cached the write request;

After receiving the cache success message of all the slave nodes, the master node returns a success response message to the client 202 to notify the client 202 that the master node and the at least one slave node have stored the data.

In the process of storing data in the distributed storage system, the master node sends the write request to the slave node before successfully storing the data, thereby avoiding that the master node in the traditional data storage method After the data is saved to the disk, the write request is sent to the slave node; therefore, the method can reduce the time when the distributed storage system responds to the client 202 by the master node to save data to the disk. time consumed. In addition, since the slave node returns a cache success message to the master node before successfully storing the data, the slave node avoids the cache success message after saving the data to the disk in the traditional data storage method. Therefore, the method can also reduce the time taken by the distributed storage system to save data to the disk by the slave node in response to the time of the client 202. Obviously, the distributed storage system can not only reduce the time consumed by the distributed storage system to save the data to the disk by the primary node in response to the time of the client 202, but also reduce the time The time taken by the node to save the data to the disk, thereby minimizing the time that the distributed storage system responds to the write request to the client.

The embodiment of the present application provides a data storage method, which is applied to a distributed storage system, such as the distributed storage system shown in FIG. 2, wherein the distributed storage system includes multiple storage nodes, which are implemented by the present application. The first node involved in the example is one of the plurality of storage nodes. The storage node includes a network card and a first memory, wherein the network card includes a first memory, and the first memory is a non-volatile memory. Referring to Figure 3, the process of the method includes:

S301: The network card receives a first write request, where the first write request carries the first data to be stored.

Optionally, the network card may receive the first write request sent by a client that initiates the first write request or another device in the distributed storage system.

According to the description in the write request in the preamble, when the storage node in the distributed storage system is a data unit as a basic unit for storing data, the first write request further includes the first data The identifier of the data object. In addition, the first write request may further include information such as an offset address, a data length, and the like in the data object.

When the first write request needs to be transmitted to the distributed storage system through the network, the structure of the first write request is as shown in FIG. 1 , and details are not described herein again.

S302: The network card caches the first write request in the first memory.

In the above S302, since the first memory is disposed inside the network card, the time taken by the network card to save the write request to the first memory is shorter. In addition, since the first memory is a non-volatile memory, the first node can quickly cache the write request by S302.

S303: The network card sends the first write request to at least one slave node that is to be used to store the first data, where the first node is a master node that is to store the first data.

And by S303, the first node distributes the first write request to the at least one slave node to ensure that the at least one slave node may also cache the first write request.

Optionally, in a case that the first write request further includes the identifier of the data object, before the performing the S303, the network card may determine, by using the following steps, that the first node is to be the first to be stored. a primary node of data (ie, a primary node storing the data object), and determining, in the distributed storage system, the at least one secondary node to store the first data (ie, storing at least one of the data objects) From the node):

Step a: The network card calculates the identifier of the data object according to the set data distribution algorithm, and obtains a plurality of storage nodes that store the data object, where the plurality of storage nodes storing the data object include the first One node

Step b: the network card determines, according to the set primary node selection rule, that the first node is a primary node that stores the data object, and determines that the first node is the plurality of storage nodes that store the data object. Other storage nodes than others are slave nodes that store the data objects.

Optionally, before step a, the network card may read the first write request in the first memory or another cache of the network card, and obtain the foregoing included in the first write request. The identifier of the data object.

In order to ensure that the data object corresponding to the identifier of the data object exists in the plurality of storage nodes storing the data object determined by the network card, the first node further includes a data object replica distribution topology. In the case of the information, optionally, when the network card performs the foregoing step a, the identifier of the data object and the topology information may be calculated according to a set data distribution algorithm, and the data object is obtained. Multiple storage nodes. The topology information includes all nodes of the data object corresponding to the identifier of the data object stored in the distributed storage system, and the connection status of the nodes.

In the above method, since the network card can also determine, by using the topology information, a plurality of storage nodes that store the data object. In this way, the network card can ensure that the data object corresponding to the identifier of the data object exists in the plurality of storage nodes that store the data object, and that the plurality of storage nodes can communicate. That is, the first write request can be transmitted.

Optionally, in the foregoing step a, the data distribution algorithm may be a Controlled Replication Under Scalable Hashing (CRUSH) algorithm.

Since in step a, the network card can determine a plurality of storage nodes storing the data object, but it is not possible to determine which storage node is the primary node storing the data object, and therefore, the network card can be determined by the above step b The primary node and at least one secondary node.

Optionally, the primary node selection rule may be, but is not limited to, the following rule: selecting a storage node with the largest storage node identifier as the primary node, selecting a storage node with the smallest storage node identifier as the primary node, and selecting the corresponding storage. A storage node whose node is identified within the specified range serves as the primary node, and selects a storage node that is within the specified physical location range or the specified communication location as the primary node.

It should be noted that, after determining the first data to be stored, the client needs to be in the distributed storage system before sending the first write request to the distributed storage system. Determining, in the storage node, a primary node (ie, the first node) to store the first data, and transmitting the first write request to the primary node. In order to ensure that the primary node and the first node determined by the client determine that the primary node is the same storage node, the client needs to adopt the network card when determining the primary node. The same method when determining the primary node.

For example, when the first node determines that the master node is the master node by using the foregoing steps a and b, the client may determine that the first node is the master node by using the foregoing steps a and b, and The first node and the client may need to adopt the same data distribution algorithm and the master node selection rule.

S304: The network card receives a first cache success message returned by the at least one slave node, where the first cache success message is used to indicate that the at least one slave node has successfully cached the first write request.

After the first cache success message is cached by the network card of the slave node to the first memory in the network card, the first cache request is sent by the network card to the first node, and therefore, the network card After receiving the first cache success message sent by any slave node, it may be determined that the slave node has successfully cached the first write request.

S305: The network card returns a success response message to the client, where the success response message is used to indicate that the first data has been stored in a primary node that is to store the first data and the at least one secondary node.

Optionally, in the embodiment of the present application, the first node further includes a processor and a second memory, where the second memory is a non-volatile memory. Optionally, the second memory may be a memory or an external memory (such as a magnetic disk, a hard disk, a floppy disk, an optical disk, or the like) in the first node.

Optionally, after S302, the first node may further store the first data in the first write request into the second memory by using the following steps:

Step A: The processor reads the first write request from the first memory;

Step B: The processor writes the first data into the data object corresponding to the identifier of the data object in the second memory according to the first write request.

Optionally, the process of storing the first data by the processor does not have an association relationship with the process of executing the network card S303-S305. Therefore, the two processes may be started at the same time, or may be performed on the network card. After executing the processes of S303-S305, the processor is executing a process of storing the first data. This application does not limit this.

In this way, the network card can distribute the first write request to the at least one slave node before the processor stores the first data to the second memory, avoiding the traditional data storage method. The primary node first distributes the first write request after saving the first data to the second memory, so the method may reduce the time that the distributed storage system responds to the client by the first node. The time consumed by the first data, thereby reducing the time that the distributed system responds to the write request to the client.

Optionally, the processor may read the first write request from the first memory by using the following method, including:

The processor reads a plurality of write requests including the first write request from the first memory.

For example, the processor may read the set number of write requests (including the first write request) when the unread write request stored in the first memory reaches a set number; The processor can read the unread write request (including the first write request) stored in the second memory according to the set read cycle. This application does not limit this.

The processor reads the unread write request by the foregoing method, which can save the signaling overhead of the processor, and reduce the number of times the processor performs the read write request, thereby reducing the processor. Power consumption.

Optionally, when the first write request includes not only the identifier of the data object, but also information such as an offset address, a data length, and the like in the data object. In this way, when the step B is performed, the processing may store the first data to an accurate position in the data object according to information such as an offset address, a data length, and the like in the data object.

Since the first memory is a non-volatile storage medium, after the processor reads the first write request from the first memory, the first memory is still cached in the first memory First write request, in order to guarantee The storage space in the first memory may be recycled. Optionally, after executing the writing the first data to the data object in the second memory, the processor may notify the network card deletion station Describe the first write request.

Therefore, optionally, after the processor writes the first data to the data object in the second memory, the method further includes:

The processor sends a space release message to the network card, where the space release message includes an identifier of the data object;

The network card deletes the first write request in the first memory according to the identifier of the data object.

Through the above method, the network card can release the storage space occupied by the first write request in the first memory.

Optionally, the network card may obtain the space release message by using the following method:

Sending, by the processor, the space release message to the network card; or

The processor sends the space release message to a memory in the first node, and the network card may release a message read period according to a set space, and read the space release message stored in the memory. .

Optionally, when the network card is executing S302, the first write request may be stored into the first memory according to an identifier of the data object in the first write request, for example, the data to be included by the network card The write request with the same identifier of the object is stored in the same storage space in the first memory. In this way, when deleting the first write request, the network card may determine the storage space where the first write request is located according to the identifier of the included data object.

Optionally, in order to prevent the network card from deleting the first write request in the first memory according to the identifier of the data object, the data object that occupies the storage space and includes the data object may be deleted by mistake. And identifying, by the processor, a write request that is not read by the processor, the first node may, but is not limited to, deleting the first write request saved in the first memory by using the following possible implementations:

a first possible implementation manner: after reading the first write request, the processor notifying the network card to add a corresponding read flag to the first write request; the network card is according to the data object When the identifier deletes the first write request in the first memory, only the first write request that includes the identifier of the data object and corresponds to the read flag is deleted.

a second possible implementation manner: after receiving the first write request, the network card determines a receiving timestamp of the first write request, and simultaneously stores the first write request and the corresponding receiving timestamp Go to the first memory, wherein the receiving timestamp includes a time when the network card receives the first write request; the processor simultaneously reads the receiving timestamp when reading the first write request And adding the receiving timestamp in the space release message; the network card deleting the first write request that includes the identifier of the data object and corresponding to the receiving timestamp.

Through the above two implementation manners, the network card can accurately delete the first write request that has been read by the processor, and avoid erroneously deleting the identifier that includes the data object, and is not read by the processor. Other write requests are fetched to ensure that the first node can subsequently store data in the other write requests into the second memory.

With the method of the embodiment of the present application, after determining, by the network card in the first node, that the first node and the at least one slave node that is to store the first data have successfully cached the first write request that includes the first data, Returns a success response message to the client. Therefore, the method can not only reduce the time consumed by the first storage node to save the first data in the time when the distributed storage system responds to the client, but also reduce the saving of the first data by the slave node. The time consumed so that the time that the distributed storage system responds to the first write request to the client can be minimized.

In addition, optionally, in the foregoing embodiment, when the first node is a slave node that is to store the second data, The method also includes:

The network card receives a second write request, where the second write request carries the second data to be stored;

The network card buffers the second write request in the first memory;

Sending, by the network card, a second cache success message to a second one of the plurality of storage nodes, where the second cache success message is used to indicate that the first node has successfully cached the second write request, where The first node is a slave node of at least one slave node to be stored, and the second node is a master node to store the second data.

The process of writing the second data into the second memory by the processor may refer to the description of the processor writing the first data to the second memory, and details are not described herein again.

Based on the foregoing embodiment, referring to FIG. 4, an embodiment of the present application further provides an example of a data storage method, where the client includes a plurality of storage nodes that store data in a distributed storage system. In this example, the primary node to store data is the first node, and the secondary node to store data is described by taking the second node as an example. As shown, the data storage process in this example includes:

Step 1: The client determines the data to be stored and determines the identity of the data object to which the data belongs.

Step 2: The client according to the data object identifier, the data object replica distribution topology information in the distributed storage system, according to a set data distribution algorithm (for example, CRUSH algorithm), in the distributed storage system Among the plurality of nodes included, a plurality of storage nodes (including the first node and the second node) storing the data object are determined.

Step 3: The client selects the first node among the determined plurality of storage nodes storing the data object according to the set primary node selection rule (for example, selecting a storage node with the largest storage node identifier as the primary node) As the primary node that stores the data object.

Step 4: The client sends a write request including the data to be stored to the first node. The structure of the write request is as shown in Figure 1:

The data semantic layer in the write request includes: the data object identifier, an offset address in the data object, a data length, and the like. The transport layer, the network layer, and the data link layer in the write request are network protocol stack layers required for network transmission. The transport layer in the write request includes a port number indicating a storage software system that processes the write request.

Step 5: The network card a in the first node receives the write request, and caches the write request into the first memory a included in the network card a.

Step 6: The network card a reads the write request from the cache of the first memory a or the network card a, decapsulates the write request, and parses the data in the write request a semantic layer that acquires an identifier of the data object included in the data semantic layer.

Step 7: The network card a acquires data object replica distribution topology information in the distributed storage system in a shared memory in the first node, and distributes the data object according to the identifier of the data object. The topology information is determined to store the data object among the plurality of storage nodes included in the distributed storage system according to the set data distribution algorithm (same as the algorithm used by the client in step 2) A plurality of storage nodes (including the first node and the second node).

Step 8: The network card a selects the first node among a plurality of storage nodes storing the data object according to the set primary node selection rule (same as the rule used by the client in step 3) And a storage node that stores the data object; and determines a storage node (the second node) other than the primary node among the plurality of storage nodes storing the data object as a slave node that stores the data object.

Step 9: The network card a sends the write request to the at least one slave node (including the second node).

Step 10: The network card b in the second node receives the write request, and caches the write request into the first memory b included in the network card b.

Step 11: The network card b reads the write request from the cache of the first memory b or the network card b, decapsulates the write request, and parses the data in the write request a semantic layer that acquires an identifier of the data object included in the data semantic layer.

Step 12: The network card b acquires data object replica distribution topology information in the distributed storage system in a shared memory in the second node, and distributes according to the identifier of the data object and the data object replica. Topology information, according to the set data distribution algorithm (same as the algorithm used in steps 2 and 7), determining, among the plurality of nodes included in the distributed storage system, storing the data object Storage nodes (including the first node and the second node).

Step 13: The network card b selects the first node as one of a plurality of storage nodes storing the data object according to the set primary node selection rule (same as the rules used in steps 3 and 8) Storing a primary node of the data object; and determining, among the plurality of storage nodes storing the data object, a storage node (second node) other than the primary node as a secondary node storing the data object.

Step 14: The network card b sends a cache success message to the first node (the primary node), and the cache success message response is used to indicate that the second node has successfully cached the write request.

Step 15: After receiving the cache success message sent by the second node, the network card a in the first node sends a success response message to the client, where the success response message is used to indicate that the data has been Stored in the first node and the second node.

In this example, after the above step 9, the first node further needs to store the data in the write request to the second memory a in the first node by the following steps:

Step (1-a): when the network card a determines that the received write request reaches the set number, generates a direct memory access (DMA) interrupt, and sends it to the DMA controller a in the processor a, The DMA controller a reads the set number of write requests (including the write request) from the first memory and copies to the kernel memory buffer of the processor a.

Step (1-b): after the kernel process in the processor a detects that there is a new write request (the write request) in the kernel memory buffer, decapsulating the write request to obtain the The port number in the transport layer in the write request, and the data content containing the data and data semantic layers.

Step (1-c): the kernel process starts the storage software system a corresponding to the port number according to the port number, and the storage software system a decapsulates the data content in the kernel memory buffer area Copy to the user cache in the storage software system.

Step (1-d): the storage software system a parses the data content in the user cache area, acquires the data, and the data object identifier and the data object offset in the data semantic layer Information such as address and data length.

Step (1-e): The storage software system a stores the data in the first memory a according to the offset address and the data length in the data object.

In this example, after the above step 14, the second node may also need to store the data in the write request to the data through the above steps (step (1-a) to step (1-e)). a second memory b in the second node, specifically The above steps can be referred to, and details are not described herein again.

In this example, after the first node stores the data to the second memory a, the first node further needs to delete the write request in the first memory a by the following steps:

Step (2-a): The storage software system a generates a space release message containing an identifier of the data object, and transmits the space release message to the shared memory.

Step (2-b): The network card a releases the message release period according to the set space, and reads the space release message in the shared memory.

Step (2-c): the network card a deletes the identifier in the second memory a that includes the identifier of the data object and corresponds to the read flag according to the identifier of the data object in the space release message. request.

The read flag corresponding to the write request is that the DMA controller a in the step (1-a) notifies the network card to add when the read request is read from the first memory a.

In this example, after the second node stores the data to the first memory b, the second node also needs to pass the above steps (step (2-a) to step (2-c)) And deleting the write request in the first memory b. For details, refer to the foregoing steps, and details are not described herein again.

In the above example, the network card a in the first node returns a success response message to the client after determining that the first node and the second node have successfully cached the write request. Therefore, the example can not only reduce the time consumed by the distributed storage system to save the data by the first node in response to the time of the client, but also reduce the consumption of saving the data by the second node. Time, thereby minimizing the time that the distributed storage system responds to the write request to the client.

Based on the above embodiment, the embodiment of the present application further provides a storage node. The storage node may be a storage node in the distributed storage system shown in FIG. 2. Referring to FIG. 5, the storage node 500 includes a communication unit 501, and the communication unit includes a first storage unit 5011, wherein the first storage unit is a non-volatile memory. among them,

The communication unit 501 is configured to receive a first write request, where the first write request carries first data to be stored, and caches the first write request in the first storage unit 5011; Transmitting a first write request to at least one slave node to be stored, wherein the first node is a master node to store the first data; and receiving the first one returned by the at least one slave node Cache success message, the first cache success message is used to indicate that the at least one slave node has successfully cached the first write request; and return a success response message to the client, where the success response message is used to indicate the first a data has been stored in the primary node of the first data to be stored and the at least one secondary node;

The first storage unit 5011 is configured to cache the first write request.

Optionally, the first write request further includes an identifier of the data object to which the first data belongs, and the communication unit 501 is further configured to:

Before the first write request is sent to the at least one slave node to be stored, the identifier of the data object is calculated according to a set data distribution algorithm, and multiple stores storing the data object are obtained. a node, wherein the plurality of storage nodes storing the data object comprise the first node;

Determining, according to the set primary node selection rule, that the first node is a primary node that stores the data object, and determining another storage node other than the first node of the multiple storage nodes that store the data object A slave node for storing the data object.

Optionally, the first node 500 further includes: a processing unit 502 and a second storage unit 503, where the second storage The storage unit 503 is a nonvolatile memory, wherein

The processing unit 502 is configured to read the first write request from the first storage unit 5011; and write the first data into the second storage unit according to the first write request And the data object corresponding to the identifier of the data object;

The second storage unit 503 is configured to store the data object.

Optionally, the processing unit 502 is further configured to: after the first data is written to the data object in the second storage unit 503 according to the first write request, to the communication unit 501 Transmitting a space release message, where the space release message includes an identifier of the data object;

The communication unit 501 is further configured to delete the first write request in the first storage unit 5011 according to the identifier of the data object.

Optionally, the communication unit 501 is further configured to receive a second write request, where the second write request carries second data to be stored, and cache the second write request in the first storage unit And sending a second cache success message to the target storage node in the distributed storage system, where the second cache success message is used to indicate that the first node has successfully cached the second write request, where The storage node is a slave node of at least one slave node to be stored, and the target storage node is a master node to store the second data;

The first storage unit 5011 is further configured to cache the second write request.

With the storage node of the embodiment of the present application, after the network card in the storage node determines that the storage node and at least one slave node that is to store the first data have successfully cached the first write request including the first data, That is, a success response message is returned to the client. Therefore, the storage node can not only reduce the time consumed by the storage node to save the first data in the time when the distributed storage system responds to the client, but also reduce the saving of the first data by the slave node. The time consumed, thereby minimizing the time that the distributed storage system responds to the client with the first write request.

It should be noted that the division of the unit in the embodiment of the present application is schematic, and is only a logical function division. In actual implementation, there may be another division manner. The functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit.

Based on the above embodiments, the embodiment of the present application further provides a computer storage medium, where the software program stores a software program, and the software program can implement the data provided by the foregoing embodiment when being read and executed by one or more processors. Storage method. The computer storage medium may include: a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, and the like, which can store program codes. medium.

Based on the above embodiments, the embodiment of the present application further provides a computer program product including instructions, which when executed on a computer, causes the computer to execute the data storage method provided by the foregoing embodiment.

Based on the above embodiment, the embodiment of the present application further provides a storage device, which is a storage node in the distributed storage system shown in FIG. 2 . Referring to FIG. 6, the storage device 600 includes an interface card 601, and the interface card further includes a first memory 6011. The first memory 6011 is a non-volatile memory.

The first memory 6011 is configured to cache a write request received by the interface card 601.

The interface card 601 is used to implement the data storage method as shown in FIG. 3, including:

Receiving a first write request, where the first write request carries first data to be stored;

Caching the first write request in the first memory 6011;

Sending the first write request to at least one slave node of the distributed storage system to be stored, where the storage device is the first data to be stored in the distributed storage system Primary node

Receiving, by the at least one slave node, a first cache success message, where the first cache success message is used to indicate that the at least one slave node has successfully cached the first write request;

Returning a success response message to the client, the success response message is used to indicate that the first data has been stored in a primary node and the at least one secondary node that are to store the first data.

Optionally, the first write request further includes an identifier of the data object to which the first data belongs, and the interface card 601 is further configured to:

Before the first write request is sent to the at least one slave node to be stored, the identifier of the data object is calculated according to a set data distribution algorithm, and multiple stores storing the data object are obtained. a node, wherein the plurality of storage nodes storing the data object comprise the storage device;

Determining, according to the set primary node selection rule, the storage device as a primary node storing the data object, and determining that other storage nodes other than the storage device of the plurality of storage nodes storing the data object are stored The slave node of the data object.

Optionally, the storage device 600 further includes a processor 602 and at least one memory 603, where the at least one memory includes a second memory 603, and the second memory 603 is a non-volatile memory, where

The processor 602 is configured to read the first write request from the first memory 6011, and write the first data into the second memory 603 according to the first write request. The data object corresponding to the identifier of the data object;

The second memory 603 is configured to store the data object.

Optionally, the processor 602 is further configured to send the first data to the interface card 601 after the first data is written to the data object in the second memory 603 according to the first write request. a space release message, wherein the space release message includes an identifier of the data object;

The interface card 601 is further configured to delete the first write request in the first memory 6011 according to the identifier of the data object.

Optionally, the interface card 601 is further configured to:

Receiving a second write request, where the second write request carries the second data to be stored;

Caching the second write request in the first memory 6011;

Sending a second cache success message to the target storage node in the distributed storage system, where the second cache success message is used to indicate that the storage device has successfully cached the second write request, where the storage device 600 And being a slave node of the at least one slave node that is to store the second data, where the target storage node is a master node to store the second data.

The at least one memory 603 is configured to store program instructions and the like. In particular, program instructions may include program code, the program code including computer operating instructions. The at least one memory 603 may include RAM and may also include non-volatile memory, such as at least one disk storage. The processor 602 executes the program instructions stored in the memory 1203, and writes the first data into the data object in the second memory 603, thereby implementing the data storage method provided by the foregoing embodiment.

With the storage node of the embodiment of the present application, the interface card in the storage node determines that the storage node and the at least one slave node that is to store the first data have successfully cached the first write request including the first data. , which returns a success response message to the client. Therefore, the storage node can not only reduce the response of the distributed storage system Determining the time consumed by the storage node to save the first data in the time of the client, and reducing the time consumed by the slave node to save the first data, thereby minimizing the distributed storage system The time at which the client responds to the first write request.

Based on the foregoing embodiment, the embodiment of the present application further provides a distributed storage system, where the distributed storage system includes multiple storage nodes, each storage node includes a network card, and the network card includes a first memory. The first memory is a non-volatile memory, wherein

a network card in the first node 701, configured to receive a write request, where the write request carries data to be stored; and cache the write request in a first memory in the first node 701; The write request is sent to the second node 702, wherein the first node 701 and the second node 702 are storage nodes of the plurality of storage nodes, and the first node 701 is a host to store the data. a node, the second node 702 being a slave node to store the data;

The network card in the second node 702 is configured to receive the write request, cache the write request in a first memory in the second node 702, and send a cache success to the first node 701. a message, the cache success message is used to indicate that the second node 702 has successfully cached the write request;

The network card in the first node 701 is further configured to receive a cache success message returned by the second node 702, and return a success response message to the client, where the success response message is used to indicate that the data has been stored in the The primary node and the secondary node of the data to be stored.

Optionally, the write request further includes an identifier of the data object to which the data belongs, and the network card in the first node 701 is further configured to:

Before transmitting the write request to the second node 702, calculating an identifier of the data object according to a set data distribution algorithm, obtaining a plurality of storage nodes storing the data object, wherein storing the data object The plurality of storage nodes include the first node 701 and the second node 702;

Determining, according to the set primary node selection rule, the first node 701 is a primary node storing the data object, and determining that the second node 702 is a secondary node that stores the data object.

Optionally, each storage node further includes a processor and a second memory, where the second memory is a non-volatile memory; in this case, the processor in the first node 701 is used to Reading the write request in the first memory in the first node 701, and writing the data into the second memory in the first node 701 according to the write request, where the data object identifier corresponds In the data object;

a processor in the second node 702, configured to read the write request from a first memory in the second node 702, and write the data into the second according to the write request In the second memory in the node 702, the data object identifier is in the data object corresponding to the data object.

Optionally, the processor in the first node 701 is further configured to: after the data is written into the data object in the second memory in the first node 701, to the first node 701 The network card in the medium sends a space release message, where the space release message includes an identifier corresponding to the data;

The network card in the first node 701 is further configured to delete the write request in the first memory in the first node 701 according to the identifier of the data object;

The processor in the two nodes is further configured to send a space release to the network card in the second node 702 after the data is written into the data object in the second memory in the second node 702. a message, where the space release message includes an identifier corresponding to the data;

The network card in the second node 702 is further configured to delete the second node 702 according to the identifier of the data object. The write request in the first memory.

In the distributed storage system, after determining that the first node and the second node have successfully cached the write request including the data to be stored, the network card in the first node returns a success response message to the client. Therefore, the method can not only reduce the time consumed by the distributed storage system to save the data by the first node in response to the time of the client, but also reduce the consumption of saving the data by the second node. Time, thereby minimizing the time that the distributed storage system responds to the write request to the client.

Those skilled in the art will appreciate that embodiments of the present application can be provided as a method, system, or computer program product. Thus, the present application can take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment in combination of software and hardware. Moreover, the application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) including computer usable program code.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (system), and computer program products according to embodiments of the present application. It will be understood that each flow and/or block of the flowchart illustrations and/or FIG. These computer program instructions can be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing device to produce a machine for the execution of instructions for execution by a processor of a computer or other programmable data processing device. Means for implementing the functions specified in one or more of the flow or in a block or blocks of the flow chart.

The computer program instructions can also be stored in a computer readable memory that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer readable memory produce an article of manufacture comprising the instruction device. The apparatus implements the functions specified in one or more blocks of a flow or a flow and/or block diagram of the flowchart.

These computer program instructions can also be loaded onto a computer or other programmable data processing device such that a series of operational steps are performed on a computer or other programmable device to produce computer-implemented processing for execution on a computer or other programmable device. The instructions provide steps for implementing the functions specified in one or more of the flow or in a block or blocks of a flow diagram.

Claims (14)

1. A data storage method, wherein the method is applied to a distributed storage system, where the distributed storage system includes a plurality of storage nodes, and a first node of the plurality of storage nodes includes a network card, and the network card A first memory is included, the first memory is a non-volatile memory, and the method includes:

   Receiving, by the network card, a first write request, where the first write request carries the first data to be stored;

   The network card caches the first write request in the first memory;

   Sending, by the network card, the first write request to at least one slave node that is to be used to store the first data, where the first node is a master node to store the first data;

   Receiving, by the network card, the first cache success message returned by the at least one slave node, where the first cache success message is used to indicate that the at least one slave node has successfully cached the first write request;

   The network card returns a success response message to the client, where the success response message is used to indicate that the first data has been stored in the primary node to be stored and the at least one secondary node.
2. The method according to claim 1, wherein the first write request further includes an identifier of the data object to which the first data belongs, and the first write request is sent to the to-be-stored place by the network card Before the at least one slave node of the first data, the method further includes:

   The network card calculates the identifier of the data object according to the set data distribution algorithm, and obtains a plurality of storage nodes that store the data object, wherein the plurality of storage nodes storing the data object include the first node;

   Determining, by the network card, the first node as a primary node storing the data object according to the set primary node selection rule, and determining, among the plurality of storage nodes storing the data object, other than the first node The other storage nodes are slave nodes that store the data objects.
3. The method of claim 2, wherein the first node further comprises a processor and a second memory, the second memory is a non-volatile memory, the method further comprising:

   The processor reads the first write request from the first memory;

   The processor writes the first data into the data object corresponding to the identifier of the data object in the second memory according to the first write request.
4. The method according to claim 3, wherein after the processor writes the first data to the data object in the second memory according to the first write request, the method further include:

   The processor sends a space release message to the network card, where the space release message includes an identifier of the data object;

   The network card deletes the first write request in the first memory according to the identifier of the data object.
5. The method according to any one of claims 1 to 4, further comprising:

   The network card receives a second write request, where the second write request carries the second data to be stored;

   The network card buffers the second write request in the first memory;

   Sending, by the network card, a second cache success message to a second one of the plurality of storage nodes, where the second cache success message is used to indicate that the first node has successfully cached the second write request, where The first node is a slave node of at least one slave node to be stored, and the second node is a master node to store the second data.
6. A storage device, wherein the storage device is a storage node in a distributed storage system, the distributed storage system includes a plurality of storage nodes, and the storage device includes an interface card, where the interface card is Including a first memory, the first memory is a non-volatile memory, wherein

   The interface card is used to:

   Receiving a first write request, where the first write request carries first data to be stored;

   Caching the first write request in the first memory;

   Sending the first write request to at least one slave node of the distributed storage system to be stored, where the storage device is the first data to be stored in the distributed storage system Primary node

   Receiving, by the at least one slave node, a first cache success message, where the first cache success message is used to indicate that the at least one slave node has successfully cached the first write request;

   Returning a success response message to the client, where the success response message is used to indicate that the first data has been stored in a primary node and the at least one secondary node that are to store the first data;

   The first memory is configured to cache the first write request.
7. The storage device according to claim 6, wherein the first write request further includes an identifier of the data object to which the first data belongs, and the interface card is further configured to:

   Before the first write request is sent to the at least one slave node to be stored, the identifier of the data object is calculated according to a set data distribution algorithm, and multiple stores storing the data object are obtained. a node, wherein the plurality of storage nodes storing the data object comprise the storage device;

   Determining, according to the set primary node selection rule, the storage device as a primary node storing the data object, and determining that other storage nodes other than the storage device of the plurality of storage nodes storing the data object are stored The slave node of the data object.
8. The storage device according to claim 7, wherein the storage device further comprises: a processor and a second memory, wherein the second memory is a non-volatile memory, wherein

   The processor, configured to read the first write request from the first memory, and write the first data into the second memory and the data according to the first write request The data object corresponding to the identifier of the object;

   The second memory is configured to store the data object.
9. A storage device according to claim 8 wherein:

   The processor is further configured to send a space release message to the interface card after the first data is written to the data object in the second memory according to the first write request, where The space release message includes an identifier of the data object;

   The interface card is further configured to delete the first write request in the first memory according to the identifier of the data object.
10. The storage device according to any one of claims 6-9, wherein the interface card is further configured to:

    Receiving a second write request, where the second write request carries the second data to be stored;

    Caching the second write request in the first memory;

    Sending a second cache success message to the target storage node in the distributed storage system, where the second cache success message is used to indicate that the storage device has successfully cached the second write request, where the storage device is a slave node of the at least one slave node of the second data to be stored, where the target storage node is a master node of the distributed storage system to store the second data;

    The first memory is further configured to cache the second write request.
11. A distributed storage system, wherein the distributed storage system includes a plurality of storage nodes, each storage node includes a network card, the network card includes a first memory, and the first memory is a nonvolatile Sexual storage Device, among them,

    a network card in the first node, configured to receive a write request, where the write request carries data to be stored; and cache the write request in a first memory in the first node; and the write request Sending to the second node, where the first node and the second node are storage nodes of the plurality of storage nodes, the first node is a primary node to store the data, and the second node The node is a slave node to which the data is to be stored;

    a network card in the second node, configured to receive the write request, cache the write request in a first memory in the second node, and send a cache success message to the first node, where The cache success message is used to indicate that the second node has successfully cached the write request;

    The network card in the first node is further configured to receive a cache success message returned by the second node, and return a success response message to the client, where the success response message is used to indicate that the data has been stored in the to-be-stored The primary node and the secondary node of the data.
12. The system of claim 11, wherein the write request further includes an identifier of the data object to which the data belongs, and the network card in the first node is further configured to:

    Before the sending the request to the second node, calculating the identifier of the data object according to the set data distribution algorithm, obtaining a plurality of storage nodes storing the data object, wherein storing the data object Storage nodes include the first node and the second node;

    Determining, according to the set primary node selection rule, that the first node is a primary node that stores the data object, and determining that the second node is a secondary node that stores the data object.
13. The system of claim 12, further comprising a processor and a second memory in each of the storage nodes, the second memory being a non-volatile memory.

    a processor in the first node, configured to read the write request from a first memory in the first node, and write the data into the first node according to the write request In the second memory, the data object identifier corresponds to the data object;

    a processor in the second node, configured to read the write request from a first memory in the second node, and write the data into the second node according to the write request In the second memory, the data object identifier is in the data object corresponding to the data object.
14. The system of claim 13 wherein:

    The processor in the first node is further configured to send a space release message to the network card in the first node after the data is written into the data object in the second memory in the first node The space release message includes an identifier corresponding to the data;

    The network card in the first node is further configured to delete the write request in the first memory in the first node according to the identifier of the data object;

    The processor in the two nodes is further configured to send a space release message to the network card in the second node after the data is written into the data object in the second memory in the second node, The space release message includes an identifier corresponding to the data.

    The network card in the second node is further configured to delete the write request in the first memory in the second node according to the identifier of the data object.

Images