A data processing and cloud storage method based on a cloud computing architecture

Abstract

This invention discloses a data processing and cloud storage method based on a cloud computing architecture. The invention relates to the field of big data storage and management technology. This method constructs a flattened hybrid index tree, residing the root node and first-level index nodes in a CXL shared memory pool based on access popularity scores, while the leaf nodes are mapped to the local memory of the DPU, forming a unified addressing structure across media. The method performs syntax parsing on query statements and determines pushdown feasibility. Pushdown-enabled query logic is compiled into eBPF bytecode and sent to the DPU storage node for nearby filtering, aggregation, and feature matching operations. Only the filtering result set is returned. The method predicts the data block hit probability based on historical query trajectories. When the compute node starts up, it writes local index blocks and hot datasets through direct memory access via CXL, completing the local index context reconstruction. This invention is used to reduce cross-network access latency and cold start latency under a compute-storage separation architecture, and to reduce network bandwidth consumption.

Description

Technical Field

[0001] This invention relates to the field of big data storage and management technology, specifically a data processing and cloud storage method based on cloud computing architecture. Background Technology

[0002] As cloud computing technology evolves towards a serverless architecture, storage-compute separation has become the main technical paradigm in the field of cloud-native big data storage and management. Under this architecture, computing resources run in elastically scalable container pools, data is persisted in distributed cloud storage systems, and computing and storage interact through cloud data center networks. Data retrieval and query processing mainly rely on tree-structured indexes. The root nodes, intermediate nodes, and leaf nodes of such indexes are organized according to a unified storage medium and access path, and the location and access between nodes rely on multi-level pointers chasing layer by layer.

[0003] In the existing cloud-based big data retrieval method closest to this invention, after receiving a query request, the computing node pulls index blocks from the remote storage cluster to local memory through the cloud network and traverses layer by layer to locate the target data location. Then, it continues to pull the original data blocks that have been hit through the network and performs filtering operations on the full amount of data pulled locally on the computing node. In this existing method, the index structure and the original data are stored in the remote storage cluster. There is no near-data processing capability collaboration between the computing node and the storage cluster. Index access and data filtering calculations both require the entire data to be moved to the computing side to complete. Moreover, before the newly expanded computing node completes the above process, it is always in an initial state without cache and without index context. This results in high query latency, a large amount of network bandwidth being occupied, and the new memory pooling and hardware acceleration capabilities are not effectively utilized by the existing index structure and query execution mechanism. Summary of the Invention

[0004] The technical problem this invention aims to solve is: in cloud computing storage-compute separation and serverless architecture, when newly expanded computing nodes process big data retrieval, range query, aggregation operation, and feature matching operation requests, due to the lack of local index context and data cache, they need to move index files and original data blocks to the remote storage cluster through the cloud network. This results in high query latency, network bandwidth being occupied by invalid data movement, and the ineffective utilization of CXL pooled memory and DPU hardware capabilities by the existing index structure and query execution mechanism.

[0005] To address the aforementioned technical problems, this invention provides a data processing and cloud storage method based on a cloud computing architecture, comprising: partitioning the entire dataset according to the key value range, generating index nodes for each partition, performing hierarchical mapping of each index node according to access popularity scores, mapping the root node and first-level index node whose access popularity scores exceed a preset threshold to the CXL shared memory pool, mapping the remaining leaf nodes to the corresponding DPU local memory, and updating the pointers to lower-level nodes in the root node and first-level index nodes to point to the physical address of the corresponding leaf node in the DPU local memory, thereby forming a flattened hybrid index tree spanning the CXL shared memory pool and the DPU local memory;

[0006] The system receives query requests initiated by compute nodes, performs lexical and syntactic parsing on the query statements in the query requests, generates corresponding abstract syntax trees, determines the feasibility of pushing down query operators in the abstract syntax trees according to preset operator pushdown rules, compiles the pushdown-feasible query logic into eBPF bytecode and sends it to the target DPU storage node, the target DPU storage node performs security verification on the received eBPF bytecode and loads it into the sandboxed execution environment, calls the local leaf node index to complete the physical address location of the target data, and performs at least one of the following operations on the original data in the DPU local memory: filtering, aggregation, and feature matching, to obtain a filtered result set, and sends the filtered result set back to the compute node that initiated the query via the network.

