Object processing method

Abstract

The embodiment of the present specification provides an object processing method, wherein the object processing method is applied to a network communication module of a server, comprising: receiving an object processing request sent by a client for a target object, and determining a request type corresponding to the object processing request; in the case of determining that the request type is a read request type, determining a target object from an object storage module in response to the object processing request; reading target data from the target object based on data identification information carried in the object processing request, and sending the target data to the client. Avoids the CPU of the server from consuming computing resources to process the request, improves the operation efficiency of the CPU, reduces, and ensures that the target object is processed quickly, improves the processing performance of the target object.

Description

TECHNICAL FIELD

[0001] Embodiments of the present specification relate to the technical field of computer technology, and particularly relate to an object processing method. BACKGROUND

[0002] With the continuous development of computer technology, since skip list (a kind of data structure) has good scalability and other characteristics, it is widely used in the field of data storage, for example, applied to distributed storage system.

[0003] In the client-server design of the prior art, the server is mainly responsible for processing operations on the skip list, and the client only sends processing requests and receives messages returned from the server. In particular, when the concurrency of the processing operation on the skip list is very high, the CPU of the server needs to consume a large amount of computing resources for processing, which reduces the operation efficiency of the CPU and further reduces the performance of the skip list. SUMMARY

[0004] Therefore, the embodiments of the present specification provide an object processing method. One or more embodiments of the present specification also relate to an object processing apparatus, a computing device, a computer-readable storage medium, and a computer program to solve the technical defects in the prior art.

[0005] According to a first aspect of the embodiments of the present specification, an object processing method is provided, applied to a network communication module of a server, comprising:

[0006] receiving an object processing request sent by a client for a target object, and determining the request type corresponding to the object processing request;

[0007] In the case where the request type is determined to be a read request type, the target object is determined from the object storage module in response to the object processing request;

[0008] Based on the data identification information carried in the object processing request, target data is read from the target object, and the target data is sent to the client.

[0009] According to a second aspect of the embodiments of the present specification, an object processing method is provided, applied to a server, the server comprising a network communication module and an operation control module, wherein,

[0010] The network communication module receives an object processing request sent by a client for a target object, and in the case where the request type corresponding to the object processing request is determined to be a read request type, the target object is determined from the object storage module in response to the object processing request, the target data is read from the target object based on the data identification information carried in the object processing request, and the target data is sent to the client.

[0011] In a case where the request type is determined as the write request type, the object processing request is sent to the operation control module.

[0012] The operation control module receives the object processing request sent by the network communication module, and processes the target object in response to the object processing request.

[0013] According to a third aspect of the embodiments of the present specification, an object processing apparatus applied to a network communication module of a server is provided, comprising:

[0014] The receiving module is configured to receive an object processing request sent by a client for a target object, and determine a request type corresponding to the object processing request;

[0015] The determining module is configured to, in a case where the request type is determined as the read request type, determine a target object from an object storage module in response to the object processing request;

[0016] The reading module is configured to read target data from the target object based on data identification information carried in the object processing request, and send the target data to the client.

[0017] According to a fourth aspect of the embodiments of the present specification, a computing device is provided, comprising:

[0018] a memory and a processor;

[0019] The memory is configured to store computer executable instructions, and the processor is configured to execute the computer executable instructions, and the computer executable instructions, when executed by the processor, implement the steps of the object processing method.

[0020] According to a fourth aspect of the embodiments of the present specification, a computer readable storage medium is provided, which stores computer executable instructions, and the computer executable instructions, when executed by a processor, implement the steps of the object processing method.

[0021] According to a fifth aspect of the embodiments of the present specification, a computer program is provided, wherein when the computer program is executed in a computer, the computer is caused to execute the steps of the object processing method.

[0022] The object processing method provided in the specification is applied to a network communication module of a server, and includes: receiving an object processing request sent by a client for a target object, and determining a request type corresponding to the object processing request; in a case where it is determined that the request type is a read request type, determining a target object from an object storage module in response to the object processing request; reading target data from the target object based on data identification information carried in the object processing request, and sending the target data to the client.

[0023] Specifically, the network communication module to which the method is applied, in a case where it is determined that the request type of the received object processing request is a read request type, directly reads target data from a target object in response to the object processing request, and sends the target data to the client, avoiding the need for the CPU of the server to consume computing resources to process the request, improving the operation efficiency of the CPU, reducing, and ensuring fast processing of the target object, improving the performance of the target object. BRIEF DESCRIPTION OF DRAWINGS

[0024] Figure 1 is an application scenario diagram of an object processing method provided by an embodiment of the specification;

[0025] Figure 2 is a diagram of a skip list node in an object processing method provided by an embodiment of the specification;

[0026] Figure 3 is a flowchart of an object processing method provided by an embodiment of the specification;

[0027] Figure 4 is a flowchart of another object processing method provided by an embodiment of the specification;

[0028] Figure 5 is a diagram of application effects of an object processing method provided by an embodiment of the specification;

[0029] Figure 6 is a structural diagram of an object processing device provided by an embodiment of the specification;

[0030] Figure 7 is a structural block diagram of a computing device provided by an embodiment of the specification. DETAILED DESCRIPTION

[0031] In the following description, many specific details are set forth in order to provide a thorough understanding of the specification. However, the specification can be practiced in many different ways beyond the specific embodiments described herein, and it is understood that persons having ordinary skill in the art can make similar modifications to the specific embodiments disclosed without departing from the spirit of the specification.

[0032] The terminology used in this disclosure one or more embodiments is for the purpose of describing particular embodiments only and is not intended to be limiting of this disclosure one or more embodiments. As used in this disclosure one or more embodiments and the accompanying claims, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises" and / or "comprising," when used in this disclosure one or more embodiments, specify the presence of stated features, integers, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0033] It will be understood that, although the terms first, second, etc. can be used herein to describe various information, these terms are not intended to denote a temporal or chronological order. Rather, these terms are used solely to distinguish one from another only. For example, without departing from the scope of this disclosure one or more embodiments, first can be termed second, and, similarly, second can be termed first. Depending on the context, the word "if' as used herein can be interpreted to mean "when" or "in response to determining" or "in response to a determination."

[0034] First, the noun terms related to this disclosure one or more embodiments are explained.

[0035] RDMA: Remote Direct Memory Access.

[0036] RNIC: Network Interface Card capable of supporting RDMA.

[0037] SkipList: Skip List.

[0038] HybridSkipList: Skip List with single / double sided hybrid mode.

[0039] MOPS: CPU's arithmetic speed.

[0040] crc64: Cyclic Redundancy Check.

[0041] DRTM: Dynamic Root of Measurement.

[0042] HTM: Hyper Text Mark-up Language.

[0043] R-tree: R-tree, another form of B-tree developed for multi-dimensional space.

[0044] Cell: Cell array.

[0045] SkipListMap: Map collection based on Skip List structure.

[0046] SkipList is a sorted data structure that supports methods such as Insert, Contain, and Remove with O(l) complexity. These operations on SkipList can be performed in O(logN) (assuming there are N nodes in SkipList). From another perspective, SkipList is composed of a hierarchy of linked lists, which behaves like a probabilistic data structure. Each node is created with a random level and exists in all levels up to its highest level. The length of each linked list can decrease from the bottom to the top with a probability p (e.g., 0.5).

