Learning type index writing extension method and system based on separated memory

Abstract

The invention relates to a learning type index write extension method and system based on a separated memory. The system comprises a computing pool server and a storage pool server. The compute pool server holds a pointer pointing to a write delta buffer of the multiplex model, and determines the insertion location of the key-value pair based on a linear model in the learned index model of the cache and holds a pointer pointing to the write delta buffer of the multiplex model to access the write delta buffer located on the storage pool server. And the storage pool server constructs a write increment buffer area of the learning type index model and the multiplexing model to absorb the newly inserted key value pair. A retraining thread in the storage pool server asynchronously retrains the sub-model so as to unload a retraining process to the storage pool server; the retraining thread scans and trains key value pairs in the sub-model to generate a new bottom layer sub-model, and the write increment buffer area is updated; and the retraining thread dynamically adjusts the size of the write increment buffer based on the data insertion characteristics under the coverage of the sub-model.

Description

Technical Field

[0001] The present invention relates to the technical field of storage and retrieval in computers, and in particular to a learning index write expansion method and system based on a disaggregated memory. Background Art

[0002] An index is regarded as a "model" for predicting the position of keys in a dataset. Therefore, an index can be learned. A Learned Index is a method that uses machine learning techniques to optimize data indexing. The core idea of a learned index is that if the distribution of data and its query patterns can be predicted, a machine learning model can be used to achieve the functions of an approximate traditional index structure. The advantage of doing this is that a learned index can adapt to the distribution of a specific dataset, thereby providing higher efficiency in terms of storage space and query time. For example, by training a neural network or a regression model to predict the position of data, the addressing overhead during data lookup can be reduced. Current research shows that a learned index is three times faster than a B+Tree in terms of search time and one order of magnitude lower than a B+Tree in terms of memory occupancy. Therefore, a learned index is an index structure that can support both efficient single-point queries and range queries and has low memory space overhead. However, a learned index is limited to static, read-only workloads. When faced with a write workload, since the newly added key-value pairs disrupt the data distribution law, the index performance collapses when dealing with write operations.

[0003] The attempts to perform write expansion for a learned index are mainly divided into two technical routes. One is to reserve gap spaces at the storage positions of key-value pairs in advance and use a model to guide the search for the insertion position, so as to reduce the number of data movements during write operations and reduce the search range during read operations. The other attempt to perform write expansion is mainly to use a traditional sorted index structure to construct an incremental index, temporarily record key-value pairs, and trigger a retraining process at a certain time, and merge the traditional incremental sorted index with the static learned index.

[0004] In a disaggregated memory system, since both the write range and the read range are not restricted, and coupled with the complex coordination problem of gap formation, the write expansion method of the gap array is not suitable for concurrent scenarios; due to the additional network access and low cache efficiency caused by tree structure traversal, the method of using a tree as an incremental buffer is also not suitable for concurrent scenarios.

[0005] On the other hand, in a disaggregated memory system, due to the low memory footprint advantage of the learning index, the entire index structure can be cached in the DRAM of the storage pool of the compute pool server nodes, thus effectively enhancing the performance advantage brought by the index. In contrast, for traditional tree indexes, due to their high memory consumption, the index structure cannot be fully cached in the DRAM of the storage pool of the compute pool server nodes, and thus the uncached part needs to access the DRAM of the storage pool of the compute pool server nodes to obtain it; due to the high network communication latency, this will result in low throughput performance. Currently, the learning indexes designed for disaggregated memory still rely on traditional sorted index structures, such as ordered linked lists, for write expansion. Therefore, although leaf table technology is adopted to quickly locate the position in the linked list, the existing learning indexes for disaggregated memory still face problems such as low write expansion performance and cache capacity miss due to the overly large leaf table.

[0006] Finally, in the case of disaggregated compute and memory resources, when the compute pool server performs retraining, according to the traditional retraining architecture method, the key-value pair data to be trained needs to be read from the DRAM of the storage pool of the storage pool server to the local DRAM of the storage pool. Then, the local CPU accesses the key-value pair data to be trained on the local DRAM and executes the optimal piecewise linear fitting algorithm for retraining. The result of the division will be temporarily stored on the local DRAM, and with the help of the RDMA network card, the training result on the local DRAM is read through the DMA technology and transferred to the DRAM of the storage pool of the storage pool server. This process will greatly consume the limited RDMA network bandwidth, resulting in a reduction in the efficiency of index operation.

[0007] CN115712616A discloses an indexing method based on a learning index. The method includes: in response to a modification operation on data in a database, storing the corresponding modified data in a buffer configured in advance outside the original database; in response to a query request for data in the database, querying the database based on a pre-configured learning index and using the buffer for query verification. Among them, the modification operation includes at least one of adding, deleting, and replacing data. An insertion sequence and a deletion sequence are pre-configured in the buffer. This technical solution also has defects in write expansion performance: First, the management of the buffer increases complexity and a balance needs to be achieved between memory usage and performance. A too small buffer may lead to frequent data flushing, affecting the batch write efficiency. In addition, there are challenges in data consistency. When data in the buffer is not synchronized to the main database in time, especially in the case of system failures, consistency problems may occur. To ensure data is not lost, the buffer may need to be persisted, which brings additional I / O overhead and affects write performance. At the same time, the risk of buffer overflow is more significant when write operations are frequent, which may lead to emergency flushing or operation discarding, affecting system stability. Moreover, during querying, verification needs to be performed through the learning index and the information in the buffer. Such complex logic may reduce query performance, especially when the content of the buffer changes frequently.

[0008] Therefore, how to improve the write expansion method of the learning index on a disaggregated memory system to make it more suitable for concurrent scenarios is a technical problem that the present invention hopes to solve.

[0009] In addition, on the one hand, there are differences in the understanding of those skilled in the art; on the other hand, although the applicant has studied a large number of documents and patents when making the present invention, all details and content are not listed in detail due to space limitations. However, this does not mean that the present invention does not have the features of these prior arts. On the contrary, the present invention already has all the features of the prior arts, and the applicant reserves the right to add relevant prior arts in the background art. Summary of the Invention

[0010] In view of the above defects or improvement requirements of the prior art, the present invention proposes a learning index write expansion method and system based on disaggregated memory, aiming to improve the problem that the write expansion in the form of a traditional incremental tree cannot be fully cached by the DRAM of the storage pool of the compute pool server node, which ultimately leads to additional network access and low cache efficiency problems, and the problem that the limited RDMA network bandwidth is quickly consumed due to the CPU of the compute pool server initiating retraining.