[0007] Collect the index block numbers and data block numbers hit by queries initiated in the past from each compute node to form a query trajectory log. Based on the query trajectory log, predict and update the hit probability of each data block. Listen for the start-up event of the compute node. Determine the prefetch object set based on the historical associated query context identifier to which the start-up compute node belongs and the predicted hit probability. After detecting the start-up event of the target compute node, write the local index blocks and hot datasets in the prefetch object set into the memory address space allocated to the target compute node through CXL direct memory access, and complete the reconstruction of the local index context of the target compute node.

[0008] Compared with the prior art, the beneficial effects of the present invention by adopting the above technical solution are as follows:

[0009] 1. This invention reduces the index location latency under the storage-compute separation architecture by residing the root node and first-level index node with high access frequency in the CXL shared memory pool and mapping the leaf nodes to the DPU local memory, thus compressing the hierarchical depth of the index tree into a fixed two-layer logical structure. The node access path is changed from cross-network multi-hop pointer chasing to CXL memory semantic access.

[0010] 2. This invention compiles feasible query logic into eBPF bytecode and sends it to the DPU storage node for nearby filtering, aggregation, and feature matching operations. This allows the original data to be calculated on the storage side and only the filtering result set to be sent back. This avoids the process of moving the hit data fragments to the computing side as a whole, thereby reducing the situation where invalid data occupies the network bandwidth in the cloud.

[0011] 3. This invention predicts the hit probability of data blocks based on historical query trajectories, and at the same time as the computing node is started, the DPU storage node actively writes the local index block and hot dataset into the memory of the computing node through CXL direct memory access, so that the computing node can have a local index context after being started, thereby shortening the cold start waiting time experienced by the computing node from start-up to having retrieval capabilities. Attached Figure Description

[0012] Figure 1 This is a flowchart illustrating the overall system architecture in an embodiment of the present invention.

[0013] Figure 2 This is a flowchart illustrating the construction process of a flattened hybrid index tree in an embodiment of the present invention.

[0014] Figure 3 This is a flowchart of the query pushdown and DPU filtering + cold start prefetch in an embodiment of the present invention. Detailed Implementation

[0015] The following is in conjunction with the appendix Figure 1-3 The specific embodiments of the present invention will be further described below. It should be noted that the description of these embodiments is for the purpose of helping to understand the present invention, but does not constitute a limitation of the present invention.

[0016] The technical solution of the present invention will be further described below with reference to specific embodiments. It should be noted that the computing node described in the present invention runs in the form of a container in a serverless computing node pool. For ease of description, the computing node will be used to refer to the computing entity running in the form of a container in the following text.

[0017] I. System Overall Architecture

[0018] The method described in this invention operates on a cloud computing infrastructure comprising a CXL shared memory pool, a DPU storage node cluster, a Serverless compute node pool, and a cloud control plane. The cloud control plane receives query requests initiated by compute nodes and internally includes a query access module, an AST parser, and an eBPF compiler to sequentially complete the access, syntax parsing, and bytecode compilation of pushdown logic for the query statement. The CXL shared memory pool hosts the root nodes and first-level index nodes with higher priority residing in the flattened hybrid index tree, and establishes low-latency data paths with the cloud control plane, the DPU storage node cluster, and the Serverless compute node pool respectively through the memory semantic access method of the CXL bus. The U storage node cluster consists of multiple DPU storage nodes. Each DPU storage node is configured with a leaf node storage area, an eBPF execution engine, a query trajectory prediction module, and a hot data cache area. It also establishes a data persistence relationship with the underlying cloud object storage or distributed block storage. The Serverless computing node pool consists of multiple elastically scalable computing nodes. Each computing node establishes a data interaction relationship with the CXL shared memory pool and the DPU storage node cluster through a memory semantic access path labeled as a CXLDMA channel. The above four parts together constitute the operating environment of the method described in this invention, respectively undertaking the functions of query parsing and compilation, index data pooling and carrying, storage-side computing sinking and execution, and query initiation and cold start prefetching.