[0047] SkipList has an important property: higher-level lists are always contained in lower-level lists. And another core feature is that each node in SkipList is adjacent to its predecessor and successor at the data structure level, but the current node and predecessor / successor are usually not in the same memory area, so traversing the nodes in the SkipList will always cause expensive random memory access.

[0048] In practical applications, to support concurrent access, SkipList can be further subdivided into an easy-to-understand, lock-based implementation, and a complex lock-free implementation. With the increasing demand for large-scale data, distributed data structures have become an indispensable part of modern systems. Distributed hash tables, distributed b-trees, and other systems are widely used in databases and key-value stores due to their capacity expansion. However, in the research field, there are few works discussing distributed SkipList and the performance gap between SkipList and RDMA. In distributed SkipList, the main overheads come from the network (i.e., RDMA) and the server-side CPU (i.e., data structure operations). Referring to Table 1, Table 1 compares the throughput between RDMA one-sided read / write access and two SkipList methods: Contain and Insert. It is worth noting that the most advanced implementation of SkipList is used here.

[0049] Table 1

[0050] Type Read / Contain Write / Insert RDMA (Connext X-3, 40Gbps) 6.2MOPS 6.5MOPS RDMA (Connext X-5, 100Gbps) 14.7MOPS 14.5MOPS SkipList (single thread) 0.39MOPS 0.50MOPS SkipList (20 threads) 2.6MOPS 2.4MOPS

[0051] Among them, the Type column includes different types of methods, that is, RDMA one-sided read / write access and two SkipList methods, ConnextX-3 and ConnextX-5 are different types of network cards that support RDMA; Gbps refers to the switching bandwidth; single thread refers to single thread, and 20 threads refers to 20 threads, that is, multi-thread.

[0052] The results according to Table 1 show that there is a significant performance gap between SkipList and RDMA (2.4 to 34 times), which proves that the bottleneck of distributed SkipList is CPU, not network.

[0053] Based on this, many studies abandon the traditional RPC, trying to use the one-way operation provided by RDMA to completely bypass the server CPU. For example, a scheme is: to allow its client to read data directly from the server memory through RDMA-read (RDMA-based read operation) to get the Get request. The client uses CRC64 to check the potential competition of the Put operation on the server, resulting in data inconsistency.

[0054] A scheme is to provide a distributed memory platform that implements Hopscotch Hashing with one-sided operation. DRTM builds a transactional hash table that supports transaction processing by using HTM and RDMA, and the scheme also uses one-way operation with cluster hash.

[0055] A scheme is to provide an R-tree index data structure (such as Catfish) based on one-sided and two-sided RDMA operations, which uses RDMA read operation for R-tree traversal, and Cell implements B-tree index data structure and prefetches a B-tree node at a time.

[0056] A scheme is to provide a concurrent SkipListMap scheme, which is a widely used SkipList implementation, which is lock-free.

[0057] At the same time, a lock-based algorithm can also be used, which uses optimistic locks and lazy lock deletion nodes to perform deletion operations.

[0058] However, the above schemes all have more or less defects, based on this, the object processing method provided by the present application provides a distributed skip list based on a hybrid RDMA mode, and the object processing method provided by the present application proposes a SkipList based on RDMA and using one-sided / two-sided hybrid communication strategy. While using RDMA as the underlying transmission, the retry lock-based is selected to provide more performance gain; the scheme takes into account that the competition of write operation is very fierce, so it combines one-sided read operation and two-sided write operation. Moreover, the HybridSkipList (distributed skip list based on hybrid RDMA mode) uses retry lock-based concurrency control, and the server side is responsible for handling concurrency to reduce the expensive network round-trip overhead. Because the use of one-sided operation can avoid the participation of server CPU, the data structure operation only needs to occupy a very small part of server CPU time, thereby reducing the CPU occupancy rate and improving the CPU processing efficiency.

[0059] Specifically, in the present specification, two object processing methods are provided, and the present specification also relates to an object processing method, a computing device, a computer-readable storage medium and a computer program, which are described in detail one by one in the following embodiments.

[0060] Figure 1 An application scenario diagram of an object processing method provided according to one embodiment of the present specification is shown, see Figure 1 The HybridSkipList provided by the present specification adopts a hybrid strategy for data structure operation. The client 104 will perform a read operation in a single-sided manner and a write operation in a double-sided manner. Specifically, the object processing method provided by the present specification will introduce how to implement five basic methods: Find, Contain, Insert, Update and Remove. Among them, the read operation can include methods such as Find (query) and Contain (contain), and the write operation can include methods such as Insert (insert), Update (update) and Remove (eliminate). In particular, the Find and Contain methods are designed in a hybrid mode of single-sided and double-sided, which can be executed by the client 104 or the server. The double-sided mode is the same as the general client 104-server RPC method, which can be referred to any kind of client 104-server RPC method.

[0061] Specifically, the client 104 can send an RDMA read request to the RNIC of the server 102, and the RNIC determines the corresponding skip list from the memory of the server 102 in response to the RDMA read request, so that the read operation on the skip list can be performed without the server (i.e. the server) being aware. At the same time, the client 104 can send a write request to the RNIC of the server 102, and perform a write operation on the skip list in the memory through the method of double-sided interaction between the client 104 and the server 102.

[0062] Among them, the execution mode of the Find method is:

[0063] The client 104 sends a Find request to the network card of the server 102 through the network card, and the Find request carries a key. Based on this, the network card of the server 102 obtains the key carried in the request. Then, the network card determines a plurality of nodes included in the skip list and obtains the key stored in each node. Match the two, and in the case of consistent matching result, the node corresponding to the key matching the key carried in the Find request is determined as the target node. And the node identifier of the target node is sent to the client 104, so as to complete the query work for the target node, and the CPU of the server 102 is not involved throughout the process.

[0064] The execution manner of the Contain method is as follows:

[0065] The client 104 sends a Contain request to the network card of the server 102 through the network card, and the Contain request carries a key. Based on this, the network card obtains the key carried in the request. Then, the network card determines the plurality of nodes included in the skip list and obtains the key stored in each node. The two are matched. In the case of consistent matching results, the node corresponding to the key matching the key carried in the Contain request is determined as the target node, and the key corresponding data is obtained from the target node, and the key corresponding data is sent to the client 104, without the participation of the CPU of the server 102.

[0066] That is, the Contain method reads the target key-value pair from the SkipList, and returns null if not found. This method does not need to wait.

[0067] In addition, in the process of sending data to the client 104 by the network card, in order to avoid the problem that the data sent to the client 104 is not the latest data. The network card can obtain the version number carried in the data, and obtain the version number from the node corresponding to the key-value pair. Then judge whether the two version numbers are consistent (that is, the version number is even and the same as the first observation value), if yes, determine that the key-value pair is the latest data, then send the key-value pair to the client 104.

[0068] If not, it is determined that the key-value pair is not the latest data, and the Contain operation is re-executed until the data is valid (the data is the latest data).

[0069] The execution manner of the Insert method is as follows:

[0070] The client 104 sends an Insert request for the skip list to the server 102, and the server 102 network card sends the Insert request to the server 102 CPU after receiving the Insert request.

[0071] In the process of executing the Insert operation, the CPU of the server 102 first calls the Find method to obtain the predecessor node and the successor node. Secondly, lock the predecessor (i.e. the predecessor node) in ascending order and verify whether the predecessor node is still connected to the successor node. If not, it is determined that the verification fails, and in the case of verification failure, the server 102 will release the lock and retry from the beginning of the Find method.