[0011] In view of the deficiencies of the prior art, the present invention provides a learning index write extension system based on a split memory from a first aspect, including a computing pool server and a storage pool server. The computing pool server determines the insertion position of key-value pairs based on the linear model in the cached learning index model and holds a pointer to the write increment buffer of the reuse model, and determines the insertion position of key-value pairs based on the linear model in the cached learning index model. The storage pool server constructs write increment buffers for the learning index model and the reuse model to absorb newly inserted key-value pairs. The retraining thread in the storage pool server asynchronously retrains the sub-model nodes to offload the retraining process to the storage pool server; the retraining thread scans and trains the key-value pairs in the sub-model, generates new underlying sub-model nodes, and updates the write increment buffer; the retraining thread also dynamically adjusts the size of the write increment buffer based on the data insertion characteristics under the sub-model coverage. The computing pool server updates the cached sub-model and the pointer held by the sub-model to the write increment buffer based on the execution result of the retraining thread of the storage pool server

[0012] Through the cooperation of the computing pool server and the storage pool server, this system realizes efficient key-value pair management and access. The computing pool server uses the pointer to the write increment buffer of the reuse model it holds to find the write increment buffer located on the storage pool server, and processes newly inserted key-value pairs by determining the insertion position through the linear model. This design avoids the space overhead of traditional index structures. The computing pool only needs to cache the learned model and the pointer to the write increment buffer, so that the index structure can be fully cached in the DRAM of the computing pool, and the access speed of the index and the throughput of key-value pair operations are improved. In addition, by offloading the retraining process to the storage pool server, the decoupling of insertion and retraining is achieved, avoiding the movement of key-value pair data to be retrained between the computing pool server and the storage pool server, thus reducing the burden on the limited RDMA network bandwidth.

[0013] According to a preferred embodiment, the computing pool server is further configured to: in the execution of the preloading phase, load the initial key-value pairs into the storage pool server and sort the key-value pairs from smallest to largest; divide the sorted key-value pairs into several sub-model nodes; recursively train the sub-model nodes to obtain the middle layer and the top layer of the indexes of the sub-model nodes; and initially allocate the continuous address space in the storage pool server as the write increment buffer according to the data node size of the sub-model nodes at the bottom layer of the learning index model.

[0014] In the preloading stage, the computing pool server sorts and partitions the initial key-value pairs, constructs multiple sub-model nodes, and then performs recursive training to form a multi-layer structure of the index. This method organizes the data in an orderly manner during the data import stage, improving the efficiency of subsequent data access and insertion. By preallocating the data space of the underlying sub-model nodes, the memory layout of the storage pool server is optimized.

[0015] According to a preferred embodiment, the storage pool server is configured to: monitor the messages of the bilateral RDMA primitive technology of the computing pool server based on a preset management thread; pass the anchor points of the interval where retraining occurs as parameters; search for the anchor points in the messages of the bilateral RDMA primitive technology based on the learning index model, and retrain the old sub-model into a new sub-model according to the search results; fill the model parameters of the new sub-model nodes and the corresponding anchor point information, and allocate data nodes and write increment buffers; the management thread sends the new sub-model nodes to each computing pool server in the manner of bilateral RDMA primitives, so that the computing pool server updates the sub-model nodes.

[0016] The management thread of the storage pool server manages the data transmission and retraining process by monitoring the messages of the bilateral RDMA primitive technology. Utilizing the high efficiency of the RDMA technology, fast data transmission and update of sub-model nodes are achieved, improving the utilization rate of network bandwidth and the real-time performance of the system.

[0017] According to a preferred embodiment, the storage pool server is further configured to: the retraining thread asynchronously migrates the data of the old sub-model nodes and the old write increment buffers to the new sub-model nodes and the new write increment buffers, and feeds back the completion status to the management thread after completion.

[0018] The retraining thread is responsible for migrating the old sub-model nodes and the cached data to the new model and cache, and feeding back the status after completion. The asynchronous migration reduces system blocking, improves the parallelism and efficiency of data update, and ensures the stability and timely response of the system.

[0019] According to a preferred embodiment, the computing pool server is further configured to: after making a segmented division of the data nodes in the old sub-model nodes and the key-value pairs of the sub-model in the write increment buffer based on the optimal piecewise linear fitting algorithm, count the number of key-value pairs N 1 on the original data nodes in each segment and the number of key-value pairs N 2 on the write increment buffer; the calculation method of the write increment buffer size is:

[0020] Size Buffer =min(N 2 / N 1 *Size Node ,2*SizeNode ), N2 / N1 > 1;

[0021] Size Buffer = max(N 2 / N 1 * Size Node , 0.5 * Size Node ), N2 / N1 < 1;

[0022] Size Buffer represents the size of the write increment buffer, and Size Node represents the size of the data node, and N 1 represents the number of key-value pairs on the original data node, and N 2 represents the number of key-value pairs located on the write increment buffer.

[0023] The retraining threads on the storage pool server use the optimal piecewise linear fitting algorithm to divide the segmented results. According to the data distribution within the segments on the data nodes and the write extension increment buffer, the size of the write increment buffer is dynamically adjusted. Preferably, the computing pool server stores the execution results of the retraining threads on the storage pool server, updates the cached sub-model and the pointer held by the sub-model to the write increment buffer. This dynamic adjustment mechanism improves the utilization rate of buffer space, optimizes memory usage, and ensures that the system can maintain efficient operation under various data loads.

[0024] According to a preferred embodiment, the computing pool server is further configured to: search based on the cache of the learning index model to determine the first position offset Loc 1 on the data node to be accessed and the second position offset Loc 2 on the write increment buffer.

[0025] Calculate the access space size of the read and write operations: Size = Size Bucket * N.

[0026] Size Bucket represents the size of the bucket, N represents the number of buckets for linear probing, and Size represents the read space size specified by the read and write operations; then the access space range of the read and write operations is [Loc 1 , Loc 1 + Size] and [Loc 2 , Loc 2 + Size].

[0027] The computing pool server determines the access positions of the data node and the write increment buffer based on the cached learning index model and calculates the space range of the read and write operations. By accurately calculating the access space, the efficiency and accuracy of data access are improved, unnecessary memory accesses are reduced, and the overall performance is optimized.

[0028] The present invention provides, from a second aspect, a learning index write expansion method based on a split memory, the method comprising: setting a pointer holding a write increment buffer pointing to a reuse model, and determining an insertion position of a key-value pair based on a linear model in a cached learning index model; constructing write increment buffers for the learning index model and the reuse model to absorb newly inserted key-value pairs; wherein, a retraining thread is used to asynchronously retrain sub-model nodes to offload the retraining process to a storage pool server; the retraining thread scans and trains key-value pairs within a sub-model, generates new underlying sub-model nodes, and updates the write increment buffer; dynamically adjusting the size of the write increment buffer based on data insertion characteristics under the coverage of the sub-model. A computing pool server updates the cached sub-model and the pointer held by the sub-model pointing to the write increment buffer based on the execution result of the retraining thread of the storage pool server.