[0019] II. Construction of a Flattened Hybrid Index Tree and Hierarchical Mapping of Nodes

[0020] The flattened hybrid index tree described in this invention adopts a wide-node flattened design. Compared with the traditional multi-level deep index structure, its tree height is compressed to a fixed two logical levels. The first level consists of a root node and a first-level index node, which reside in the CXL shared memory pool. Each index node adopts a wide fan-out design and is memory aligned according to the cache line transmission characteristics of the CXL bus. The alignment granularity can be 64 bytes or 256 bytes.

[0021] The second layer is the leaf node layer, which is directly mapped to the local memory of the corresponding DPU storage node. The leaf nodes store the actual key-value pairs and the physical address pointers pointing to the original data blocks.

[0022] The determination of node residency location adopts a scoring mechanism based on access popularity. For each node in the index tree, its residency priority score is calculated, and nodes with higher scores reside in the CXL shared memory pool. The calculation method is as follows:

[0023] ;

[0024] In the formula, Indicates the first The residency priority score of each index node;

[0025] Indicates the first Normalized values ​​of historical access frequency of each index node within a preset statistics window;

[0026] Indicates the first The access time recentity normalized value of each index node;

[0027] and These are the weighting coefficients corresponding to the normalized value of historical access frequency and the weighting coefficients corresponding to the normalized value of access time recentity, respectively. Both values ​​are greater than 0 and less than 1, and their sum is 1. In one specific embodiment, It can take the value 0.6. A value of 0.4 is acceptable to reflect the dominant influence of access frequency on residency determination. This value is only an example and does not constitute a limitation on the value of the weighting coefficient.

[0028] During system operation, the control plane first partitions the entire dataset according to the key value range, generates an initial index node for each partition, and organizes the index nodes into an initial flattened candidate tree structure according to the key value range.

[0029] Subsequently, the historical access frequency and access time of each index node in the candidate tree structure are continuously collected and updated periodically according to the preset statistical window.

[0030] Based on this, for each index node in the candidate tree structure, its resident priority score is calculated according to the aforementioned scoring method. The root node and first-level index node with scores exceeding the preset threshold are allocated and written to the corresponding address space of the CXL shared memory pool through the CXL memory mapping interface. The remaining leaf nodes are allocated and written to the DPU local memory space corresponding to their respective storage partitions.

[0031] Then, the pointers to lower-level nodes in the root node and first-level index node are updated to point to the physical address of the corresponding leaf node in the DPU local memory, completing the unified addressing mapping across the CXL shared memory pool and the DPU local memory. The above node access statistics collection, scoring calculation and hierarchical mapping process is repeated periodically according to the preset statistical window. The resident position of the node between the CXL shared memory pool and the DPU local memory is dynamically adjusted according to the changes in node access popularity to adapt to changes in query load.

[0032] III. Intent-Driven Computational Pushdown and DPU Native Filtering

[0033] Based on the completion of the flattened hybrid index tree construction, this invention further provides a mechanism to sink the query calculation logic to the DPU storage node for execution nearby. After the cloud control plane receives the query request initiated by the computing node, it calls the AST parser to perform lexical and syntactic analysis on the query statement (including range query conditions, aggregate functions and feature matching expressions) and generate the corresponding abstract syntax tree.

[0034] The control plane then traverses each node of the abstract syntax tree and performs a semantic determination of pushdown feasibility based on the preset operator pushdown rule base. The determination criteria include whether the query operator is one of the filtering, aggregation, and feature matching operators without side effects, and whether the data on which the operator depends has been located in the target DPU storage node. For the syntax tree subtree determined to be pushable, the control plane compiles its corresponding query logic into eBPF bytecode that conforms to the instruction set constraints of the target DPU execution environment. Boundary check instructions are inserted during the compilation process to ensure execution safety.