[0072] If yes, it is determined that the verification is successful, and the lock is acquired in the case of successful verification. After the lock is acquired, the server 102 will start a new node and complete the pointer chasing, and set the FullyLinked flag to true. That is, a new node is inserted in the predecessor node and the successor node, and the pointer of the predecessor node to the successor node is pointed to the new node. The pointer of the successor node to the predecessor node is pointed to the new node; thereby realizing the insertion of the node.

[0073] The execution mode of the Update method is as follows:

[0074] The client 104 sends an Update request for the skip list to the server 102, and the server 102 network card sends the Update request to the server 102 CPU after receiving the Update request.

[0075] The server 102 responds to the Update request, first calls the Find method to locate the target node and lock the node. Then it increases the version number to an odd number, performs the update (i.e. performs the data update operation for the key-value pair in the node), and after the update is completed, increases the version number to an even number.

[0076] The execution mode of the Remove method is as follows:

[0077] The client 104 sends a Remove request for the skip list to the server 102, and the server 102 network card sends the Remove request to the server 102 CPU after receiving the Remove request.

[0078] The server 102 first calls the Find method to locate the node to be updated. If the node is found, it checks whether the node is ready to be removed, wherein the FullyLinked flag of the node to be updated is true, and the Removed flag of the node to be updated is false. If the node can be deleted, it will be logically deleted by setting the Removed flag from false to true. Then physical deletion will be performed.

[0079] In addition, it should be noted that after the above read request and write request are executed, they are all controlled by retry lock for concurrency, so that in the case where it is determined that the data structure node is modified, the read / write operation should be retried, thereby avoiding the problem of excessive network round trip overhead between the server 102 and the client 104 caused by the problem of reading the latest data by the read request or the problem of writing error by the write request due to concurrent operation.

[0080] Further, in the embodiments provided in the present specification, the single-sided based Find / Contain (read) method, i.e. read operation, requires more RDMA operations than the double-sided based Insert / Update / Remove (write) method, i.e. write operation. In some cases, the Read method dominates and thus the bandwidth of RDMA is already saturated (i.e. bound by RDMA rather than CPU). To solve this problem, the object processing method provided in the present specification further proposes a mechanism to dynamically switch between the two communication paradigms. The server 102 monitors the inbound network traffic and if the maximum throughput threshold (obtained using profiling tools) is exceeded, the server 102 informs several randomly selected clients 104 to switch the read operation to the two-way RPC mode.

[0081] In the embodiments provided in the present specification, due to the natural characteristics of SkipList, the consistency of data can be guaranteed. Therefore, in order to distribute the SkipList to multiple servers, a specific partitioning method (for example, key-hashing partitioning method) can be used to split the SkipList and assign partitions to designated servers. Specifically, each server can occupy multiple partitions, and if the workload is skewed, each partition can be dynamically migrated to another server. Compared with tree data structures that require complex node splitting / merging and spinning, SkipList is suitable for division into multiple partitions. Each partition will be a separate SkipList and store elements whose keys are within a specific range. The mapping between partitions and servers is known to both the server side and the clients 104. If each server has fewer partitions, in order to achieve load balancing, the head or tail part of a partition can be migrated to another partition, where the server can be understood as the server 102.

[0082] In addition, it should be noted that in the embodiments provided in the present specification, the object processing method provided in the present specification proposes a data structure HybridSkipList, which contains multiple nodes, wherein the format of the node is as shown in Figure 2 Figure 2 is a schematic diagram of a skip list node in an object processing method provided in an embodiment of the present specification.

[0083] Referring to Figure 2 , Figure 2 ​The format of a node in the data structure HybridSkipList is shown. Among them, Version is the necessary version number in the skip list; Level is the level number of the skip list; the skip list stores data in the form of key-value pairs, based on which the key is the key in the key-value pair, and the Data is the data corresponding to the key; Pointer[Level] is a pointer to the next node. Flag is used to store the corresponding control information.

[0084] In addition, each node is also composed of four auxiliary flags at the tail of the node. Respectively, Lock, FullLinked, Removed, Polling. These flags can maintain the properties of the SkipList. Specifically, the lock (Lock) is used to prevent the structure near the node from being changed when inserting or deleting the node, and to prevent any access to the node until it is inserted or deleted from all levels of the list.

[0085] In practical applications, in order to handle concurrency control, the object processing method provided in the description uses a retry lock, which uses an optimistic approach to read operations (for example, Find, Contain) on the data structure. The core idea is not to prevent concurrent modification of the data structure node, but to optimistically assume that the data structure node has not been modified. After the read operation is completed, if the data structure node is modified, the read operation should be retried. In the format of HybridSkipList, the version number is at the tail of the node, supporting the update method. This number can help check the modification of the value during the read operation. When the update method is executed, it will immediately lock the node to be modified. Then, it will increase the version number to an odd number, perform the update, and increase the version number to an even number, wherein the increment operation is atomic. And after the value is modified, the cache is flushed to the main memory based on the memory barrier. If the RDMA read operation is interleaved with local modifications, it will see an odd value, indicating that the read operation must be retried. Only when the version number is observed to be even and checked to be the same as the first observed value, it can successfully read the value, otherwise it means a failed attempt.

[0086] FullLinked is used to show whether a node has been connected in all its levels. If a node has been connected in all its levels, FullLinked is true, otherwise it is false. Before full connection, no read or write operation is allowed on the node.

[0087] Removed is used to show whether a node can be deleted. When a node is marked, it is logically deleted. If a node is logically deleted, Removed is true, otherwise it is false.

[0088] Polling is a polling flag.

[0089] Among them, the four attributes of version number, pointer, level number and auxiliary field are less than 8 bytes (Byte), respectively: version number is 28 Bits, pointer is 4 Bytes, level number is 2 Bytes and auxiliary field is 1 Bit. Therefore, the client can retrieve them through the RDMA read operation. In order to improve the performance, the object processing method provided in the specification applies selective signals to the RDMA operation. Even without signals, the client can know that the read operation has been completed by detecting the tail polling flag (Polling) change to 1 (RDMA write operation guarantees to write data in sequence).

[0090] Based on this, the object processing method provided in the specification proposes a SkipList based on RDMA and using a single / double hybrid communication strategy (HybridSkipList). While using RDMA as the underlying transmission, the retry-based lock is selected to provide more performance gain. At the same time, the scheme takes into account that the competition of write operation is very fierce, so it combines single read operation and double write operation.

[0091] In addition, HybridSkipList uses lock-based concurrency control, which is responsible for handling concurrency on the server side to reduce the expensive network round-trip overhead. Because using single operation can avoid the participation of server CPU, data structure operation only needs to occupy a very small part of server CPU time.

[0092] Figure 3 A flowchart of an object processing method according to an embodiment of the specification is shown, which is applied to a network communication module of a server, and specifically includes the following steps.

[0093] Step 302: receiving an object processing request sent by a client for a target object, and determining the request type corresponding to the object processing request.

[0094] Among them, the network communication module can be understood as a module for network communication in the server, such as a network card. In the object processing method provided in the specification, the network is a network card (RNIC) that performs RDMA.