[0029] Through the cooperation of the computing pool server and the storage pool server, the present invention realizes efficient key-value pair management and access. The computing pool server uses the write increment buffer of the reuse model to absorb newly inserted key-value pairs and determines the insertion position through a linear model. This design avoids the space overhead of traditional index structures, enabling the index structure to be fully cached in the DRAM of the computing pool, thereby improving the access speed of the index and the throughput of key-value pair operations. In addition, by offloading the retraining process to the storage pool server, the decoupling of insertion and retraining is achieved, avoiding the movement of key-value pair data to be retrained between the computing pool server and the storage pool server, thereby reducing the burden on the limited RDMA network bandwidth.

[0030] According to a preferred embodiment, the method further comprises: during the execution of a preloading phase, loading initial key-value pairs into the storage pool server and sorting the key-value pairs in ascending order; dividing the sorted key-value pairs into a number of sub-model nodes; recursively training the sub-model nodes to obtain the middle layer and the top layer of the index of the sub-model nodes; and initially allocating a continuous address space in the storage pool server as a write increment buffer according to the data node size of the underlying sub-model nodes of the learning index model.

[0031] During the preloading phase, the method first loads the initial key-value pairs into the storage pool server and sorts them, divides the sorted key-value pairs using the best piecewise linear fitting algorithm, organizes the data into sub-model nodes, and then recursively trains to construct the middle layer and the top layer structures of the index. This method ensures that the data is efficiently organized during the initial loading, improving the efficiency of data access and insertion. By preallocating a continuous address space as the write increment buffer, the subsequent memory usage is optimized and the overhead of dynamic allocation is reduced.

[0032] According to a preferred embodiment, the method further includes: monitoring messages of the bilateral RDMA primitive technology of the compute pool server based on a preset management thread; passing the anchor points of the interval where retraining occurs as parameters; searching for the anchor points in the messages of the bilateral RDMA primitive technology based on the learning index model, and retraining the old sub-model into a new sub-model according to the search results; filling the model parameters of the new sub-model nodes and the corresponding anchor point information, and allocating data nodes and write increment buffers; the management thread sending the new sub-model nodes to each compute pool server in the manner of bilateral RDMA primitives, so that the compute pool server updates the sub-model nodes.

[0033] The method monitors RDMA messages through a management thread to ensure efficient data transmission and update. During retraining, the old sub-model nodes are retrained into new nodes and transmitted to the compute pool server via RDMA for update. The use of RDMA improves the speed and efficiency of data transmission, ensuring that model parameters and anchor point information can be quickly updated to each compute pool server. This method enhances the system's response ability and processing efficiency, making the index update process smoother.

[0034] According to a preferred embodiment, the method further includes: the retraining thread asynchronously migrates the data of the old sub-model nodes and the old write increment buffer to the new sub-model nodes and the new write increment buffer, and feeds back the completion status to the management thread after completion. The asynchronous migration reduces system blocking, improves the parallelism and efficiency of data update, and ensures the stability and timely response of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] Figure 1 is the hardware architecture diagram of the learning index write expansion system based on disaggregated memory provided by the present invention;

[0036] Figure 2 is the logical schematic diagram of the learning index write expansion method based on disaggregated memory provided by the present invention;

[0037] Figure 3 is the usage schematic diagram of the write expansion increment area provided by the present invention;

[0038] Figure 4 is the schematic diagram of the read data access path during retraining provided by the present invention;

[0039] Figure 5 is the schematic diagram of the write data access path during retraining provided by the present invention;

[0040] Figure 6 is a schematic diagram of the memory space division range of the write increment buffer provided by the present invention;

[0041] Figure 7It is another schematic diagram of the memory space division range of the write increment buffer provided by the present invention. Detailed implementation manners

[0042] The following is a detailed description with reference to the accompanying drawings.

[0043] The present invention explains some noun terms.

[0044] Computing pool: It refers to aggregating multiple computing resources (such as CPUs, GPUs, memory, etc.) to form a unified computing resource pool. This resource pooling enables computing resources to be flexibly allocated to different application programs and tasks, improving the utilization efficiency of computing power. Computing pools are usually used in cloud computing environments and are realized through virtualization technology. Users can dynamically adjust the allocation of computing resources according to needs to cope with different workloads and performance requirements.

[0045] Client: It refers to the physical server in the computing pool node. Different clients are different computing pool server nodes. In terms of resource nature, since the client contains rich CPU resources, it can be called the computing pool side; in terms of service nature, the computing pool provides the ability to access key-value pairs to the client, which is the general term for the server nodes on the client-facing side.

[0046] Storage pool: It is a technology that aggregates multiple physical storage resources (such as hard disks, SSDs, etc.) to form a unified and manageable storage resource pool. Through the storage pool, administrators can dynamically allocate and manage storage space, improving the utilization rate and flexibility of storage resources. The storage pool can support different storage strategies, such as RAID configurations, data redundancy, and backup strategies, to ensure data reliability and availability. It is commonly used in virtualized environments to quickly allocate storage resources according to needs.

[0047] Server side: It refers to the physical server in the storage pool node. Different server sides are different storage pool server nodes. In terms of resource nature, since the server side contains rich DRAM memory resources, it can be called the storage pool side; in terms of service nature, the storage pool provides the ability to store key-value pairs to the client, which is the general term for the server nodes on the storage service-facing side.

[0048] Sub-model: A set of parameters obtained by the optimal piecewise linear fitting algorithm, respectively called the intercept b and the slope k, can form a linear model of loc = k * key + b, where loc is the model prediction position and key is the key of the key-value pair.

[0049] Sub - model node: A data node that contains a sub - model, the largest key (referred to as the anchor key) in the key - value pairs covered in the sub - model, a pointer to a data node (the node storing the key - value pair data within the coverage range of the sub - model), a pointer, a write increment buffer node, and global lock information, etc.

[0050] Linear model: A linear equation of the form loc = k * key + b, which is composed of a set of parameters within the sub - model. loc is the predicted position of the model, key is the key of the key - value pair. k and b are parameters given by the best piece - wise linear fitting algorithm within the sub - model.

[0051] Learning - based index: A tree - like structure formed by sub - models and intermediate - layer nodes and top - layer nodes obtained by recursively training sub - model nodes.