[0035] After receiving the eBPF bytecode, the target DPU storage node performs memory boundary checks, loop termination checks, and permission compliance checks on the bytecode using its built-in validator. Once the checks pass, the bytecode is loaded into the DPU sandboxed execution environment. The DPU execution engine then calls the leaf node index of the local flat hybrid index tree to locate the physical address of the target data and directly performs filtering, aggregation, or feature matching operations on the original data in the DPU's local memory. This operation is completed in the DPU's local memory without cross-network data transfer. The DPU then sends the filtered result set obtained after the execution back to the compute node that initiated the query via the cloud network. For query logic corresponding to query operators that do not meet the pushdown conditions, the traditional method of transferring the original data to the compute node is still followed, and the compute node performs subsequent processing on the filtered intermediate result set as a fallback processing path.

[0036] The data reduction effect brought about by the above calculation pushdown mechanism can be measured in the following ways:

[0037] ;

[0038] In the formula, Indicates the reduction rate of network transmission data;

[0039] This represents the amount of result set data actually transmitted back over the network after being filtered by the DPU storage node.

[0040] This indicates the amount of raw data that would need to be transferred using the traditional full-data transfer method. The closer the value is to 1, the more significant the network bandwidth saving effect of the calculation pushdown mechanism described in this invention.

[0041] IV. Cold Start Prefetching and State Reconstruction Based on Query Trajectory Prediction

[0042] To address the issue of the lack of local index context during the cold start phase of compute nodes, this invention further provides an active prefetching and memory state reconstruction mechanism based on query trajectory prediction. The DPU storage node continuously records the index block number and data block number hit by queries initiated by each compute node in the past, forming a time-seriesd query trajectory log.

[0043] Based on this query trajectory log, the DPU storage node uses a weighted recursive method to predict and update the hit probability of each data block at the next time step. The calculation method is as follows:

[0044] ;

[0045] In the formula, Represents data block The predicted hit probability at the next statistical moment;

[0046] Represents data block The probability of hitting at the current statistical moment;

[0047] Represents data block The indicator value for whether the target was actually hit at the current statistical moment is 1 when the target was hit and 0 when the target was not hit.

[0048] This is the historical weight decay coefficient, with a value range greater than 0 and less than 1. It is used to balance the influence of historical hit records and the latest hit records on the prediction results.

[0049] DPU storage nodes monitor the creation and startup events of compute nodes in real time through an event subscription interface with the cloud-based serverless scheduling plane. They obtain the tenant identifier and historical associated query context identifier of the started compute node, and based on this attribution information and the predicted hit probability... A preset number of local index blocks and hot data blocks are selected according to their hit probability from high to low to form a prefetch object set. After detecting the start-up event of the target compute node, the DPU storage node actively initiates a CXL direct memory access write operation to write the local index blocks and hot data sets in the prefetch object set directly into the memory address space allocated to the compute node through CXL memory semantics. The compute node does not need to initiate an explicit network fetch request throughout the process. After the compute node detects that the prefetch data written in the above manner already exists in its local memory, it completes the reconstruction of the local index context and marks itself into a stateful retrieval state. Subsequent query requests can be responded to directly based on the local prefetch data and the flattened hybrid index tree without having to go through the complete cold start data loading process.

[0050] The cold start latency of a compute node can be represented as follows:

[0051] ;

[0052] In the formula, This represents the total cold start latency experienced by a computing node from its initial setup to when it has retrieval capabilities;

[0053] This indicates the time taken to complete hotspot prediction and determine the prefetch object set;

[0054] This indicates the time taken to complete data transfer via the CXL direct memory access channel;

[0055] This represents the time taken for a compute node to complete the local state reconstruction marker, due to Based on CXL memory semantics transfer, its time consumption is lower than that of traditional cross-network input / output pull, so the method described in this invention helps to shorten the cold start latency of computing nodes.

[0056] V. Alternative Implementation Methods