[0095] The target object can be understood as an object capable of storing data, for example, a skip list in a server memory, a linked list in a server, a two-dimensional table in a server, and the like. The object processing request can be understood as a request capable of processing the target object; in the case of a skip list as the target object, the object processing request can be understood as a read request (for example, Find, Contain, and the like) for a read operation on the skip list, or the object processing request can be understood as a write request (for example, Insert, Update, Remove, and the like) for a write operation on the skip list. Accordingly, the request type can be understood as the type corresponding to the request, for example, the request is a read request type, or a write request type.

[0096] Specifically, the object processing method provided in the present specification is applied to a network communication module of a server. Based on this, the client can send an object processing request to the network communication module in the server through the network communication module configured by itself. The network communication module receives the object processing request sent by the client and determines the type of the object processing request.

[0097] The following takes the application of the object processing method provided in the present specification in the distributed skip list scenario based on the hybrid RDMA mode as an example to further illustrate the network communication module receiving the object processing request sent by the client to the target object and determining the corresponding request type. The target object can be a skip list, which can be referred to the description of HybridSkipList above, and will not be described here. The network communication module can be a network card supporting RDMA. The object processing request is an operation request of the client to the skip list. The server is a server.

[0098] Based on this, the application program in the client can send an operation request to the skip list in the server memory to the network card of the server through the network card deployed in the client. The network card determines the type of the operation request upon receiving the operation request sent by the client. The type includes a write request type and a read request type.

[0099] Step 304: In the case where the request type is determined to be a read request type, a target object is determined from an object storage module in response to the object processing request.

[0100] The object storage module can be understood as a module storing the target object. In actual application, the object storage module can be a memory of a server, a cache in a server, a register in a server, and the like, which is not specifically limited in the present specification.

[0101] Specifically, after determining the request type corresponding to the object processing request, the network communication module determines the target object from the object storage module in the case that the request type is a read request type in response to the object processing request. Wherein, determining the target object from the object storage module can be understood as that the network communication module obtains the object identifier of the target object carried in the object processing request, and determines the target object corresponding to the object identifier from the object storage module based on the object identifier. Wherein, the object identifier can be understood as information uniquely identifying an object, for example, the name, ID, number, etc. of the target object. In the case that the target object is a skip list, the object identifier can be the name of the skip list.

[0102] Continuing with the above example, in the case that the network card of the server determines that the request sent by the client is a read request for a skip list, the network card can query the skip list corresponding to the read request from the server memory. In actual applications, the network card can query the skip list corresponding to the skip list name from the server memory based on the skip list name carried in the read request.

[0103] Step 306: reading target data from the target object based on the data identifier information carried in the object processing request, and sending the target data to the client.

[0104] Wherein, in the case that the object processing request is different, the target data is also different, for example, in the case that the object processing request is a request for obtaining data in the target object, i.e. the object processing request is a Contain method, the target object can be understood as user data stored in the target object, for example, in the case that the target object is a skip list, the target data is user data (for example, multimedia data, numerical value, etc.) stored in the skip list. In actual applications, the target data can be stored in the nodes of the skip list in the form of key-value pairs.

[0105] For example, in the case that the object processing request is a request for querying a node in the target object, i.e. the object processing request is a Find method, the target data can be node information corresponding to the node, wherein the node information can be understood as the node identifier of the node.

[0106] In the case that the target data is data stored in the node of the skip list, the data identifier information can be understood as an identifier uniquely representing the target data, for example, in the case that the target data is data stored in the node of the skip list in the form of key-value pairs, the data identifier information can be understood as the key corresponding to the data.

[0107] Further, in the embodiments provided in the specification, in the case where the object processing request is Contain, the network card needs to determine the corresponding skip list from the memory of the server through the RDMA mode, and obtain the corresponding data from the skip list, so as to avoid the problem that the CPU of the server needs to consume the computing resources to execute the Contain request, reduce the computing pressure of the CPU, and improve the utilization efficiency of the skip list. Based on this, the way of obtaining the target data from the skip list is as follows.

[0108] The target data is read from the target object based on the data identification information carried in the object processing request, and the method comprises the following steps of:

[0109] The data identification information carried in the object processing request is determined.

[0110] At least two data storage nodes included in the target object are determined, and local data identification information stored in each data storage node is obtained.

[0111] The data identification information is matched with each local data identification information respectively, and in the case where the matching result is consistent, the data storage node corresponding to the local data identification information is determined as the target data storage node.

[0112] The target data corresponding to the data identification information is obtained from the target data storage node.

[0113] The data storage node can be understood as a node for storing data in the target object. For example, in the case where the target object is a skip list, the data storage node can be understood as a node in the skip list, which can be specifically understood with reference to the description of Figure 2 For another example, in the case where the target object is a tree data structure, the data storage node can be understood as a node for storing data in the tree data structure.

[0114] The local data identification information can be understood as a key stored in the data storage node. Referring to Figure 2 , the local data identification information is a key in the node, and the target data is data corresponding to the key.

[0115] Specifically, the object processing request carries data identification information, based on which the network communication module obtains the data identification information from the object processing request. Then, the network communication module determines a plurality of data storage nodes included in the target object, and obtains local data identification information stored in each data storage node.

[0116] The data identification information is matched with each local data identification information respectively, and in the case of consistent matching result, the data storage node corresponding to the local data identification information is determined as a target data storage node; and target data corresponding to the data identification information is obtained from the target data storage node.

[0117] In the above example, the key is carried in the Contain request, and based on this, the network card obtains the carried key from the request. Then, the network card determines the plurality of nodes included in the skip list, and obtains the key stored in each node. The two are matched,

[0118] In the case of consistent matching result, the node corresponding to the key matched with the key carried in the Contain request is determined as a target node, and the data corresponding to the key is obtained from the target node.

[0119] That is, the server CPU calls the Find method to verify the existence of the key, and if a node with the key is found, the target key-value pair in the node is sent to the client.

[0120] And in an embodiment provided in the specification, the server CPU reads the target key-value pair from the SkipList in response to the Contain method, and returns null if not found. This method does not need to wait.

[0121] In the embodiment provided in the specification, the network card calls the Find method to verify the existence of the key, that is, to determine whether the key in the node is consistent with the key carried in Contain. If consistent, it is determined that a node with the key is found, and the full link and removed flag of the node are checked by RDMA reading. Only when FullyLinked is true and Removed is false, the node is considered to exist, and the value in the node can be returned to the client.

[0122] Alternatively, in the embodiment provided in the specification, the network card calls the Find method to verify the existence of the key, that is, to determine whether the key in the node is consistent with the key carried in Contain. If consistent, it is determined that a node with the key is found, and the target key-value pair, Removed, FullyLinked and other data in the node are sent to the client. The client checks the full link and removed flag of the node. Only when FullyLinked is true and Removed is false, the node is considered to exist, and the value in the node can be returned to the application in the client. The application is the program that initiates the Contain request.

[0123] Further, since the data in each node in the skip list has the possibility of being updated, and in the case of a large number of read requests, the process of the network card obtaining the data and sending it to the client, the data may not be sent to the client in time due to the large number of read requests, thus causing the data sent to the client to be not the latest data. Therefore, in the embodiments provided in the specification, the network card needs to check the version number of the node before returning the value (data). If the value of the version number cannot satisfy the two conditions: that is, the version number is even and the same as the first observation value, it must be retried from the beginning of the Contain method until the data is valid (the data is the latest data); the specific implementation is as follows.

[0124] The method further includes:

[0125] Obtaining version information in the target data and obtaining local version information stored in the target data storage node;

[0126] Determining whether the version information is consistent with the local version information;