[0052] Write increment buffer: A data node formed by a continuous address space that re - uses the parameters of the sub - model node to store newly inserted key - value pairs. The newly added key - value pairs are calculated to obtain the storage position in the way of the parameters within the sub - model node, and the key size is revealed by the storage position address size.

[0053] Multi - version mechanism: After retraining, maintaining pointers to the data nodes and write increment buffers before retraining, as well as pointers to the newly generated data nodes and newly allocated write increment buffers, which are respectively called new / old versions.

[0054] Posterior - perception static node allocation: When retraining, adjust the size of the newly allocated write increment buffer according to the ratio of the number of key - value pairs in the write increment buffer to the number of key - value pairs in the data node.

[0055] Pre - loading stage: It belongs to the initial generation stage of the learning - based index; the application using this index selects key - value pairs according to the uniform sampling strategy based on the application's historical key - value pair information; after sorting in ascending order, generate sub - model nodes according to the best piece - wise linear fitting algorithm and recursively train the sub - model nodes according to the best piece - wise linear fitting algorithm to generate recursive sub - model nodes until the number of recursively generated sub - model nodes is small enough (single - digit or unable to perform the best piece - wise linear fitting algorithm anymore).

[0056] Initial learning - based index: A tree - like model composed of sub - model nodes and recursively generated sub - model nodes in the pre - loading stage.

[0057] Training - generated node: A data node generated by the best piece - wise linear fitting algorithm.

[0058] The PLR algorithm, namely the optimal piecewise linear fitting algorithm, is a fitting algorithm in the field of computational geometry. Its input is keys sorted in ascending order, and its output is the partitioning of these sorted keys, as well as the linear models corresponding to each range within the partitioning. For example, for keys Key0 to Key100 sorted in ascending order, the PLR algorithm divides them into Key0 - Key35, along with the linear model loc = k0 * Key + b0; Key36 - Key58, along with the linear model loc = k1 * Key + b1; Key59 - Key100, along with the linear model loc = k2 * Key + b2.

[0059] The present invention provides a learning index write expansion method and system based on disaggregated memory. The present invention can also be a learning index write expansion device based on disaggregated memory. The present invention can also be an electronic device that executes the learning index write expansion method based on disaggregated memory. The present invention can also provide a storage medium storing an encoded program of the learning index write expansion method based on disaggregated memory.

[0060] Embodiment 1

[0061] As Figure 1 shown, the learning index write expansion system based on disaggregated memory includes a plurality of compute pool servers and a plurality of storage pool servers. The compute pool servers are configured with a large amount of CPU resources and local DRAM. The local DRAM is used as local memory.

[0062] The storage pool servers are configured with limited CPU resources and a large amount of DRAM. The storage pool servers are configured with a large amount of DRAM, which is used as storage pool DRAM. The storage pool DRAM is used as a remote large memory for exposure to external systems.

[0063] In the scenario of the present invention, the RDMA network technology is adopted to implement the memory expansion function. Each piece of hardware in the compute pool servers and the storage pool servers is configured with an RDMA network card. The plurality of compute pool servers and the plurality of storage pool servers are connected through a dedicated InfiniBand switch, thereby realizing RDMA networking.

[0064] As Figure 1 shown, in the case of realizing RDMA networking, data is exchanged between the compute pool servers and the storage pool servers; data is not exchanged between the compute pool servers and between the storage pool servers. As Figure 2 shown, Client 1 and Client 2 serve as compute pool servers.

[0065] In the learning index write extension system based on a split memory in the present invention, a write increment buffer for a reuse model is built on the storage pool server to absorb newly inserted key-value pairs. The computing pool server holds a pointer to the write increment buffer of the reuse model and determines the insertion position of the key-value pair based on the linear model in the cached learning index model.

[0066] That is to say, the computing pool server utilizes the property that the calculation result of the linear model in the learning index structure is monotonically increasing for keys (i.e., the larger the key itself, the larger the position calculated by the linear model) to determine the selection of the insertion position for subsequent key-value pairs. Each linear model covers a different key-value pair range. Therefore, each sub-model node constructs a separate write increment buffer, and it is necessary to normalize the model prediction position range to the pre-set write increment buffer size, that is, multiply the model prediction range by a scaling factor so that this range covers the positions of each bucket in the write increment buffer.

[0067] Since the model parameters occupy extremely little space, the write increment buffer for write function extension only needs a pointer occupying a small amount of space for indexing and is fully cached on the local DRAM of the computing pool server, thereby improving the efficiency of index cache access, without missing the cache of the index structure due to insufficient memory space in the local DRAM of the computing pool server, and further improving the key-value pair access efficiency. Missing requires the CPU in the computing pool server to initiate an access to the remote global index and perform cache replacement.

[0068] The storage pool server constructs a write increment buffer for the learning index model and the reuse model to absorb newly inserted key-value pairs. That is to say, the learning index model is built in the memory of the storage pool DRAM of the storage pool server and is cached by the local DRAM in the computing pool server, so as to be accessed by the working threads on the CPU in the computing pool server.

[0069] The learning index model includes a three-layer structure.

[0070] The bottom layer is a sub-model node, which contains a pointer to the data node, a pointer to the write increment buffer for reusing model parameters, model parameters, data nodes, the maximum value of the range allowed for storing write extended data nodes (this maximum value will be called the anchor key), and a global lock. The initial key-value pairs provided in the preloading stage are trained by the best piecewise linear fitting algorithm. The initial key-value pairs are obtained by sampling from the historical data by the application load using this indexing system and are sorted from small to large. The result of the execution of the best piecewise linear fitting algorithm is to divide these initial key-value pairs into non-overlapping sub-models in terms of coverage. Here, the initial key-value pairs refer to: after sorting the keys by size, the application service using this indexing system evenly samples the historical key-value pair information to obtain the key-value pairs. These key-value pairs are stored in file form and are used as initial key-value pairs in the preloading stage. Different from traditional indexes, a learning index cannot be built from scratch but needs to go through a preloading process to read the historical key-value pair features of the application service using the learning index.

[0071] The middle layer is a recursive index node of the sub-model node, responsible for searching the sub-models. The recursive index node is trained by the best piecewise linear fitting algorithm.

[0072] The top layer is a data range division node. The learning index model will divide the data range according to the training situation of the model in the middle layer according to the principle of uniform distribution and save the pointers to these data ranges. The number of data ranges formed after the top layer division is small. Therefore, for a specific key-value pair key, binary search is used to find the data range it belongs to, and then it jumps to the middle layer for model search. At the same time, if the middle layer is obtained by the best piecewise linear fitting algorithm and the divided data ranges are still too many, the same best piecewise linear fitting algorithm will be recursively used to continue dividing the data range until the data range is small enough (for example, less than 10 data ranges), and a model top layer is formed so that the top layer can perform binary search with high search efficiency to find the data range where the corresponding key is located.