[0057] In data center environments without CXL hardware support, a high-speed RDMA network can be used to replace the CXL shared memory pool. The root node and first-level index node of the flat hybrid index tree are centrally deployed on a memory server cluster equipped with RDMA network cards. Both compute nodes and DPU storage nodes remotely access the index data in the memory server cluster through the RDMA protocol. Without changing the existing network infrastructure, the same technical effect of reducing the number of hops across the network for index access is achieved.

[0058] In the calculation pushdown stage, instead of using eBPF bytecode as the pushdown execution carrier, a standardized operator library pre-compiled and deployed in the DPU storage node firmware can be used. This standardized operator library has pre-built filtering operators, summation operators, counting operators and regular matching operators.

[0059] After completing the abstract syntax tree parsing, the cloud control plane maps the query logic to a call sequence and parameter configuration of several operators in the standardized operator library, and sends the call sequence to the DPU storage node for execution. The DPU storage node executes the corresponding firmware operators in the order of the call sequence to complete the data filtering process. This alternative implementation method can further reduce the security verification overhead in the push-down execution process while reducing the flexibility of the query logic, and is suitable for application scenarios with relatively fixed query patterns.

[0060] The above-described specific implementation and alternative implementation methods employ three mechanisms—index structure media hierarchical residency, query computation storage-side execution, and data prefetching proactive push—to work together to achieve the technical effects of reducing cross-network access latency, reducing invalid network bandwidth occupation, and compressing cold start latency of computing nodes under the storage-compute separation architecture. Those skilled in the art should understand that, without departing from the essence of the technical solution of this invention, equivalent substitutions or simple modifications to the above implementation methods should fall within the protection scope of this invention.

[0061] Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make possible changes and modifications without departing from the spirit and scope of the present invention. Therefore, any modifications, equivalent changes and alterations made to the above embodiments based on the technical essence of the present invention without departing from the content of the technical solution of the present invention shall fall within the protection scope defined by the claims of the present invention.

Claims

1. A data processing and cloud storage method based on a cloud computing architecture, characterized in that, include: The entire dataset is partitioned according to the key value range, and an index node is generated for each partition. The index nodes are mapped hierarchically according to the access popularity score. The root node and the first-level index node whose access popularity score exceeds the preset threshold are mapped to the CXL shared memory pool, and the remaining leaf nodes are mapped to the corresponding DPU local memory. The pointers to the lower-level nodes in the root node and the first-level index node are updated so that they point to the physical address of the corresponding leaf node in the DPU local memory, thus forming a flattened hybrid index tree across the CXL shared memory pool and the DPU local memory. The system receives a query request initiated by a compute node, performs lexical and syntactic parsing on the query statement in the query request, generates a corresponding abstract syntax tree, determines the feasibility of pushing down the query operators in the abstract syntax tree according to preset operator pushdown rules, compiles the pushdown-feasible query logic into eBPF bytecode and sends it to the target DPU storage node, the target DPU storage node performs security verification on the received eBPF bytecode and loads it into the sandboxed execution environment, calls the local leaf node index to complete the physical address location of the target data, and performs at least one operation of filtering, aggregation and feature matching on the original data in the DPU local memory to obtain a filtered result set, and transmits the filtered result set back to the compute node that initiated the query through the network. Collect the index block numbers and data block numbers hit by queries initiated in the past from each computing node to form a query trajectory log. Based on the query trajectory log, predict and update the hit probability of each data block. Listen for the start-up event of the computing node. Determine the prefetch object set based on the historical associated query context identifier to which the started computing node belongs and the predicted hit probability. After detecting the start-up event of the target computing node, the DPU storage node actively initiates a CXL direct memory access write operation. Without the target computing node initiating an explicit network fetch request, write the local index blocks and hot datasets in the prefetch object set into the memory address space allocated to the target computing node, and complete the reconstruction of the local index context of the target computing node. The computing nodes run in a Serverless computing node pool in the form of containers.