[0127] If yes, the target data is sent to the client;

[0128] If no, the step of reading target data from the target object based on the data identification information carried in the object processing request is continued to be executed until the version information and the local version information are consistent.

[0129] The version information can be understood as a version number. Correspondingly, the local version information is the version number in the node, which will change according to the modification of the data in the node in actual application.

[0130] In the case of sending the key-value pair, version number and other data to the client, the network card obtains the version number from the data to be sent to the client, and obtains the version number from the node corresponding to the key-value pair. Then, it is determined whether the two version numbers are consistent. If yes, it is determined that the key-value pair is the latest data, and the key-value pair is sent to the client.

[0131] If no, it is determined that the key-value pair is not the latest data, and the operation of obtaining the target data is re-executed until the data is valid (the data is the latest data).

[0132] In addition, in the object processing method provided in the specification, if the data amount of the node in the skip list is small, one strategy can be to obtain the entire node first and then check its state. When the update operation is very small, this optimization can significantly reduce the network round trip times.

[0133] Further, in the embodiments provided in the specification, in the case where the object processing request is Find, the network card needs to determine the corresponding skip list from the memory of the server through RDMA, and query the corresponding node from the skip list, so as to avoid the problem that the CPU of the server needs to consume computing resources to execute the Find request, reduce the computing pressure of the CPU, and improve the utilization efficiency of the skip list. Based on this, the way to obtain the target data from the skip list is as follows.

[0134] The target data is read from the target object based on the data identification information carried in the object processing request, and the target data is obtained based on the data identification information carried in the object processing request.

[0135] The data identification information carried in the object processing request is determined.

[0136] At least two data storage nodes included in the target object are determined, and local data identification information stored in each data storage node is obtained.

[0137] The data identification information is matched with each local data identification information respectively, and in the case where the matching result is consistent, the data storage node corresponding to the local data identification information is determined as the target data storage node.

[0138] The node information corresponding to the target data storage node is taken as the target data.

[0139] It should be noted that the object processing request can be a request for querying the corresponding node from the target object, for example, the Find method. Correspondingly, the node information can be understood as the node identifier of the target data storage node.

[0140] It should be noted that the Find method is the core of all operations. The specific execution process of the Find method can be: setting the header node as the root (root node), and the client (client) iteratively reads through RDMA traversal of the nodes in the SkipList until the target node is found or the loop ends.

[0141] In the above example, the Find request carries the key, based on which the network card obtains the key carried in the request. Then, the network card determines a plurality of nodes included in the skip list, and obtains the key stored in each node. The two are matched, and in the case where the matching result is consistent, the node corresponding to the key matching the key carried in the Find request is determined as the target node. And the node identifier of the target node is sent to the client.

[0142] In the embodiments provided in the specification, HybridSkipList can reduce MMIO (operation of obtaining data from local memory to RNIC) to only one by a specific method to avoid concurrency problems. In actual applications, the specific method can be any method of reducing multiple MMIO to only one, for example, Doorbell technology. Based on this, the HybridSkipList processes multiple RDMA read operations by using “Doorbell”. Doorbell can reduce multiple MMIO generated by CPU to only one. However, the RDMA read operations in the same batch should not depend on each other's values. So that the client only needs to poll the last CQE in the batch to determine the status of all requests. According to this rule, by using Doorbell batch processing, the client can retrieve the key and successor pointer in the same batch, and then continue to perform iterative queries for the node based on the key and successor pointer.

[0143] Further, in the embodiments provided in the specification, methods such as Insert, Update, and Remove are designed as a bilateral mode, which is the same as the general client-server RPC method, and the specific implementation is as follows.

[0144] After determining the request type corresponding to the object processing request, the method further comprises:

[0145] In a case where the request type is determined as a write request type, the object processing request is sent to an operation control module of the server, so that the operation control module performs processing on the target object in response to the object processing request.

[0146] The operation control module can be understood as a module in the server that can execute a write request, for example, a CPU in the server.

[0147] Continuing with the above example, in a case where the network card determines that the request is a write request (including but not limited to Insert, Update, and Remove), the object processing request can be sent to the CPU of the server, so that the CPU can process the skip list in the memory based on the write request, thereby realizing processing of the skip list by the bilateral mode.

[0148] It should be noted that the step of the operation control module performing processing on the target object in response to the object processing request can refer to the corresponding or corresponding content in the following object processing method applied to a server comprising a network communication module and an operation control module, and this embodiment will not be described in detail here.

[0149] The object processing method provided by the present specification for the network communication module of the server directly reads target data from a target object in response to a received object processing request in a case where the request type of the object processing request is determined to be a read request type, and sends the target data to a client, avoiding the need for the CPU of the server to consume computing resources to process the request, improving the operation efficiency of the CPU and reducing, and ensuring fast processing of the target object, improving the processing performance of the target object.

[0150] In addition, the above is a schematic scheme of an object processing method of the present embodiment. It should be noted that the technical scheme of the object processing method belongs to the same concept as the technical scheme of another object processing method described below, and the details of the technical scheme of the object processing method that are not described in detail can be referred to the description of the technical scheme of the another object processing method.

[0151] Figure 4 A flowchart of another object processing method according to an embodiment of the present specification is shown, which is applied to a server, the server comprising a network communication module and an operation control module, and the method specifically comprises the following steps.

[0152] Step 402: The network communication module receives an object processing request sent by a client for a target object, and in a case where the request type corresponding to the object processing request is determined to be a read request type, determines a target object from an object storage module in response to the object processing request, reads target data from the target object based on data identification information carried in the object processing request, and sends the target data to the client; and

[0153] In a case where the request type is determined to be a write request type, the object processing request is sent to the operation control module.

[0154] It should be noted that the explanation and description of this step 402 can be referred to the corresponding or corresponding contents in the above-mentioned one object processing method, and the present specification will not make too much repetition.

[0155] In an embodiment provided by the present specification, the reading of target data from the target object based on the data identification information carried in the object processing request comprises:

[0156] The network communication module determines the data identification information carried in the object processing request;

[0157] Determining at least two data storage nodes included in the target object, and obtaining local data identification information stored in each data storage node;

[0158] Match the data identification information with each local data identification information respectively, and in the case of consistent matching result, determine the data storage node corresponding to the local data identification information as the target data storage node;

[0159] Obtain the target data corresponding to the data identification information from the target data storage node.

[0160] Specifically, for the network communication module, determine the data identification information carried in the object processing request; determine at least two data storage nodes included in the target object, and obtain the local data identification information stored in each data storage node; match the data identification information with each local data identification information respectively, and in the case of consistent matching result, determine the data storage node corresponding to the local data identification information as the target data storage node; obtain the interpretation of the target data corresponding to the data identification information from the target data storage node. For the corresponding or corresponding content in the above-mentioned object processing method, this specification will not be described in detail.

[0161] In an embodiment provided by the specification, the target data is sent to the client, including:

[0162] The network communication module obtains the version information in the target data and the local version information stored in the target data storage node.

[0163] Determine whether the version information is consistent with the local version information.

[0164] If yes, the target data is sent to the client.

[0165] If no, continue to perform the step of reading the target data from the target object based on the data identification information carried in the object processing request until the version information and the local version information are consistent.