[0073] The computing pool server is also configured to: during the execution of the preloading stage, load the initial key-value pairs into the storage pool server and sort the key-value pairs from small to large. Store the sorting result on the storage pool DRAM of the storage pool server. Use the PLR algorithm to divide the sorted key-value pairs into several sub-model nodes.

[0074] Preferably, each data node will correspond to a sub-model node with a size of 48 bytes. Among them, 8 bytes are used to store a pointer to this data node, 16 bytes are used to store model parameters, 8 bytes are used to store a global lock, 8 bytes record the largest key within the data node, that is, the anchor key, and the remaining 8 bytes are used to record the starting position of the storage write increment buffer. The sub-model node data is stored on the local DRAM of the compute pool server at this stage.

[0075] The write increment buffer calculates the storage location of the new key-value pair to be inserted through the model parameters. This approach will utilize the characteristic of low space occupancy of the model parameters, greatly reducing the subsequent index storage overhead for them.

[0076] Since the storage space of the local DRAM of the compute pool server is much smaller than that of the storage pool DRAM of the storage pool server (for example, the local DRAM is configured with 4GB, while the remote large memory space provided by the storage pool DRAM can reach 4TB), the index built for the large memory needs to be fully cached on the local DRAM of the compute pool server to reduce the microsecond-level access to the uncached index structure on the remote large memory due to index cache misses.

[0077] Recursively train the sub-model nodes to obtain the middle layer and top layer of the index of the sub-model nodes. Initially allocate a continuous address space in the storage pool server as the write increment buffer according to the data node size of the sub-model nodes at the bottom layer of the learning index model.

[0078] Specifically, in a single-point operation, both read and write operations from the compute pool server will use the learning index model cached on the local DRAM of the compute pool server to calculate the first position offset Loc 1 and the second position offset Loc 2 on the data node and the write increment buffer for the key to be accessed, and then initiate an RDMA doorbell batch (an interface provided by the RDMA network programming library) to the storage pool DRAM of the storage pool server.

[0079] The memory addresses of the storage pool DRAM of the storage pool server specified in the RDMA doorbell batch are: Base 1 +Loc 1 *size Bucket and Base 2 +Loc 2 *size Bucket .

[0080] Base 1 and Base 2Record the addresses of data nodes and write increment buffers of the learning index model for the local DRAM cache of the computing pool server on the storage pool DRAM of the storage pool server. Bucket is the storage bucket for the key-value pair data stored in the data node and write increment buffer, which is a continuous address space and can store several key-value pair data.

[0081] The write expansion increment area is a node formed by a continuous address space associated with the data node. When a new key-value pair is inserted, the newly inserted key-value pair is calculated by the learning index model and finally falls into a certain sub-model node, and this sub-model node is responsible for storing the newly added key-value pair.

[0082] In the traditional method, since it is necessary to maintain the ordered relationship of each key-value pair in the sub-model node, a size comparison-based method is adopted, that is, an additional B+ tree / skiplist and other structures are used to absorb additional insertions. An overlooked fact is that the linear model used to predict the storage location of key-value pairs in the read operation can also maintain and indicate the size sorting relationship of newly inserted key-value pairs in the insert operation, because the linear model itself has the property of maintaining order (that is, the larger the key, the larger the storage location calculated by the model for the key). Therefore, the storage location of the newly inserted key-value pair can be calculated without using an additional data structure (such as a B+ tree, skiplist, etc.) for size relationship comparison.

[0083] The essence of the write increment buffer is a node formed by a continuous address space. The newly inserted key-value pair will be calculated by the linear model for the insertion position, and the size relationship of the key itself will be revealed by the size relationship of the insertion position address, so as to ensure that the newly added key-value pairs can still maintain the sorting from small to large, and can also be calculated and found in the read operation.

[0084] The anchor key of the sub-model node forms a recursively trainable structure, that is, the anchor key is used as the training key, and the pointer of the sub-model node is used as the value. The CPU of the computing pool server uses the same method to recursively train the sub-model nodes stored on the local DRAM of the computing pool server to obtain the index of the sub-model nodes, that is, the intermediate layer. Subsequently, according to the index scale, the above sorting steps can be repeated to recursively generate higher-level intermediate layers until the intermediate layer scale is small enough to be used as the top layer. The intermediate layer and top layer models will be stored on the local DRAM of the computing pool server.

[0085] For each underlying sub-model node, the CPU of the computing pool server reads the size of the corresponding index data node recorded on the local DRAM, and initially allocates a continuous address space of the same size on the storage pool DRAM of the storage pool server as the write increment buffer, and shares the training parameters of the sub-model.

[0086] The CPU of the computing pool server transmits the key-value pairs generated in the preloading phase and the initially trained model through the RDMA Write technology via the RDMA network card, and the RDMA network card of the storage pool server writes them into the storage pool DRAM through the DMA technology, making the initially trained learning index model generated in the preloading phase globally visible.

[0087] A schematic diagram of the use of the write expansion increment area in the write expansion method is as Figure 3 shown. In Figure 3 , the learning index model predicts the key key of the key-value pair according to the parameters (model parameters) in the learned model, that is, the prediction model predicts the location loc. Training generates nodes, that is, data nodes generated by the optimal piecewise linear fitting algorithm. Write expansion data nodes are generated by associating with the expansion buffer.

[0088] As Figure 3 shown on the right, during the process of training and generating nodes, [Predict(key6)] = loc5, and inserting into LeafNode fails. During the process of writing expansion data nodes, [Predict(key6) / 2] = loc3.

[0089] Since the redundant size comparison process is avoided, the write expansion method in the present invention will avoid maintaining additional data structures (such as B+ trees, skip lists, etc.), thereby reducing the requirement for additional memory space in the cost brought by the write function expansion of the learning index model. The learning index that supports write function expansion with low memory space occupancy will be fully cached on the limited local DRAM of the computing pool server nodes, improving the efficiency of index caching and ultimately increasing the throughput of key-value pair access.

[0090] The retraining thread in the storage pool server retrains the submodel nodes asynchronously to offload the retraining process to the storage pool server. The retraining thread scans and trains the key-value pairs in the submodel, generates new underlying submodel nodes, and updates the write increment buffer, and dynamically adjusts the size of the write increment buffer based on the data insertion characteristics under the submodel coverage.

[0091] The working thread on the CPU of the computing pool server communicates with the working thread on the CPU of the storage pool server using the bilateral RDMA primitive in the open-source RDMA library, and sets the message type to retraining in the data packet, thereby offloading the submodel retraining process in the storage pool DRAM.