2. The method as described in claim 1, characterized in that, The access popularity score is obtained by weighted summation of the normalized historical access frequency value and the normalized access time value of the i-th index node within a preset statistical window. The sum of the weight coefficient corresponding to the normalized historical access frequency value and the weight coefficient corresponding to the normalized access time value is 1. During system operation, the residency priority score of each index node is periodically recalculated, and the residency position of the index node between the CXL shared memory pool and the DPU local memory is dynamically adjusted according to the score changes.

3. The method as described in claim 2, characterized in that, During system operation, the historical access frequency and access time of each index node in the flattened hybrid index tree are continuously collected and updated periodically according to a preset statistical window, which serves as the basis for calculating the access popularity score.

4. The method as described in claim 1, characterized in that, The feasibility determination of the pushdown includes: determining whether the query operator is a filtering operator, aggregation operator, or feature matching operator without side effects, and determining whether the data on which the query operator depends has been located in the target DPU storage node; For query logic corresponding to query operators that are determined not to meet the pushdown conditions, the filtered intermediate result set is processed on the computing node side by moving the original data to the computing node side.

5. The method as described in claim 4, characterized in that, Boundary check instructions are inserted during the compilation of pushdown-capable query logic into eBPF bytecode. The target DPU storage node performs memory out-of-bounds checks, loop termination checks, and permission compliance checks on the received eBPF bytecode through a built-in verifier. After the checks pass, the eBPF bytecode is loaded into the sandboxed execution environment.

6. The method as described in claim 1, characterized in that, Based on the query trajectory log, the hit probability of each data block is predicted and updated, including: multiplying the hit probability of the data block at the current statistical moment with the historical weight decay coefficient to obtain the first product; The second product is obtained by multiplying the indicator value of whether the data block was actually hit at the current statistical moment with the difference between 1 and the historical weight decay coefficient. Add the first product and the second product to obtain the predicted hit probability of the data block at the next statistical time step; The indicator value is 1 when the data block is hit and 0 when the data block is not hit, and the historical weight decay coefficient is greater than 0 and less than 1.

7. The method as described in claim 6, characterized in that, The monitoring of the startup events of the computing nodes includes: monitoring the creation and startup events of newly added computing nodes in real time through the event subscription interface with the cloud serverless scheduling plane, and obtaining the tenant identifier and historical associated query context identifier to which the newly added computing node belongs; The determination of the prefetch object set includes: based on the obtained tenant identifier and the historical associated query context identifier, combined with the predicted hit probability, selecting a preset number of local index blocks and hot data blocks in descending order of hit probability to form the prefetch object set.

8. The method as described in claim 7, characterized in that, The reconstruction of the compute node's local index context includes: after the compute node detects that the prefetched object set already exists in its local memory via CXL direct memory access, it marks itself as entering a stateful retrieval state, and thereafter responds to received query requests based on the local prefetched data and the flattened hybrid index tree.

9. A data processing and cloud storage system based on a cloud computing architecture, characterized in that, This includes the CXL shared memory pool, DPU storage node cluster, Serverless compute node pool, and cloud control plane; The CXL shared memory pool is used to host the root node and the first-level index node in the flattened hybrid index tree. The root node and the first-level index node reside in the CXL shared memory pool according to the access popularity score. The DPU storage node cluster includes multiple DPU storage nodes. Each DPU storage node carries the leaf nodes and corresponding original data in the flattened hybrid index tree, and is configured with an eBPF execution engine and a query trajectory prediction module. The eBPF execution engine is used to perform security verification, sandbox loading and execution on the received eBPF bytecode, and the query trajectory prediction module is used to predict the hit probability of data blocks based on historical query trajectories. The cloud control plane is equipped with an AST parser and an eBPF compiler, which are used to perform syntax parsing and pushdown feasibility determination on query requests initiated by the Serverless computing node pool, and compile the query logic that is determined to be pushdown into eBPF bytecode and then send it to the DPU storage node cluster. The Serverless compute node pool includes multiple compute nodes running in container form, which are used to initiate query requests, receive the filtered result set returned by the DPU storage node cluster, and receive the local index blocks and hot data sets written by the DPU storage node cluster through CXL direct memory access when the compute node is started, thereby completing the reconstruction of the local index context.

Images