[0166] Specifically, for the network communication module in the above-mentioned embodiment, obtain the version information in the target data and the local version information stored in the target data storage node; determine whether the version information is consistent with the local version information; if yes, send the target data to the client; if no, continue to perform the step of reading the target data from the target object based on the data identification information carried in the object processing request until the version information and the local version information are consistent. For the corresponding or corresponding content in the above-mentioned object processing method, this specification will not be described in detail.

[0167] In an embodiment provided by the specification, the target data is sent to the client, including:

[0168] The network communication module determines data identification information carried in the object processing request.

[0169] The network communication module determines at least two data storage nodes included in the target object, and obtains local data identification information stored in each data storage node.

[0170] The network communication module matches the data identification information with each local data identification information respectively, and determines the data storage node corresponding to the local data identification information as a target data storage node when the matching result is consistent.

[0171] The network communication module determines node information corresponding to the target data storage node as target data.

[0172] Specifically, for the network communication module, the data identification information carried in the object processing request is determined, at least two data storage nodes included in the target object are determined, and local data identification information stored in each data storage node is obtained. The data identification information is matched with each local data identification information respectively, and the data storage node corresponding to the local data identification information is determined as a target data storage node when the matching result is consistent. The node information corresponding to the target data storage node is determined as target data. For details, please refer to the corresponding or corresponding content in the above object processing method, and this specification will not be described in detail.

[0173] Step 404: The operation control module receives the object processing request sent by the network communication module, and processes the target object in response to the object processing request.

[0174] In the embodiments provided in the specification, the operation control module processes the target object in response to the object processing request, including:

[0175] The operation control module determines the target object from the object storage module in response to the object processing request.

[0176] Based on the data identification information carried in the object processing request, a target data storage node is determined from at least two data storage nodes included in the target object.

[0177] The operation control module processes the target data storage node based on the object processing request.

[0178] Specifically, after receiving the object processing request sent by the network communication module, the operation control module can determine the target object from the object storage module in response to the object processing request, and determine the target data storage node from at least two data storage nodes included in the target object based on the data identifier information carried in the object processing request, and then process the target data storage node based on the object processing request.

[0179] Wherein, determining the target object from the object storage module can be understood as that the operation control module obtains the object identifier of the target object carried in the object processing request, and determines the target object corresponding to the object identifier from the object storage module based on the object identifier. Wherein, the object identifier can be understood as information for uniquely identifying an object, for example, the name, ID, number, etc. of the target object. In the case of the target object being a skip list, the object identifier can be the name of the skip list.

[0180] Further, in the embodiments provided in the specification, determining the target data storage node from the at least two data storage nodes included in the target object based on the data identifier information carried in the object processing request comprises:

[0181] The operation control module determines the data identifier information carried in the object processing request;

[0182] determining at least two data storage nodes included in the target object, and obtaining local data identifier information stored in each data storage node;

[0183] matching the data identifier information with each local data identifier information respectively, and in the case of matching results being consistent, determining the data storage node corresponding to the local data identifier information as the target data storage node.

[0184] In the above example, the write request carries the key, based on which the server CPU obtains the key carried in the request. Then, the server CPU determines the multiple nodes included in the skip list, and obtains the key stored in each node. Matching the two, in the case of matching results being consistent, the node corresponding to the key matching the key carried in the write request is determined as the target node.

[0185] Further, the methods of Insert, Update, Remove, etc. are bilateral implementation. They are only called by the server. The server uses the built-in atomic library of gcc (GNU Compiler Collection, GNU Compiler Collection) to ensure that the key data access is atomic. Specifically, in the case of the object processing request being an Insert request, the server performs node insertion on the skip list based on the Insert request in the following manner.

[0186] The object processing request is a node addition request.

[0187] Correspondingly, the processing of the target data storage node based on the object processing request comprises:

[0188] The operation control module determines the front data storage node corresponding to the target data storage node, and locks the front data storage node.

[0189] In the case where the front data storage node is connected to the target data storage node, a to-be-processed storage node is created.

[0190] The pointer in the front data storage node pointing to the target data storage node is modified to a pointer pointing to the to-be-processed storage node.

[0191] The pointer in the target data storage node pointing to the front data storage node is modified to a pointer pointing to the to-be-processed storage node.

[0192] The front data storage node is released.

[0193] The node addition request can be understood as a request for adding a node for storing data to the target object. For example, the node addition request can be an Insert request.

[0194] In the above example, the CPU of the server first calls the Find method to obtain the front node and the successor node in the process of performing the Insert operation. It should be noted that the server side will process the Find method here, rather than using a one-way operation to find the position of the node. This is because the combination of one-way and two-way operations in the same method will cause consistency problems after applying the cache. Therefore, to avoid changing the predecessor node when inserting the node, the object processing method provided in the specification locks the predecessor (i.e., the predecessor node) in ascending order and verifies that the predecessor node is still connected to the successor node. If the verification fails, the server will release the lock and retry from the beginning of the Find method. If the verification succeeds, after obtaining the lock, the server will start a new node and complete the pointer chasing, and set the FullyLinked flag to true.

[0195] That is, a new node is inserted in the front node and the successor node, and the pointer of the front node pointing to the successor node is pointed to the new node. And the pointer of the successor node pointing to the front node is pointed to the new node; thereby realizing the insertion of the node.

[0196] In the embodiment summary of the present specification, in the case that the object processing request is an Update or Remove request, the server performs node insertion on the skip list based on the Update or Remove request in the following manner.

[0197] The object processing request is a node update request.

[0198] Correspondingly, the processing of the target data storage node based on the object processing request comprises:

[0199] The operation control module determines target data in the object processing request for updating the initial data.

[0200] Locking the target data storage node, and updating the initial data in the target data storage node based on the target data, and releasing the target data storage node after the updating is completed.

[0201] The node update request can be understood as a request for updating data in a node. In actual application, the node update request can be an Update request or a Remove request. For example, in the case that the node update request is an Update request, after the server locates the target node, it first locks the node. Then it increases the version number to an odd number, performs updating (i.e., performs an updating operation on the data of the key-value pair in the node), and increases the version number to an even number after the updating is completed.

[0202] For example, in the case that the node update request is a Remove request, the Remove request is similar to the Insert method. The server first calls the Find method to locate the node to be updated. If the node is found, it checks whether the node is ready to be removed, wherein the FullyLinked flag of the node to be updated is true, and the Removed flag of the node to be updated is false. If the node can be deleted, it will be logically deleted by setting the Removed flag from false to true. Then physical deletion will be performed. The server locks the predecessor node of the node to be updated, verifies that the Removed flag of the predecessor node is still false and connected to the node to be updated. After the verification, the server can splice the node to be updated from top to bottom, and keep the properties of the SkipList.

[0203] Based on this, in the case of the node update request being an Update request, the initial data can be the data of the key-value pair in the node; correspondingly, the target data is a request to update the data in the key-value pair. In the case of the node update request being a Remove request, the initial data is the Removed flag of the node, and the target data is data that converts the Removed flag to false.

[0204] It should be noted that the Find and Contain methods can be executed by the client or the server, therefore, the server can execute the Find and Contain methods through the CPU, and the specific process of the server CPU executing the Find and Contain methods can refer to the steps of the client executing the Find and Contain methods, and the present specification will not make too much repetition. For example, in the process of the client executing, the Find and Contain methods can be executed through the server network card, and in the process of the server executing, the Find and Contain methods can be executed through the CPU of the server instead of the server network card.