[0092] The working thread on the CPU of the storage pool server will apply for a new retraining thread to initiate retraining of the sub-model asynchronously. Offloading the retraining process to the storage pool DRAM will prevent key-value pairs within the range to be trained from being sent back to the local DRAM storage space of the compute pool server by the RDMA network card of the storage pool server, thus avoiding waste of the limited RDMA network bandwidth and improving the efficiency of the retraining process.

[0093] The retraining thread first scans and trains the key-value pairs within the sub-model, using the optimal piecewise linear fitting algorithm to obtain several new underlying sub-model nodes, and generating respective data nodes and new write increment buffers that reuse new parameters for them. Subsequently, the retraining thread will use bilateral RDMA primitives to notify each compute pool server of the retraining results. Each compute pool server will synchronize the retraining results and hold data nodes of both the new and old versions of the atomic model. Insertion of new data nodes and redirection of old key-value pairs by the retraining thread will occur on the new data nodes. Read operations will occur on data nodes of both the new and old versions, so that the offloaded retraining process will not block write operations, truly achieving decoupling of the insertion operation and the retraining offloading operation.

[0094] Preferably, Figure 4 and Figure 5 The data access path during the insertion-retraining decoupling process under the multi-version mechanism is shown.

[0095] As Figure 4 shown, the CPU on the compute pool server will obtain the new parameters generated after retraining of the old model, but hold both the new model parameters and the old model parameters, and write the new parameters into the local DRAM memory on the compute pool server to form a local index cache. The compute pool server calculates the remote node memory addresses based on the new and old model parameters and inputs them to the storage pool server through the RDMA network card.

[0096] The RDMA network card in the storage pool server accesses the corresponding data nodes and write extended data nodes according to the transmitted memory addresses. In the storage pool DRAM, training generates nodes, associates write extended buffers, and forms new data nodes for subsequent writes.

[0097] Or, training generates nodes, associates write extended buffers, and forms old data nodes that will not be modified.

[0098] As Figure 5 shown, the CPU in the storage pool server asynchronously migrates the old data nodes to the new write increment buffer by the storage pool node thread to form new data nodes for subsequent writes.

[0099] As Figure 5As shown in the figure, the retraining thread on the CPU of the storage pool server asynchronously migrates the old data nodes on the storage pool DRAM of the storage pool server and the data on the old write increment buffer to the new data nodes and the new write increment buffer on the storage pool DRAM of the storage pool server. After completion, the retraining thread will feedback the completion status to the management thread of the CPU of the storage pool server, and the management thread of the storage pool server will transmit the result to the local DRAM of each computing pool server node in the form of a bilateral RDMA primitive, thus completing the retraining offloading process.

[0100] Preferably, the storage pool server is configured to: monitor the messages of the bilateral RDMA primitive technology of the computing pool server based on a preset management thread; pass the anchor point of the interval where retraining occurs as a parameter. Search for the anchor point in the messages of the bilateral RDMA primitive technology based on the learning index model, and retrain the old sub-model into a new sub-model node according to the search result. Fill the model parameters of the new sub-model node and the corresponding anchor point information, and allocate data nodes and write increment buffers. The management thread sends the new sub-model node to each computing pool server in the form of a bilateral RDMA primitive, so that the computing pool server updates the sub-model node.

[0101] The storage pool server is provided with a management thread running on the CPU to listen for messages from the computing pool server based on the bilateral RDMA primitive technology. The working thread running on the CPU of the computing pool server will send a message encapsulated based on the bilateral RDMA primitive to the RDMA network card on the storage pool server through the RDMA network card, and finally send it to the storage pool DRAM memory on the storage pool server through the DMA technology, which is sensed by the management thread running on the CPU of the storage pool server. The type of the message is retraining, and the anchor point key of the retraining interval is the anchor point key recorded by the sub-model node.

[0102] After receiving the message, the management thread running on the CPU of the storage pool server will start an asynchronous thread and pass the anchor point key of the interval where retraining occurs as a parameter. The asynchronous thread performs a corresponding search operation on the learning index model on the storage pool DRAM, finds the old sub-model node to be retrained, and uses the best piecewise linear fitting algorithm to retrain the key-value pair data on the data nodes covered by the sub-model and the write extension nodes, obtaining several new sub-model nodes.

[0103] By re-encapsulating the messages of the bilateral RDMA primitive, the retraining process originally executed by the CPU on the computing pool server is offloaded to the CPU on the storage pool server, thus avoiding the transmission of the key-value pair data to be retrained in the RDMA network, and further avoiding the waste of the limited RDMA network bandwidth, thereby improving the overall throughput of the index system.

[0104] According to a preferred embodiment, the retraining thread asynchronously migrates the data of the old sub-model nodes and the old write increment buffer to the new sub-model nodes and the new write increment buffer, and feeds back the completion status to the management thread after completion.

[0105] Preferably, the retraining thread on the CPU of the storage node fills the model parameters of the new sub-model nodes and the corresponding anchor key information, and allocates data nodes and write increment buffers for them on the local DRAM of the storage node. The size Size of the data nodes Node is determined during the execution of the algorithm. After making a segmentation of the data nodes in the old sub-model nodes and the key-value pairs in the write increment buffer based on the optimal piecewise linear fitting algorithm, the number N of key-value pairs on the original data nodes in each segment is counted 1 and the number N of key-value pairs located on the write increment buffer 2 . The calculation method of the write increment buffer size is:

[0106] Size Buffer =min(N 2 / N 1 *Size Node ,2*Size Node ), N2 / N1>1;

[0107] Size Buffer =max(N 2 / N 1 *Size Node ,0.5*Size Node ), N2 / N1<1;

[0108] Size Buffer represents the size of the write increment buffer, Size Node represents the size of the data nodes, N 1 represents the number of key-value pairs on the original data nodes, N 2 represents the number of key-value pairs located on the write increment buffer.

[0109] Based on this formula, a new write increment buffer size is allocated for the newly generated sub-model nodes on the storage pool DRAM of the storage pool server.

[0110] The calculation pool server is also configured to: search based on the cache of the learning index model to determine the first position offset Loc on the data node to be accessed 1 and the second position offset Loc on the write increment buffer 2 . Calculate the access space size of the read and write operations: Size = Size Bucket *N; Size BucketIndicates the size of the bucket, N indicates the number of buckets for linear probing, and Size indicates the size of the read space specified by the read and write operations. Then the access space range of the read and write operations is [Loc 1 , Loc 1 + Size] and [Loc 2 , Loc 2 + Size].

[0111] Through the method of posterior perception, if there are more key-value pairs in the write increment buffer, this segment is considered a hot segment and will absorb more newly inserted key-value pairs subsequently. Therefore, a larger write increment buffer size is allocated for the newly generated sub-model nodes on the storage pool DRAM of the storage pool server; otherwise, a smaller write increment buffer size is allocated on the storage pool DRAM of the storage pool server. Through this adaptive method, the space waste caused by a single write increment buffer size is avoided.

[0112] Figure 6 And Figure 7 show a schematic diagram of optimizing the memory space usage range of the write increment buffer. In Figure 6 , within the range divided by the PLR algorithm: The training generation node contains Nf = 7 key-value pairs. The write extension data node contains Nb = 12 key-value pairs. The ratio is Ratio = Nb / Nf = 1.71 > 1. Posterior perception (posteriorly considered) that the coverage range of this new sub-model is a hot range, and a larger write extension data node is allocated for the newly generated sub-model nodes. The PLR algorithm scans the training generation node and the write extension data node and automatically makes a range division between the two nodes.

[0113] In Figure 7 , within the range divided by the PLR algorithm: The training generation node contains Nf = 7 key-value pairs. The write extension data node contains Nb = 3 key-value pairs. The ratio is Ratio = Nb / Nf = 0.43 < 1. Posterior perception (posteriorly considered) that the coverage range of this new sub-model is a cold range, and a smaller write extension data node is allocated for the newly generated sub-model nodes. The PLR algorithm scans the training generation node and the write extension data node and automatically makes a range division between the two nodes.

[0114] The method for optimizing the memory space usage efficiency of the write increment buffer includes: generating different initial size regions for the write increment buffer in a static adjustment manner, so as to allocate different write increment buffer sizes for different sub-model nodes, and avoid unnecessary space waste caused by a write increment buffer of a single size.

[0115] Since the data insertion features under different sub-model coverage ranges are different, dynamically adjusting the initial size of the write increment buffer will allocate a larger write increment buffer for the range with more inserted key-value pairs and a smaller write increment buffer for the range with fewer inserted key-value pairs, thereby saving the use of the storage pool DRAM space.

[0116] In the bulk loading phase, the initial write increment buffer will be set to the same size as the data node to conform to the expected data distribution during initial training. In the retraining phase, when reallocating the write increment buffer, the size will be adjusted according to the ratio of the number of key-value pairs in the write increment buffer within the data range covered by the new sub-model during retraining to the number of key-value pairs in the static index data node. At the same time, to further improve the space utilization rate of the write increment buffer, the worker threads of the compute pool server will use linear probing to access several buckets on the write increment buffer at one time and find accessible positions.

[0117] Embodiment 2

[0118] This embodiment is an illustration of Embodiment 1, and repeated content will not be elaborated.

[0119] Consider a cloud storage service provider offering object storage services externally. The cloud storage service provider stores the mapping relationship of obj id (object ID) to obj content (object content). Due to the requirement of the cloud platform for efficient and elastic resource configuration, resource decoupling becomes very important in such a scenario, which determines whether the operating cost of the cloud storage service provider can be reduced. The cloud storage service provider adopts a split memory architecture and a learning index model for split memory that supports write operations to support the externally provided elastic and efficient object storage services. The specific steps are as follows:

[0120] S110: Reuse the write increment buffer structure of the model.

[0121] In the data center platform of a cloud storage service provider, a large amount of object data is stored in the storage pool DRAM of the storage pool server in the form of key-value pairs. The storage pool DRAM of the storage pool server also stores a learning index model. Since the model parameters are reused to construct the write increment buffer, the metadata space occupation required for indexing the write increment buffer is reduced, so that the compute pool server can use the limited local DRAM to fully cache the learning index model located on the storage pool DRAM of the storage pool server. When a user performs a viewing operation on an object, the working thread of the compute pool server can directly access the index cache on the local DRAM, find the storage location of the object data on the storage pool server at a latency of nanoseconds, and read it. The advantage of this is that for the access of object data, the compute pool server does not need to read the uncached index node at a latency of microseconds first, thus reducing the response latency.

[0122] S120: Implement the retraining decoupling mechanism.

[0123] In the object storage service of a cloud storage service provider, when a user adds more object data to the system, the old model nodes may become invalid due to the change in the distribution relationship of the learned old object IDs gradually damaged by the newly inserted object IDs, thus requiring retraining to obtain a new model. This is caused by the addition of new objects, and the retraining process will take a long time. This causes the user to trigger the retraining operation when performing some object addition operations, and thus block the system, so that the current object addition operation faces a latency of milliseconds. The retraining decoupling mechanism moves the retraining out of the critical path of the insertion operation, so that the user can get a fast response at any time when using the object storage server of the cloud storage service provider.

[0124] S130: Implement the object storage mechanism of linear probing.

[0125] Adopting the method of constructing the write increment buffer based on the reused model essentially exchanges the storage pool server space for read and write performance. By introducing the method of linear probing, when an object is added, several consecutive storage spaces are linearly searched after the insertion position, so that the load factor of the write increment buffer rises, saving the use of the storage pool DRAM storage space of the storage pool server.

[0126] By implementing the method of the present invention, the cloud storage service provider can support the learning index model for write operations, and the object storage service of the cloud storage service provider achieves the following technical effects:

[0127] First, improve the access efficiency of object data: By directly accessing the learning index model that is fully cached on the local DRAM of the compute pool server to directly locate the object data, the platform can ensure that the user's access requests can be responded to quickly. For example, when a user reads the content of an object, the result can be obtained in less than a microsecond. If the index is not fully cached on the local DRAM of the compute pool server, traversing the index structure on the storage pool server will cause delays at the microsecond or even millisecond level. At the same time, since the CPU processor burden of the compute pool server is reduced, the throughput of the system is also improved, and the object storage service will serve more user requests per unit time.

[0128] Second, reduce the response latency of object data access: During peak periods, due to a large number of object addition operations by users, the system may retrain because the model fails. By decoupling the insert-retrain operation and moving the retrain operation out of the critical path of the insert operation, the time-consuming retrain operation will not block the system, enabling the user's object addition operation to always be responded to and feedback with a low latency.

[0129] Third, improve the utilization rate of the storage pool DRAM space: Through the linear probing mechanism, object storage can be stored in the continuous space after the predicted location, effectively solving the problem of wasted storage space caused by model prediction conflicts. Cloud storage service providers will be able to achieve efficient object storage management services at a lower storage cost.