[0205] The object processing method provided by the present specification applied to the server comprising a network communication module and an operation control module, in the case of determining that the request type of the received object processing request is a read request type, directly responding to the object processing request to read target data from a target object, and sending the target data to the client, and in the case of determining that the request type is a write request type, sending the object processing request to the operation control module, and processing the target object in response to the object processing request by the operation control module, so that the CPU of the server only needs to process the write request, avoiding the CPU of the server needing to consume computing resources to process the read request, improving the operation efficiency of the CPU, reducing, and ensuring fast processing of the target object, improving the processing performance of the target object.

[0206] In an embodiment provided by the present specification, the application effect of the object processing method in the actual application scenario is provided, referring to Figure 5 , Figure 5 is a schematic diagram of the application effect of an object processing method provided by an embodiment of the present specification, referring to Figure 5It can be seen that with a write operation load of 10%, a cache ratio of 1 / 32, and a key-value pair data size of 4096 bytes, and assuming the evaluation result is the average of ten runs, it can improve throughput by 1.48 to 4.41 times and 0.52 to 3.45 times compared to one-Sided SkipList and two-Sided SkipList, respectively. When the number of clients is 16, HybridSkipList ( Figure 5 The Hybrid version of the RDMA write test achieved a peak throughput of 237 KOPS. Under the same settings, the pure RDMA write test performed 780 KOPS (390 KOPS in the ping-pong scenario). The HybridSkipList's throughput was only 40% lower than the maximum RDMA write throughput. In conclusion, the HybridSkipList can fully utilize RDMA bandwidth. Here, Throughput can be considered as throughput. Figure 5 The "No Cache" setting can be used for local caching or caching on a proxy server.

[0207] Therefore, SkipList is based on RDMA and employs a hybrid one-sided / two-sided communication strategy. While using RDMA as the underlying transport, it chooses retry-based locking to provide further performance gains. Furthermore, HybridSkipList uses lock-based concurrency control, with the server handling concurrency to reduce costly network round-trip overhead. Because one-sided operations avoid server CPU involvement, data structure operations require only a small fraction of server CPU time.

[0208] Corresponding to the above method embodiments, this specification also provides embodiments of an object processing apparatus. Figure 6 A schematic diagram of an object processing apparatus according to one embodiment of this specification is shown. Figure 6 As shown, the network communication module of the server side of the device includes:

[0209] The receiving module 602 is configured to receive an object processing request sent by a client for a target object, and to determine the request type corresponding to the object processing request;

[0210] The determination module 604 is configured to determine the target object from the object storage module in response to the object processing request if the request type is determined to be a read request type.

[0211] The reading module 606 is configured to read target data from the target object based on the data identification information carried in the object processing request, and send the target data to the client.

[0212] Optionally, the object processing apparatus further comprises a sending module configured to:

[0213] in a case where the request type is determined as the write request type, send the object processing request to an operation control module of the server, so as to make the operation control module perform processing on the target object in response to the object processing request.

[0214] Optionally, the reading module 606 is further configured to:

[0215] determine data identification information carried in the object processing request;

[0216] determine at least two data storage nodes included in the target object, and acquire local data identification information stored in each data storage node;

[0217] match the data identification information with each local data identification information respectively, and in a case where the matching result is consistent, determine the data storage node corresponding to the local data identification information as a target data storage node;

[0218] acquire target data corresponding to the data identification information from the target data storage node.

[0219] Optionally, the reading module 606 is further configured to:

[0220] acquire version information in the target data, and acquire local version information stored in the target data storage node;

[0221] determine whether the version information is consistent with the local version information;

[0222] if yes, send the target data to the client;

[0223] if no, continue to perform the step of reading target data from the target object based on the data identification information carried in the object processing request until the version information is consistent with the local version information.

[0224] Optionally, the reading module 606 is further configured to:

[0225] determine data identification information carried in the object processing request;

[0226] determine at least two data storage nodes included in the target object, and acquire local data identification information stored in each data storage node;

[0227] The data identification information is matched with each local data identification information respectively, and in a case where the matching result is consistent, the data storage node corresponding to the local data identification information is determined as a target data storage node;

[0228] The node information corresponding to the target data storage node is taken as target data.

[0229] The object processing apparatus provided in the specification directly reads target data from a target object in response to the received object processing request in a case where the request type of the received object processing request is determined as a read request type, and sends the target data to the client, avoiding the need for the CPU of the server to consume computing resources to process the request, improving the operation efficiency of the CPU, reducing, and ensuring fast processing of the target object, improving the processing performance of the target object.

[0230] The above is a schematic scheme of an object processing apparatus of the embodiment. It should be noted that the technical scheme of the object processing apparatus belongs to the same concept as the technical scheme of the object processing method described above, and the details of the technical scheme of the object processing apparatus that are not described in detail can be referred to the description of the technical scheme of the object processing method.

[0231] Figure 7 A structural block diagram of a computing device 700 according to an embodiment of the specification is shown. The components of the computing device 700 include, but are not limited to, a memory 710 and a processor 720. The processor 720 is connected to the memory 710 through a bus 730, and a database 750 is used to save data.

[0232] The computing device 700 also includes an access device 740, which enables the computing device 700 to communicate via one or more networks 760. Examples of these networks include a public switched telephone network (PSTN), a local area network (LAN), a wide area network (WAN), a personal area network (PAN), or a combination of communication networks such as the Internet. The access device 740 can include one or more of any type of network interface (e.g., network interface card (NIC)), such as an IEEE 802.11 wireless local area network (WLAN) wireless interface, a worldwide interoperability for microwave access (Wi-MAX) interface, an Ethernet interface, a universal serial bus (USB) interface, a cellular network interface, a Bluetooth interface, a near field communication (NFC) interface, and the like.

[0233] In an embodiment of the specification, the above-mentioned components of the computing device 700 and Figure 7 other components not shown in the specification can be connected to each other, for example, through a bus. It should be understood that Figure 7The illustrated computing device structural block diagram is merely for the purpose of example, and is not a limitation on the scope of the present specification. Other components can be added or replaced as needed by those skilled in the art.

[0234] The computing device 700 can be any type of stationary or mobile computing device, including a mobile computer or mobile computing device (e.g., a tablet computer, a personal digital assistant, a laptop computer, a notebook computer, a netbook, etc.), a mobile phone (e.g., a smartphone), a wearable computing device (e.g., a smart watch, smart glasses, etc.), or other type of mobile device, or a stationary computing device such as a desktop computer or PC. The computing device 700 can also be a mobile or stationary server.

[0235] The processor 720 is configured to execute computer-executable instructions, which, when executed by the processor 720, implement the steps of the object processing method described above.

[0236] The above is a schematic scheme of the computing device of the embodiment. It should be noted that the technical scheme of the computing device and the technical scheme of the object processing method described above belong to the same concept, and the details of the technical scheme of the computing device that are not described in detail can be referred to the description of the technical scheme of the object processing method.

[0237] An embodiment of the present specification also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the steps of the object processing method described above.

[0238] The above is a schematic scheme of the computer-readable storage medium of the embodiment. It should be noted that the technical scheme of the storage medium and the technical scheme of the object processing method described above belong to the same concept, and the details of the technical scheme of the storage medium that are not described in detail can be referred to the description of the technical scheme of the object processing method.

[0239] An embodiment of the present specification also provides a computer program, which, when executed in a computer, causes the computer to perform the steps of the object processing method described above.

[0240] The above is a schematic scheme of the computer program of the embodiment. It should be noted that the technical scheme of the computer program and the technical scheme of the object processing method described above belong to the same concept, and the details of the technical scheme of the computer program that are not described in detail can be referred to the description of the technical scheme of the object processing method.

[0241] The above-described embodiments of the application have several aspects, no single one of which is solely responsible for the application's desirable attributes. Without limiting the scope of the application as expressed by the claims which follow, some further embodiments make these aspects even more useful. Other embodiments can result in less desirable attributes.

[0242] The computer readable medium can include any entity or apparatus capable of carrying the computer program code, recording medium, U disk, mobile hard disk, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signal, telecommunication signal, software distribution medium, etc. It should be noted that the computer readable medium can include appropriate contents according to the requirements of legislation and patent practice in the jurisdiction, for example, in some jurisdictions, according to legislation and patent practice, the computer readable medium does not include electrical carrier signals and telecommunication signals.

[0243] It should be noted that for the foregoing method embodiments, the acts described can be performed in a different order than that described, and that various interlocking and / or parallel configurations are also possible according to the certain embodiments of the present specification. Furthermore, certain of the acts can be optional depending upon the particular embodiment of the method. The scope of the method of each method claim should not be limited to the specific embodiments set forth herein, but should be given the full scope of its corresponding jurisdictional patent claims and any equivalents thereof.

[0244] In the above embodiments, the description of each embodiment is focused on different aspects, and the parts not described in detail in a certain embodiment can be referred to the related description of other embodiments.

[0245] The preferred embodiments of the present specification disclosed above are only used to help explain the present specification. The alternative embodiments do not describe all the details and do not limit the application to the specific embodiments described. Obviously, according to the content of the embodiments of the present specification, many modifications and changes can be made. The present specification selects and specifically describes these embodiments in order to better explain the principles and practical applications of the embodiments of the present specification, so that those skilled in the art can well understand and use the present specification. The present specification is limited by the claims and their full scope and equivalents.

Claims

1. An object processing method applied to a network communication module of a server, comprising: receiving an object processing request sent by a client for a target object, and determining a request type corresponding to the object processing request, wherein the request type comprises a read request type and a write request type, the read request type is a unilateral operation, and the write request type is a bilateral operation; in a case where it is determined that the request type is the read request type, determining a target object from an object storage module in response to the object processing request; reading target data from the target object based on data identification information carried in the object processing request, and sending the target data to the client.

2. The object processing method of claim 1, after the step of determining the request type corresponding to the object processing request, further comprising: in a case where it is determined that the request type is the write request type, sending the object processing request to an operation control module of the server, so that the operation control module processes the target object in response to the object processing request.

3. The object processing method of claim 1, wherein the step of reading target data from the target object based on data identification information carried in the object processing request comprises: determining the data identification information carried in the object processing request; determining at least two data storage nodes included in the target object, and obtaining local data identification information stored in each data storage node; matching the data identification information with each local data identification information respectively, and in a case where the matching result is consistent, determining the data storage node corresponding to the local data identification information as a target data storage node; obtaining target data corresponding to the data identification information from the target data storage node.

4. The object processing method of claim 3, wherein the step of sending the target data to the client comprises: obtaining version information in the target data, and obtaining local version information stored in the target data storage node; determining whether the version information is consistent with the local version information; if yes, sending the target data to the client; if no, continuing to perform the step of reading target data from the target object based on data identification information carried in the object processing request until the version information is consistent with the local version information.

5. The object processing method of claim 1, wherein the step of reading target data from the target object based on data identification information carried in the object processing request comprises: determining the data identification information carried in the object processing request; determining at least two data storage nodes included in the target object, and obtaining local data identification information stored in each data storage node; matching the data identification information with each local data identification information respectively, and in a case where the matching result is consistent, determining the data storage node corresponding to the local data identification information as a target data storage node; obtaining node information corresponding to the target data storage node as target data.

6. An object processing method applied to a server, the server comprising a network communication module and an operation control module, wherein the network communication module receives an object processing request sent by a client for a target object, and in a case where it is determined that a request type corresponding to the object processing request is a read request type, the network communication module determines a target object from an object storage module in response to the object processing request, reads target data from the target object based on data identification information carried in the object processing request, and sends the target data to the client; and in a case where it is determined that the request type is a write request type, the network communication module sends the object processing request to the operation control module; wherein the read request type is unilateral operation, and the write request type is bilateral operation. The operation control module receives the object processing request sent by the network communication module, and processes the target object in response to the object processing request.

7. The object processing method of claim 6, wherein the reading of the target data from the target object based on the data identification information carried in the object processing request comprises: determining, by the network communication module, the data identification information carried in the object processing request; determining at least two data storage nodes included in the target object, and obtaining local data identification information stored in each data storage node; matching the data identification information with each local data identification information respectively, and in a case where the matching result is consistent, determining the data storage node corresponding to the local data identification information as a target data storage node; and obtaining target data corresponding to the data identification information from the target data storage node.

8. The object processing method of claim 6, wherein the reading of the target data from the target object based on the data identification information carried in the object processing request comprises: determining, by the network communication module, the data identification information carried in the object processing request; determining at least two data storage nodes included in the target object, and obtaining local data identification information stored in each data storage node; matching the data identification information with each local data identification information respectively, and in a case where the matching result is consistent, determining the data storage node corresponding to the local data identification information as a target data storage node; and obtaining node information corresponding to the target data storage node as target data.

9. The object processing method of claim 6, wherein the processing of the target object by the operation control module in response to the object processing request comprises: determining, by the operation control module, a target object from an object storage module in response to the object processing request; determining a target data storage node from at least two data storage nodes included in the target object based on data identification information carried in the object processing request; and processing the target data storage node based on the object processing request. ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ 10.The object processing method of claim 9, wherein the determining the target data storage node from the at least two data storage nodes included in the target object based on the data identifier carried in the object processing request comprises: determining the data identifier carried in the object processing request by the operation control module; determining the at least two data storage nodes included in the target object and obtaining the local data identifier stored in each data storage node; and matching the data identifier with each local data identifier respectively, and in case of a consistent matching result, determining the data storage node corresponding to the local data identifier as the target data storage node. 11.The object processing method of claim 9, wherein the object processing request is a node addition request; and correspondingly, the processing the target data storage node based on the object processing request comprises: determining the front data storage node corresponding to the target data storage node and locking the front data storage node by the operation control module; in case that the front data storage node is connected to the target data storage node, creating a to-be-processed storage node; modifying the pointer in the front data storage node pointing to the target data storage node to a pointer pointing to the to-be-processed storage node; modifying the pointer in the target data storage node pointing to the front data storage node to a pointer pointing to the to-be-processed storage node; and releasing the front data storage node. 12.The object processing method of claim 9, wherein the object processing request is a node update request; and correspondingly, the processing the target data storage node based on the object processing request comprises: determining the target data for updating the initial data carried in the object processing request by the operation control module; locking the target data storage node and updating the initial data in the target data storage node based on the target data, and releasing the target data storage node after the updating is completed. 13.A computing device comprising: a memory and a processor; the memory is configured to store computer executable instructions, and the processor is configured to execute the computer executable instructions, which when executed by the processor, implement the steps of the object processing method of any one of claims 1 to 5. 14.A computer readable storage medium storing computer executable instructions, which when executed by a processor, implement the steps of the object processing method of any one of claims 1 to 5. ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​

Images