[0130] This case demonstrates the successful application of the learning index model for disaggregated memory in the cloud storage service provider platform. By reusing model parameters to construct a write increment buffer and decoupling the insert and retrain mechanisms, the cloud storage service provider platform will provide low-latency and high-throughput object storage services; through the linear probing mechanism, the storage cost overhead of cloud storage service providers can be further reduced. Such a technical solution can help cloud storage service providers stand out in the highly competitive market and improve user retention rate and user stickiness.

[0131] It should be noted that the above specific embodiments are exemplary. Those skilled in the art can come up with various solutions inspired by the disclosure of the present invention, and these solutions also fall within the scope of the disclosure of the present invention and within the protection scope of the present invention. Those skilled in the art should understand that the description and drawings of the present invention are illustrative and do not constitute a limitation on the claims. The protection scope of the present invention is defined by the claims and their equivalents. The description of the present invention contains multiple inventive concepts. For example, "preferably" and "according to a preferred embodiment" both indicate that the corresponding paragraphs disclose an independent concept. The applicant reserves the right to file divisional applications based on each inventive concept.

Claims

1. A learning index write expansion system based on separated memory, characterized in that: include: The compute pool server holds a pointer to the write increment buffer of the reuse model and determines the insertion position of the key-value pair based on the linear model in the cached learned index model; The storage pool server builds the incremental write buffer of the learning index model and the reuse model to absorb newly inserted key-value pairs; The retraining thread in the storage pool server asynchronously retrains the sub-model to offload the retraining process to the storage pool server; the retraining thread scans and trains the key-value pairs in the sub-model, generates new underlying sub-model nodes, and updates the write incremental buffer, while dynamically adjusting the size of the write incremental buffer based on the data insertion characteristics under the sub-model coverage; The computing pool server updates the cached sub-model and the pointer to the write incremental buffer held by the sub-model based on the retraining thread execution result of the storage pool server.

2. The system according to claim 1, characterized in that The computing pool server is further configured to: load initial key-value pairs into the storage pool server during the preloading phase, and sort the key-value pairs from small to large; Dividing the sorted key-value pairs into a plurality of sub-model nodes; Recursively training the sub-model nodes to obtain the middle layer and the top layer of the index of the sub-model nodes; The continuous address space in the storage pool server is initially allocated as a write incremental buffer according to the data node size of the underlying sub-model node of the learning index model.

3. The system according to claim 1 or 2, characterized in that: The storage pool server is configured as: Monitoring the bilateral RDMA primitive technology message of the computing pool server based on a preset management thread; Pass the anchor point of the interval where the retraining will occur as a parameter; Searching for anchor points in the message of the bilateral RDMA primitive technology based on the learned index model, and retraining the old sub-model into a new sub-model according to the search results; Filling the model parameters of the new sub-model node and the corresponding anchor point information, and allocating data nodes and writing incremental buffers; The management thread sends the new sub-model node to each of the computing pool servers in a bilateral RDMA primitive manner, so that the computing pool server updates the sub-model node.

4. The system according to any one of claims 1 to 3, characterized in that: The storage pool server is further configured to: The retraining thread asynchronously migrates the data of the old sub-model node and the old write incremental buffer to the new sub-model node and the new write incremental buffer, and feedbacks the completion status to the management thread after completion.

5. The system according to any one of claims 1 to 4, characterized in that: The computing pool server is further configured to: after segmenting the data nodes in the old sub-model node and the key-value pairs in the write incremental buffer based on the best piecewise linear fitting algorithm, count the number N1 of key-value pairs on the original data nodes in each segment and the number N2 of key-value pairs located in the write incremental buffer; The write increment buffer size is calculated as: Size Buffer =min(N2 / N1*Size Node ,2*Size Node ),N2 / N1>1; Size Buffer =max(N2 / N1*Size Node ,0.5*Size Node ),N2 / N1<1; Among them, Size Buffer Indicates the size of the write incremental buffer, Size Node Represents the size of the data node, N1 represents the number of key-value pairs on the original data node, and N2 represents the number of key-value pairs in the write incremental buffer.

6. The system according to any one of claims 1 to 5, characterized in that: The computing pool server is also configured as: Search based on the cache of the learning index model to determine the first position offset Loc1 on the data node to be accessed and the second position offset Loc2 on the write incremental buffer, Calculate the access space size for read and write operations: Size=Size Bucket *N; Size Bucket Indicates the size of the bucket, N indicates the number of buckets for linear detection, and Size indicates the size of the read space specified by the read and write operations; Then the access space range for read and write operations is [Loc1, Loc1+Size] and [Loc2, Loc2+Size].

7. A learning index write expansion method based on separated memory, characterized in that: The method comprises: Set a pointer to the write increment buffer of the reuse model, and determine the insertion position of the key-value pair based on the linear model in the cached learning index model; Build a learning index model and a write incremental buffer for the reuse model to absorb newly inserted key-value pairs; Among them, a retraining thread is used to asynchronously retrain the sub-model to offload the retraining process to the storage pool server; the retraining thread scans and trains the key-value pairs of the sub-model, generates new underlying sub-model nodes, and updates the write incremental buffer; and at the same time, the size of the write incremental buffer is dynamically adjusted based on the data insertion characteristics under the coverage of the sub-model; Based on the execution results of the retraining thread of the storage pool server, the cached sub-model and the pointer to the write incremental buffer held by the sub-model are updated.

8. The method according to claim 7, characterized in that The method further comprises: In the pre-loading phase, the initial key-value pairs are loaded into the storage pool server and the key-value pairs are sorted from small to large. Dividing the sorted key-value pairs into a plurality of sub-model nodes; Recursively training the sub-model nodes to obtain the middle layer and the top layer of the index of the sub-model nodes; The continuous address space in the storage pool server is initially allocated as a write incremental buffer according to the data node size of the underlying sub-model node of the learning index model.

9. The method according to claim 7 or 8, characterized in that: The method further comprises: Monitoring the bilateral RDMA primitive technology messages of the computing pool server based on the preset management thread; Pass the anchor point of the interval where the retraining will occur as a parameter; Searching for anchor points in the message of the bilateral RDMA primitive technology based on the learned index model, and retraining the old sub-model into a new sub-model according to the search results; Filling the model parameters of the new sub-model node and the corresponding anchor point information, and allocating data nodes and writing incremental buffers; The management thread sends the new sub-model node to each computing pool server in a bilateral RDMA primitive manner, so that the computing pool server updates the sub-model node.

10. The method according to any one of claims 7 to 9, characterized in that: The method further comprises: The retraining thread asynchronously migrates the data of the old sub-model node and the old write incremental buffer to the new sub-model node and the new write incremental buffer, and feeds back the completion status to the management thread after completion.

Images