Data processing method and computing cluster

Abstract

The present application provides a data processing method, comprising: a first computing node acquires an IO request, wherein the IO request comprises an access path; the first computing node determines, on the basis of metadata of a root directory in the access path, a computing node where the root directory is located, and sends the access path to the computing node where the root directory is located; a second computing node where an ith-level directory among N levels of directories is located receives a sub-path sent by a computing node where an (i-1)th-level directory is located, determines a third computing node where an (i+1)th-level directory is located, and sends, to the third computing node, a sub-path that uses the information of the (i+1)th-level directory as a first directory; on the basis of information of a target data block sent by a computing node where an (N-1)th-level directory is located, a fourth computing node where an Nth-level directory is located acquires metadata of the target data block; the first computing node acquires the target data block on the basis of the metadata of the target data block. The method can effectively reduce the number of times of communication between nodes in a computing cluster, and improve the efficiency of accessing a target data block.

Description

Method of data processing and computing cluster

[0001] The present application claims priority to the Chinese patent application No. 202411009868.8, filed on July 25, 2024, with the State Intellectual Property Office of China, with the title of "Method of data processing and computing cluster", the content of which is incorporated herein by reference in its entirety. TECHNICAL FIELD

[0002] The present application relates to the field of storage, and more particularly, to a method of data processing and a computing cluster. BACKGROUND

[0003] Super computer (super computer, also can be referred to as super computer) is a kind of computer with the strongest function, the fastest operation speed and the largest storage capacity in computer, which is mostly used in national high-tech field and cutting-edge technology research. In order to store and share massive data and guarantee the consistency of data view between nodes, super computer system usually uses parallel file system to store data. The computing nodes are used as clients of the parallel file system, and the storage nodes are used as servers of the parallel file system. Due to the running characteristics of high-performance computing parallel programs, in the process of running some loads, there will be burst and intensive data read-write operations, and a large number of computing nodes will generate a large number of tidal surge type I / O requests, which will cause serious load pressure on the file system server.

[0004] In order to solve the problem caused by the separation of computing and storage, the mainstream super computer system will build a multi-layer storage system, and use burst buffer (BB) file system to solve the I / O bottleneck problem. BB file system is generally constructed using high-performance storage devices, such as non-volatile memory and flash memory, to improve its access speed.

[0005] The BB file system is applied in a large-scale computing cluster. When computing nodes in the cluster access data in a file, the path of the file to be accessed needs to be parsed to obtain metadata of the file to be accessed. In a related file path parsing scheme, it is assumed that all directories / files are distributed on different nodes, i.e., no two files / directories are in the same node. After encapsulating a path parsing request, a parsing initiating node sends the path parsing request to a node where a root directory in the path is located. The node where the root directory is located sends information about a node where a next-level directory is located to the parsing initiating node after parsing the information about the node where the next-level directory is located. The parsing initiating node sends a path parsing request to the node where the next-level directory is located again based on the information about the node where the next-level directory is located. The node where the next-level directory is located sends information about a node where a next-next-level directory is located to the parsing initiating node after parsing the information about the node where the next-next-level directory is located. In this way, until information about a node where a file to be accessed is located is parsed, the parsing initiating node sends a request to the node where the file to be accessed is located based on the information about the node where the file to be accessed is located, to request metadata of the file to be accessed. In the related file path parsing scheme, there are multiple interactions and communications between the parsing initiating node and other nodes, and the efficiency is low.

[0006] Therefore, how to improve the efficiency of file path parsing and reduce the delay of file access becomes a technical problem to be solved. SUMMARY

[0007] The present application provides a data processing method and a computing cluster, and designs an efficient file path parsing mode, which can effectively reduce the number of communications between computing nodes in the computing cluster, reduce the delay of file access, and improve the efficiency of file access.

[0008] In a first aspect, a data processing method is provided, which is applied to a computing cluster including a plurality of computing nodes, and storage devices on the plurality of computing nodes constitute a burst buffer (BB) storage system. The method includes: a first computing node of the plurality of computing nodes acquires an input / output (IO) request issued by an application, and the IO request includes an access path of a target data block, the access path is information of an N-level directory in a BB file system in the BB storage system, N-level directory information of an Nth-level directory in the N-level directory is information of the target data block, and the N-level directory is distributed in the storage devices on the plurality of computing nodes; the first computing node determines a computing node where a root directory in the access path is located according to metadata of the root directory, and sends the access path to the computing node where the root directory is located; an i-th-level directory in the N-level directory is located in a second computing node, receives a sub-path sent by a computing node where an (i-1)-th-level directory is located, a first directory in the sub-path is information of the i-th-level directory, determines the i-th-level directory according to the information of the i-th-level directory, the i-th-level directory includes metadata of an (i+1)-th-level directory, determines a third computing node where the (i+1)-th-level directory is located according to the metadata of the (i+1)-th-level directory, and sends a sub-path with the (i+1)-th-level directory information as the first directory to the third computing node; a fourth computing node where the Nth-level directory is located receives information of the target data block sent by a computing node where an (N-1)-th-level directory is located, acquires metadata of the target data block according to the information of the target data block, and returns the metadata of the target data block to the first computing node; and the first computing node acquires the target data block according to the metadata of the target data block.

[0009] In the technical solution, after the second computing node where the i-th-level directory in the N-level directory is located determines the third computing node where the (i+1)-th-level directory is located, the second computing node can directly send the sub-path with the (i+1)-th-level directory information as the first directory to the third computing node, without informing the first computing node that the computing node where the (i+1)-th-level directory is located is the third node, and then sending the sub-path with the (i+1)-th-level directory information as the first directory to the third computing node again by the first computing node. In this way, the number of communications between the computing nodes can be effectively reduced, the delay of file access can be reduced, and the efficiency of file access can be improved.

[0010] In combination with the first aspect, in some implementations of the first aspect, the method further includes: dividing the plurality of computing nodes into a plurality of groups, fully connecting the computing nodes in each group, and using peer-to-peer connection between groups, the peer-to-peer connection is to connect the computing nodes with the same number in different groups.

[0011] In the technical solution, all computing nodes in a large-scale cluster are logically grouped, the computing nodes in a group are interconnected in a full connection mode, and the computing nodes between groups are forwarded through specific peer nodes. In this way, serious resource occupation caused by full connection between all computing nodes is avoided, and the stability of the system is improved.

[0012] With reference to the first aspect, in some implementations of the first aspect, the metadata of the (i+1)th directory includes grouping information and identification information of the computing node where the (i+1)th directory is located, and the determining the third computing node where the (i+1)th directory is located according to the metadata of the (i+1)th directory includes: determining the third computing node where the (i+1)th directory is located according to the grouping information and the identification information of the computing node where the (i+1)th directory is located.

[0013] With reference to the first aspect, in some implementations of the first aspect, the metadata of the target data block includes a first table item, the first table item is used to record grouping information and identification information of the fifth computing node where the target data block is stored, and the first computing node acquires the target data block according to the metadata of the target data block, including: the first computing node determines the fifth computing node where the target data block is stored according to the first table item, and sends a request message to the fifth computing node where the target data block is stored, the request message being used to indicate to acquire the target data block; the fifth computing node where the target data block is stored acquires the target data block according to the second table item, and returns the target data block to the first computing node, where the second table item is used to record a storage position of the target data block in the computing node.

[0014] With reference to the first aspect, in some implementations of the first aspect, the size of the target data block is greater than a preset threshold, and the first table item and the metadata of the target data block are carried in a metadata block.

[0015] With reference to the first aspect, in some implementations of the first aspect, the first computing node is located in a first group, and the method further includes: a management node in the first group acquires storage spaces respectively occupied by other computing nodes in the first group; and the management node migrates data on a computing node whose occupied storage space exceeds a threshold to other computing nodes in the first group, so that each computing node in the first group respectively occupies a storage space less than the threshold.

[0016] In a second aspect, a computing cluster is provided, which includes a plurality of computing nodes, and storage devices on the plurality of computing nodes constitute a burst buffer (BB) storage system. The plurality of computing nodes include a first computing node, a second computing node, a third computing node, and a fourth computing node. The first computing node is configured to obtain an input / output (IO) request issued by a first application, and the IO request includes an access path of a target data block. The access path is information of an N-level directory in a BB file system in the BB storage system. The information of the N-level directory includes N-level directory information of the target data block. The N-level directory is distributed on the storage devices of the plurality of computing nodes. The first computing node is further configured to determine a computing node where a root directory of the access path is located according to metadata of the root directory, and send the access path to the computing node where the root directory is located. The second computing node where the i-level directory of the N-level directory is located is configured to receive a sub-path sent by a computing node where an (i-1)-level directory is located. A first directory in the sub-path is information of the i-level directory. The second computing node is configured to determine the i-level directory according to the information of the i-level directory. The i-level directory includes metadata of an (i+1)-level directory. The second computing node is configured to determine a third computing node where the (i+1)-level directory is located according to the metadata of the (i+1)-level directory. The second computing node is configured to send a sub-path with the (i+1)-level directory information as the first directory to the third computing node. The fourth computing node where the N-level directory is located is configured to receive information of the target data block sent by a computing node where an (N-1)-level directory is located. The fourth computing node is configured to obtain metadata of the target data block according to the information of the target data block, and return the metadata of the target data block to the first computing node. The first computing node is further configured to obtain the target data block according to the metadata of the target data block.

[0017] With reference to the second aspect, in some implementations of the second aspect, the computing cluster further includes a first management node configured to divide the plurality of computing nodes into a plurality of groups, and perform full connection on computing nodes in each group, and perform peer-to-peer connection between groups. The peer-to-peer connection is to connect computing nodes with the same number in different groups.

[0018] With reference to the second aspect, in some implementations of the second aspect, the metadata of the (i+1)-level directory includes grouping information and identification information of the third computing node where the (i+1)-level directory is located. The second computing node is specifically configured to determine the third computing node where the (i+1)-level directory is located according to the grouping information and the identification information of the third computing node.

[0019] With reference to the second aspect, in some implementations of the second aspect, the metadata of the target data block includes a first table item. The first table item is configured to record grouping information and identification information of a fifth computing node where the target data block is stored. The first computing node is specifically configured to:

[0020] The fifth computing node storing the target data block is determined according to the first table entry, and a request message is sent to the fifth computing node storing the target data block. The request message is used to instruct the acquisition of the target data block. The fifth computing node is specifically used to: acquire the target data block according to the second table entry, and return the target data block to the first computing node. The second table entry is used to record the location where the target data block is stored in the computing node.

[0021] In conjunction with the second aspect, in some implementations of the second aspect, the size of the target data block is greater than a preset threshold, and the metadata of the first entry and the target data block are carried in a metadata block.

[0022] In conjunction with the second aspect, in some implementations of the second aspect, the first computing node is located within a first group, which also includes a second management node. The second management node is used to migrate data on computing nodes whose occupied storage space exceeds a threshold to other computing nodes within the first group, so that the storage space occupied by each computing node within the first group is less than the threshold.

[0023] Thirdly, a computing node is provided, including a processor and a memory, and optionally, an input / output interface. The processor controls the input / output interface to send and receive information, the memory stores a computer program, and the processor retrieves and runs the computer program from the memory, enabling the execution of the method in the first aspect or any possible implementation thereof.

[0024] Optionally, the processor can be a general-purpose processor, which can be implemented in hardware or software. When implemented in hardware, the processor can be a logic circuit, integrated circuit, etc.; when implemented in software, the processor can be a general-purpose processor that reads software code stored in memory. This memory can be integrated into the processor or located outside the processor and exist independently.

[0025] Fourthly, a computing cluster is provided, comprising multiple computing nodes, each computing node including a processor and a memory; the processor of the multiple computing nodes is used to execute instructions stored in the memory of the multiple computing nodes, so that the computing cluster performs the method of the first aspect or any possible implementation thereof.

[0026] Fifthly, a chip is provided that acquires and executes instructions to implement the methods described in the first aspect and any implementation thereof.

[0027] Optionally, as one implementation, the chip includes a processor and a data interface, through which the processor reads instructions stored in the memory and executes the methods in the first aspect and any implementation thereof.

[0028] Optionally, as one implementation, the chip may further include a memory storing instructions, and the processor is used to execute the instructions stored in the memory. When the instructions are executed, the processor is used to perform the method in the first aspect and any implementation thereof.

[0029] In a sixth aspect, a computer program product containing instructions is provided, which, when run by a computing cluster, causes the computing cluster to perform the methods described in the first aspect and any implementation thereof.

[0030] In a seventh aspect, a computer-readable storage medium is provided, including computer program instructions that, when executed by a computing cluster, perform the method as described in the first aspect and any implementation thereof.

[0031] As examples, these computer-readable storage devices include, but are not limited to, one or more of the following: read-only memory (ROM), programmable ROM (PROM), erasable PROM (EPROM), flash memory, electrically EPROM (EEPROM), and hard drive.

[0032] Alternatively, as one implementation method, the aforementioned storage medium can specifically be a non-volatile storage medium. Attached Figure Description

[0033] Figure 1 is a schematic diagram of a computing node grouping provided in an embodiment of this application.

[0034] Figure 2 is a schematic diagram of a computing node with a BB file system deployed.

[0035] Figure 3 is a schematic flowchart of a data processing method provided in an embodiment of this application.

[0036] Figure 4 is a schematic diagram of a computing cluster provided in an embodiment of this application.

[0037] Figure 5 is a schematic flowchart of a method for a first computing node to perform a read operation on a target data block according to an embodiment of this application.

[0038] Figure 6 is a schematic flowchart of a method for a first computing node to perform a write operation on a target data block according to an embodiment of this application.

[0039] Figure 7 is a schematic diagram of the architecture of a computing device 1500 provided in an embodiment of this application.

[0040] Figure 8 is a schematic diagram of the architecture of a computing device cluster provided in an embodiment of this application.

[0041] Figure 9 is a schematic diagram of the connection between computing devices 1500A and 1500B via a network provided in an embodiment of this application. Detailed Implementation

[0042] The technical solutions in this application will now be described with reference to the accompanying drawings.

[0043] This application will present various aspects, embodiments, or features relating to systems comprising multiple devices, components, modules, etc. It should be understood and appreciated that individual systems may include additional devices, components, modules, etc., and / or may not include all devices, components, modules, etc. discussed in conjunction with the accompanying drawings. Furthermore, combinations of these approaches are also possible.

[0044] Furthermore, in the embodiments of this application, the words "exemplary," "for example," etc., are used to indicate that they are examples, illustrations, or descriptions. Any embodiment or design scheme described as "exemplary" in this application should not be construed as being more preferred or advantageous than other embodiments or design schemes. Specifically, the use of the term "exemplary" is intended to present the concept in a concrete manner.

[0045] In the embodiments of this application, "corresponding" and "corresponding" can sometimes be used interchangeably. It should be noted that when the distinction is not emphasized, their intended meanings are consistent.

[0046] The business scenarios described in the embodiments of this application are for the purpose of more clearly illustrating the technical solutions of the embodiments of this application, and do not constitute a limitation on the technical solutions provided in the embodiments of this application. As those skilled in the art will know, with the evolution of network architecture and the emergence of new business scenarios, the technical solutions provided in the embodiments of this application are also applicable to similar technical problems.

[0047] References to "one embodiment" or "some embodiments" as described in this specification mean that one or more embodiments of this application include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0048] In this application, "at least one" means one or more, and "more than one" means two or more. "And / or" describes the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can mean: A alone, A and B simultaneously, and B alone, where A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects are in an "or" relationship. "At least one of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one of a, b, or c can mean: a, b, c, ab, ac, bc, or abc, where a, b, and c can be single or multiple.

[0049] For ease of description, the following explanations will first cover several related concepts involved in the embodiments of this application.

[0050] 1. Burst Buffer (BB)

[0051] Blackboard (BB) is a high-speed intermediate storage layer used in high-performance computing (HPC) scenarios. It sits between the compute nodes and the storage system in HPC, aiming to bridge the I / O bandwidth gap between them. BBs are typically built with high-performance storage devices, such as non-volatile memory and flash memory, providing higher bandwidth and lower latency than back-end storage systems.

[0052] 2. Remote Direct Memory Access (RDMA)

[0053] RDMA is a high-speed, low-latency, and low-CPU-overhead network technology. RDMA bypasses the operating system and CPU of remote machines, directly accessing their memory, significantly reducing network communication latency and saving CPU resources, making it suitable for large-scale clusters. Based on RDMA's one-sided and two-sided primitives, low-latency remote procedure calls (RPCs) and large data block transfers can be implemented, offering significant advantages over traditional transmission control protocols (TCP) and internet protocols (IP).

[0054] 3. Shared memory

[0055] Shared memory is a memory space that can be shared and accessed by multiple processes. In the Linux operating system, each process has its own independent virtual memory space, and resources are isolated between processes. Shared memory allows a memory space accessible to multiple processes to be mapped into a process's virtual memory space. Inter-process communication (IPC) is typically implemented using shared memory, and its performance is far superior to IPC implemented through pipes or sockets.

[0056] 4. Key-value database

[0057] A key-value database is a type of NoSQL database that stores data using simple key-value pairs. It stores data as a collection of key-value pairs, where the key serves as a unique identifier. Both keys and values ​​can be anything, ranging from simple objects to complex composite objects. Key-value databases are highly partitionable and allow for horizontal scaling to a level unattainable by other types of databases.

[0058] Supercomputers are the most powerful, fastest, and largest-capacity computers, primarily used in national high-tech fields and cutting-edge technology research. Their components are largely the same as those of ordinary computers, but they differ in performance and scale.

[0059] HPC (High-Performance Parallel Computing) technology is a technical science that utilizes supercomputers to achieve parallel computing, encompassing theories, methods, techniques, and applications. It revolves around leveraging continuously evolving parallel processing units and parallel architectures to achieve high-performance parallel computing. This field encompasses parallel computing models, parallel programming models, parallel execution models, parallel adaptive frameworks, parallel architectures, parallel network communication, and parallel algorithm design.

[0060] Supercomputing systems typically consist of a large number of heterogeneous nodes. These nodes can be categorized into compute nodes, storage nodes, and I / O forwarding nodes. Compute nodes primarily perform computations and usually have little or no disk space. Storage nodes primarily store data and have large-capacity disks. I / O forwarding nodes primarily forward requests and data; they have diverse functions and also possess some computational and storage capabilities, and are typically found in large-scale supercomputers. With the development of supercomputing and the increasing computational demands, supercomputing systems are gradually entering the Exascale era (i.e., peak computing power reaching "10^ ...

[0061] To store and share massive amounts of data and ensure data consistency across nodes, supercomputing systems typically use parallel file systems. Compute nodes act as clients of the parallel file system, while storage nodes act as servers. Due to the characteristics of high-performance computing parallel programs, sudden and intensive data read / write operations may occur during certain load periods. The large number of compute nodes will generate a surge of I / O requests, which can severely strain the file system server.

[0062] To address the problems caused by this separation of computation and storage, mainstream supercomputing systems construct multi-layered storage architectures and use burst cache (BB) file systems to solve I / O bottlenecks. BB file systems are typically built using high-performance storage devices, such as non-volatile memory and flash memory, to improve access speed.

[0063] As an example, based on the deployment location of the storage device, the BB file system is generally divided into two categories: 1) The storage device is deployed on a dedicated node that can be accessed by the compute nodes, such as the storage device being deployed on an I / O forwarding node, and all I / O forwarding nodes build the BB system based on the local storage device; 2) The storage device is deployed directly on the compute nodes, and all compute nodes build the BB system based on the local storage device.

[0064] For ease of description, this application uses the example of deploying the BB file system directly on a compute node.

[0065] Traditional BlackBerry (BB) file systems are used in large-scale computing clusters, which consist of multiple compute nodes, each with a BB file system deployed on it. These nodes communicate and connect using a fully connected architecture. In large-scale computing clusters, this fully connected approach leads to significant resource consumption, resulting in decreased system stability. Furthermore, it doesn't consider network affinity between compute nodes in a large-scale cluster. In such clusters, compute nodes are not perfectly equal, and extensive cross-rack data transmission can cause network congestion and increased access latency.

[0066] In view of this, in this embodiment of the application, the large-scale computing cluster includes multiple computing nodes, and the storage devices on each computing node constitute a BB file system. For all computing nodes in the large-scale cluster, this embodiment of the application can logically group them. Computing nodes within a group can be interconnected using a fully connected approach, and peer-to-peer connections are used between groups. Here, a peer-to-peer node is a computing node with the same number across different groups, and the peer-to-peer connection refers to the connection between different groups through peer nodes with the same number. This avoids the severe resource consumption caused by using a fully connected approach between all computing nodes, thereby improving system stability.

[0067] This application does not specifically limit the grouping method for multiple computing nodes. Several possible grouping methods are listed below.

[0068] One possible implementation is to perform network affinity grouping based on the physical topology of the network in a large-scale cluster, dividing compute nodes under the same switch within the same pod into a group.

[0069] Another possible implementation is to group compute nodes that use the same HPC application together.

[0070] For example, as shown in Figure 1, assume group A includes compute nodes A0 to A3, and group B includes compute nodes B0 to B3. Compute nodes within a group communicate with each other in a fully connected manner, while connections between groups are established through peer nodes. Inter-group communication between compute nodes is handled by the corresponding peer node acting as a communication proxy.

[0071] As shown in Figure 1, computing node A0 in group A is a peer node with computing node B0 in group B, computing node A1 in group A is a peer node with computing node B1 in group B, computing node A2 in group A is a peer node with computing node B2 in group B, and computing node A3 in group A is a peer node with computing node B2 in group B.

[0072] For example, suppose compute node A0 in group A needs to send a remote procedure call (RPC) request to compute node B1 in group B. In this case, the communication method is cross-group RPC. There are two communication paths: one is A0 => B0 => B1, and the other is A0 => A01 => B1. The path can be dynamically selected based on the actual network conditions.

[0073] The following section, with reference to Figure 2, provides a detailed description of the compute node deployed with the BB file system.

[0074] It should be understood that, in this embodiment of the application, a computing node with a BB file system deployed may also be referred to simply as a BB node.

[0075] Referring to Figure 2, in terms of hardware, the compute nodes are equipped with storage devices that constitute a BB storage system, which includes a BB file system. In terms of software, the compute node comprises two main modules: a client and a daemon process. These modules communicate with each other via IPC based on shared memory. The client provides services in the form of an interception library, intercepting I / O system calls issued by HPC applications and forwarding these calls to the daemon process via local IPC or RPC network. The daemon process is responsible for starting an instance on the compute node and handling the I / O system calls sent by the client, accessing data in files.

[0076] It should be understood that the above client can also be called a BB interceptor, and the daemon process can also be called a BB daemon process.

[0077] When the daemon process in the aforementioned BB node accesses data in a file, it needs to parse the path of the file to be accessed in order to obtain the metadata of the file to be accessed, and then obtain the file to be accessed based on the metadata of the file to be accessed.

[0078] In a traditional file path resolution scheme, it is assumed that all directories / files are distributed across different nodes, meaning no two files / directories reside on the same node. The initiating node encapsulates the path resolution request and sends it to the node containing the root directory within that path. The node containing the root directory, after resolving to the node information of the next-level directory, sends that node information back to the initiating node. The initiating node then sends the path resolution request again to the node containing the next-level directory, and so on, until it resolves to the node containing the file to be accessed. The initiating node then sends a request to the node containing the file to retrieve its metadata.

[0079] In the traditional file path resolution scheme described above, there are multiple interactions and communications between the resolution initiating node and other nodes, resulting in low efficiency.

[0080] In view of this, embodiments of this application provide a data processing method that designs an efficient file path resolution mode, which can effectively reduce the number of cross-group RPCs, reduce file access latency, and improve file access efficiency.

[0081] Figure 3 is a schematic flowchart of a data processing method provided in an embodiment of this application, which can be applied to the computing cluster shown in Figure 4. For ease of description, the computing cluster shown in Figure 4 will be described below first.

[0082] As shown in Figure 4, the computing cluster includes multiple computing nodes. The storage devices on these multiple computing nodes constitute a burst cache BB storage system, which includes a BB file system. The multiple computing nodes include a first computing node, a second computing node, a third computing node, and a fourth node.

[0083] In one possible implementation, the first, second, third, and fourth computing nodes are divided into multiple groups. The computing nodes within each group are fully connected, and peer nodes connect different groups. For a detailed description of peer nodes, please refer to the explanation above; it will not be repeated here.

[0084] As exemplarily shown in Figure 3, the method may include steps 310-350, which will be described in detail below.

[0085] Step 310: The first computing node obtains the input / output I / O request issued by the first application.

[0086] In this embodiment of the application, the first computing node can obtain an IO request issued by a first application (e.g., an HPC application), which includes the access path of the target data block.

[0087] The access path of the target data block includes information about the N-level directories in the BB file system of the BB storage system. The Nth-level directory information of this N-level directory is the information of the target data block. This N-level directory is distributed across the storage devices of the multiple compute nodes. That is, the N-level directory is stored in the storage devices of the multiple compute nodes respectively.

[0088] For example, the first compute node includes a BB client and a BB daemon. After the IO request issued by the first application is intercepted by the BB client in the first compute node, the BB client obtains the IO request issued by the first application through interception. The BB client also sends the intercepted IO request to the BB daemon on the first compute node.

[0089] Step 320: The first compute node determines the compute node where the root directory is located based on the metadata of the root directory in the access path, and sends the access path to the compute node where the root directory is located.

[0090] In this embodiment of the application, after obtaining the input / output IO request issued by the first application, the first computing node can obtain the metadata of the root directory from the access path of the target data block included in the IO request, determine the computing node where the root directory is located based on the metadata of the root directory, and send the access path to the computing node where the root directory is located.

[0091] Step 330: The second computing node where the i-th level directory in the N-level directory is located will send the sub-path with the i+1-th level directory information as the starting directory to the third computing node where the i+1-th level directory is located.

[0092] As an example, the second computing node mentioned above is the computing node containing the i-th level directory in the N-level directory, and the third computing node is the computing node containing the (i+1)-th level directory in the N-level directory. That is, the second computing node stores the i-th level directory, and the third computing node stores the (i+1)-th level directory.

[0093] The second compute node receives the subpath sent by the compute node containing the (i-1)th level directory, where the first directory in the subpath is the information of the i-th level directory. The second compute node determines the i-th level directory based on this information, and this i-th level directory includes the metadata of the (i+1)th level directory. The second compute node then determines the third compute node containing the (i+1)th level directory based on its metadata and sends the subpath with the (i+1)th level directory information as its first directory to the third compute node.

[0094] One possible implementation is described below using the (i-1)th level directory as the next level directory after the root directory as an example.

[0095] For example, the compute node containing the root directory receives path information sent by the first compute node, where the first directory in the path information is the root directory. Based on this root directory information, the compute node containing the root directory determines the metadata of the next-level directory (level i-1), and based on the metadata of the next-level directory (level i-1), determines the compute node where the next-level directory (level i-1) of the root directory resides. It then sends the sub-path with the level i directory information as its first directory to the compute node where the level i-1 directory resides.

[0096] For example, the compute node containing the next level directory (level i-1) of the root directory receives a subpath sent by the compute node containing the root directory, where the first directory of the subpath is the level i-1 directory. The compute node containing the next level directory (level i-1) of the root directory determines the metadata of the next level directory (level i) based on this information, determines the second compute node containing the next level directory (level i) based on this metadata, and sends the subpath with the level i directory information as its first directory to the second compute node containing the level i directory.

[0097] For example, the second compute node containing the i-th level directory receives a subpath from the compute node containing the (i-1)-th level directory, where the first directory in the subpath is the i-th level directory. The second compute node containing the i-th level directory determines the metadata of the next-level directory (i+1-th level directory) based on this information, and then determines the third compute node containing that next-level directory (i+1-th level directory) based on its metadata. The second compute node then sends the subpath with the i+1-th level directory information as its first directory to the third compute node containing the i+1-th level directory. Similarly, the third compute node containing the i+1-th level directory can send subpaths with the i+2-th level directory information as their first directory to the compute node containing the i+2-th level directory using the same method. Subsequent processes are described above and will not be repeated here.

[0098] For example, the metadata of the above-mentioned i+1 level directory includes the grouping information and identification information of the computing node where the i+1 level directory is located. In this embodiment of the application, the third computing node where the i+1 level directory is located can be determined based on the grouping information and identification information of the computing node where the i+1 level directory is located.

[0099] For example, in this embodiment of the application, an index node (inode) can be used to represent the data structure storing the metadata of a file / directory. That is, an inode represents the metadata of a file / directory. Each file / directory corresponds to one inode, which is identified using 128 bits and called the inode number (ino). The inode contains the node ID information storing the inode and the target group ID information corresponding to the node.

[0100] The node ID information mentioned above can be generated by hashing algorithms to achieve load balancing of metadata within the group.

[0101] For example, each compute node allocates a storage pool in its local storage device to store inode data in blocks. Each block is 4 KiB in size and is called a metadata block. Each metadata block consists of 512 bytes of inode information and a portion of file data or a data block index.

[0102] In this embodiment, the file system can be organized in the form of a traditional directory tree. For example, a key-value database is used to store directory entry (dentry) information, as shown in Table 1. Simultaneously, in order to use ino to find the corresponding inode, the mapping relationship between ino and inode object locations in the storage pool also needs to be stored in a key-value database (KV-DB).

[0103] Table 1. Data Tables Used for Metadata Management

[0104] Step 340: The fourth compute node where the Nth level directory is located obtains the metadata of the target data block and returns the metadata of the target data block to the first compute node.

[0105] In this embodiment, the computing node containing the (N-1)th level directory receives a sub-path from the computing node containing the (N-2)th level directory, where the first directory in the sub-path is the (N-1)th level directory. The computing node containing the (N-1)th level directory determines the metadata of the (N-1)th level directory based on this information, determines the fourth computing node containing the (N-2)th level directory based on this metadata, and sends the sub-path with the (N-1)th level directory information as its first directory to the fourth computing node containing the (N-1)th level directory.

[0106] The fourth computing node, where the Nth level directory is located, receives the target data block information sent by the computing node where the N-1 level directory is located, obtains the metadata of the target data block based on the target data block information, and returns the obtained target data block metadata to the first computing node.

[0107] Step 350: The first computing node obtains the target data block based on the target data block's metadata.

[0108] In this embodiment of the application, after the first computing node obtains the target data block based on the target data block's metadata, it can access the target data block.

[0109] The aforementioned access to the target data block may be reading data from the target data block or writing data into the target data block; this application embodiment does not specifically limit this.

[0110] For example, if the target data block is a small file, meaning its size is less than a preset threshold, the target data block is stored in a metadata block. The first compute node can directly retrieve and access this target data block from the metadata block.

[0111] It should be understood that the above metadata block is a data block that carries the metadata of the target data block.

[0112] Another example is when the target file is a medium / large file, meaning the size of the target data block exceeds a preset threshold. The target data block is not stored locally on the first compute node. The first compute node can obtain a first entry from the metadata block. This first entry indicates the identification information of the target compute node storing the target data block. Based on the identification information of the target compute node, the first compute node retrieves and accesses the target data block from the target compute node. In other words, both the first entry and the metadata of the target data block are carried within a single metadata block.

[0113] The specific implementation process of accessing the target data block will be described in detail below with reference to specific embodiments, and will not be repeated here.

[0114] Optionally, in some embodiments, it is assumed that the first computing node is located within a first group, and the first group also includes a second management node. The second management node is used to migrate data on computing nodes whose occupied storage space exceeds a threshold to other computing nodes within the first group, so that the storage space occupied by each computing node in the first group is less than the threshold.

[0115] In the above technical solution, after the second computing node containing the i-th level directory in the N-level directory determines the third computing node containing the (i+1)-th level directory, it can directly send the subpaths starting with the (i+1)-th level directory information to the third computing node, without needing to inform the first computing node that the (i+1)-th level directory is the third node, and for the first computing node to then send the subpaths starting with the (i+1)-th level directory information to the third computing node. This effectively reduces the number of communications between computing nodes, lowers file access latency, and improves file access efficiency.

[0116] The read and write processes of the target data block are described in detail below with reference to Figures 5 and 6. It should be understood that the examples in Figures 5 and 6 are merely to help those skilled in the art understand the embodiments of this application, and are not intended to limit the embodiments to the specific values ​​or scenarios illustrated in Figures 5 and 6. Those skilled in the art can obviously make various equivalent modifications or variations based on the examples given below in Figures 5 and 6, and such modifications and variations also fall within the scope of the embodiments of this application.

[0117] Figure 5 is a schematic flowchart of a method for performing a read operation on a target data block of a first computing node according to an embodiment of this application. As shown in Figure 5, the method may include steps 510-553, which will be described in detail below.

[0118] Step 510: The HPC application on the first compute node issues an IO read request.

[0119] As an example, if an HPC application needs to read n bytes from the offset of a target data block, the HPC application can issue an IO read request to request the reading of n bytes from the offset of the target data block.

[0120] Step 513: The BB interception library of the first compute node intercepts the IO read request and forwards it to the BB daemon process of the first compute node via IPC.

[0121] As an example, after the BB interception library of the first compute node intercepts the IO read request issued by the PC application, it forwards the IO read request to the daemon process of the first compute node through IPC.

[0122] Step 516: The daemon process of the first compute node converts the IO read request into...<ino,bno,off,n> .

[0123] As an example, after the daemon of the first compute node receives an I / O read request requesting to read n bytes from the offset of a target data block, it can calculate the offset and n in the I / O read request to convert it into a read request for one or more data blocks. For example, this read request for one or more data blocks can be used...<ino,bno,off,n> To describe.<ino,bno,off,n> This indicates that for the bno-th target data block corresponding to ino, n bytes are read starting from offset off.

[0124] The ino field of the target data block stores information about the computing node where the target data block's metadata resides; that is, it stores information about the computing node that stores the target data block's metadata. For example, it stores the representation information of the computing node that stores the target data block's metadata and the identification information of the group to which that computing node belongs.

[0125] Step 519: The daemon of the first compute node obtains the metadata of the target data block from other remote compute nodes based on the ino of the target data block.

[0126] In this embodiment, the daemon process of the first computing node can refer to the method shown in Figure 3 above to obtain the metadata of the target data block from the remote fourth computing node through RDMA RPC technology. For details, please refer to the description in Figure 3 above, which will not be repeated here.

[0127] Step 526: The daemon process of the first computing node determines the type of the target data block.

[0128] In this embodiment of the application, based on the file data block index, the target data blocks are divided into three categories: small, medium, and large according to the size of different target data blocks.

[0129] For example, the following is an implementation method for dividing the target data block into three categories of files: small, medium, and large.

[0130] For example, small files refer to files whose target data block size is ≤3584B.

[0131] For example, a medium-sized file refers to a type of file where the size of the target data block is greater than 3584B and the file size is less than or equal to 56MiB (based on a block size of 64KiB).

[0132] For example, a large file refers to a type of file whose target data block size is greater than 56 MiB.

[0133] In this embodiment of the application, it is assumed that the size of a metadata block is 4KiB, the file / directory metadata in the metadata block occupies 512B, and the remaining 3584B space is used for inlining the target data block or the A table entry of the target data block.

[0134] It should be understood that, in order to efficiently index the data blocks written on each compute node, this application embodiment introduces a secondary index, named Table A and Table B. Table A and Table B are stored on the compute nodes in the form of key-value pairs, as shown in Table 2.

[0135] Table 2 shows Tables A and B used for data management.

[0136] Table A is a global table that records the nodes where file data blocks are stored. Each table entry is hashed using a key to obtain a storage node within the group. Table B is a node-local table that records the location of file data blocks within the local storage pool.

[0137] For example, when the target data block is a small file, that is, the size of the target data block is ≤3584B, the target data block can be directly stored in the metadata block. In this case, the number of data blocks is 0, and there is no corresponding A table entry in the system.

[0138] For example, when the target data block is a medium-sized file, meaning its size is greater than 3584 bytes, the metadata block is insufficient to store it. In this case, the system moves the target data block out of the metadata block, allocates and writes a new data block to the current node, and uses the remaining 3584 bytes of space in the metadata block for inline storage or storing A table entries. As an example, each A table entry only needs to store the Value (Group Id, Server Id), which is 4 bytes in size. The inode number in the Key is stored in 512 bytes of metadata, and the block number serves as the index in the 3584 bytes of space. A total of 3584 / 4 = 896 A table entries, or 896 data blocks, can be stored. Assuming the system's block size is 64 KiB, the inline A table can record 896 * 64 KiB = 56 MiB of data across storage nodes.

[0139] For example, when the target data block is a large file, that is, when the size of the target data block is greater than 56 MiB, the overflowing A table entries in the metadata block are stored in a distributed key-value store and distributed across various computing nodes in the group.

[0140] In the above technical solution, files are classified into "large, medium, and small" according to their size, and different indexing and storage methods are used for different file types to reduce the path depth for accessing small files, thereby optimizing the performance of small file access and improving space utilization.

[0141] In one possible implementation, if the daemon process of the first compute node determines that the target data block is a small file, the daemon process of the first compute node can execute step 529.

[0142] In another implementation, if the daemon process of the first compute node determines that the target data block is a medium or large file, the daemon process of the first compute node can execute step 530.

[0143] Step 529: The daemon of the first compute node retrieves the target data block from the metadata block.

[0144] In this embodiment of the application, if the daemon process of the first computing node determines that the target data block belongs to a small file, the daemon process of the first computing node directly obtains the target data block from the metadata block.

[0145] Step 530: The daemon process of the first compute node queries table B locally to determine whether the target data block is stored locally on the first compute node.

[0146] In this embodiment of the application, if the daemon process of the first computing node determines that the target data block is a medium or large file, the daemon of the first computing node can first perform a query on the local B table to determine whether the target data block is stored locally on the first computing node.

[0147] In one possible implementation, if the target data block is stored in the local storage pool of the first compute node, the daemon of the first compute node can execute step 533.

[0148] In another possible implementation, if the target data block is not stored in the local storage pool of the first compute node, the daemon of the first compute node can execute step 536.

[0149] Step 533: The daemon process of the first compute node retrieves the target data block from the local machine.

[0150] In this embodiment of the application, if the daemon process of the first computing node determines from the B table that the target data block is stored locally on the first computing node, the daemon process of the first computing node can read the target data block from the local storage pool according to the location of the target data block in the local storage pool recorded in the B table, and write the target data block into the data block read / write buffer.

[0151] Step 536: The daemon process of the first compute node determines whether bno is less than 896.

[0152] In this embodiment of the application, if the daemon process of the first computing node determines from the B table that the target data block is not stored locally on the first computing node, the daemon process of the first computing node can continue to determine whether bno is less than 896.

[0153] In one possible implementation, if the bno of the target data block is less than 896, the daemon of the first compute node executes step 539 to obtain the A table entry.

[0154] In another possible implementation, if the bno of the target data block is greater than or equal to 896, the daemon of the first compute node executes step 540 to obtain the A entry.

[0155] Step 539: The daemon of the first compute node retrieves the stored A table entries from the metadata block.

[0156] Step 540: The daemon process of the first compute node retrieves the stored A table entries from the database.

[0157] Step 543: The daemon of the first compute node obtains the location of the target data block based on the A table entry and sends an RPC request to the compute node (e.g., the fourth compute node) that stores the target data block.

[0158] In this embodiment of the application, after the daemon process of the first computing node obtains the A table entry, it identifies the computing node storing the target data block after the A table entry as the fourth computing node, and the daemon process of the first computing node can initiate an RPC request to the fourth computing node.

[0159] Step 546: The fourth compute node reads the target data block from its local storage pool and writes it into the data block read / write buffer of the first compute node.

[0160] In this embodiment, after receiving the RPC request from the first computing node, the fourth computing node queries its local B table to find the location of the target data block in the local storage pool, reads the target data block from the storage pool, and writes it into the data block read / write buffer of the first computing node. Finally, it responds to the first computing node with the RPC request.

[0161] Step 549: The daemon of the first compute node notifies the client of the first compute node of the location of the target data block in the data block read / write buffer via an IPC response.

[0162] In this embodiment of the application, the daemon process of the first computing node can notify the client of the first computing node of the offset of the target data block in the data block read / write buffer, so that the client of the first computing node can obtain the target data block from the data block read / write buffer according to the offset.

[0163] Step 550: The client of the first compute node obtains and copies the target data block from the data block read / write buffer.

[0164] In this embodiment, the client of the first computing node retrieves the target data block from the data block read / write buffer based on the offset of the target data block in the data block read / write buffer. After the client of the first computing node completes the copying of the target data block, the read request ends and resources are reclaimed.

[0165] Step 553: The client of the first compute node sends the target data block to the HPC application for copying.

[0166] Figure 6 is a schematic flowchart of a method for a first computing node to perform a write operation on a target data block according to an embodiment of this application. As shown in Figure 6, the method may include steps 610-659, which will be described in detail below.

[0167] Step 610: The HPC application issues an IO write request.

[0168] As an example, if an HPC application needs to write n bytes to a target data block from the offset, the HPC application can issue an IO write request to request that n bytes be written to the target data block from the offset.

[0169] Step 613: The BB interception library of the first compute node intercepts the IO write request and forwards it to the BB daemon process of the first compute node via IPC.

[0170] Step 616: The daemon process of the first compute node converts the IO write request into...<ino,bno,off,n,data> .

[0171] As an example, after the daemon of the first compute node receives an I / O write request requesting to write n bytes to a target data block from offset, it can calculate the offset and n in the I / O write request to convert it into a write request for one or more data blocks. For example, this write request for one or more data blocks can be used...<ino,bno,off,n,data> To describe.<ino,bno,off,n,data> This indicates the number of bytes to be written starting from offset off for the bno-th target data block corresponding to ino, where data represents the target data to be written.

[0172] In this embodiment, the daemon process of the first computing node allocates corresponding memory in the data block read / write buffer according to the number of data blocks, and notifies the client of the first computing node to write the data of the write request into the data block read / write buffer.

[0173] Step 619: The daemon process of the first compute node obtains the metadata of the target data block from other remote compute nodes based on the ino of the target data block.

[0174] Step 626: The daemon process of the first compute node determines whether the level of the target data block will change after the target data is written to the target data block locally.

[0175] For example, if this write changes the level of the target data block, for instance, causing the target data block to change from a small file to a medium file or a large file, the daemon of the first compute node executes step 629.

[0176] In another example, if the write does not change the level of the target data block, the daemon of the first compute node executes step 633.

[0177] Step 629: The daemon of the first compute node initiates a file type conversion request to the compute node (e.g., the third compute node) that stores the metadata of the target data block, and the third compute node moves out the inline data in the metadata block.

[0178] In this embodiment of the application, after the third computing node receives the file type conversion request sent by the daemon process of the first computing node, the third computing node can move out the inline data in the metadata block, allocate and write a data block of the file on the third computing node, update table B, and write the first inline table A entry into the metadata block.

[0179] Step 633: The daemon process of the first computing node determines the size of the target data block.

[0180] In one possible implementation, if the daemon process of the first compute node determines that the target data block is a small file, the daemon process of the first compute node can execute step 636.

[0181] In another implementation, if the daemon process of the first compute node determines that the target data block is a medium or large file, the daemon process of the first compute node can execute step 639.

[0182] Step 636: The daemon process of the first compute node writes the target data to be written into the metadata block.

[0183] Step 639: The daemon process of the first compute node determines whether the target data block exists.

[0184] In one possible implementation, if the target data block of the target data to be written exists, the daemon process of the first computing node executes step 640.

[0185] In another possible implementation, if the target data block of the target data to be written does not exist, the daemon process of the first computing node executes step 646.

[0186] Step 640: The daemon of the first compute node sends an RPC request to the compute node (e.g., the fourth compute node) that stores the target data block, and the fourth compute node writes the target data into the target data block.

[0187] In this embodiment of the application, after the fourth computing node receives the RPC request sent by the first computing node, it reads the target data to be written from the first computing node through unilateral RDMA, queries the local B table to find the location of the target data block in the local storage pool, and writes the target data into the local storage pool.

[0188] Step 646: The daemon process of the first compute node writes the target data into the local storage pool and updates the local B table.

[0189] In this embodiment of the application, if the target data block does not exist, the daemon process of the first computing node can directly write the target data into the local storage pool and update the local B table.

[0190] In the above technical solutions, to fully utilize the local disk capability of computing nodes, this application adopts a strategy of prioritizing local writes of data blocks. When a data block is written for the first time, it is written to the local storage pool first. This reduces network data transmission, lowers I / O latency, and is well compatible with the N:1 and N:N I / O load characteristics of HPC applications.

[0191] Step 649: The daemon process of the first compute node determines whether bno is less than 896.

[0192] In one possible implementation, if the bno of the target data block is less than 896, the daemon of the first compute node executes step 650 to update the A entry in the metadata block.

[0193] In another possible implementation, if the bno of the target data block is greater than or equal to 896, the daemon of the first compute node executes step 653 to update the A table entry in the database.

[0194] Step 650: The daemon of the first compute node inserts a new A table entry into the metadata block.

[0195] Step 653: The daemon of the first compute node inserts a new A table entry into the database.

[0196] Step 656: The daemon of the first computing node notifies the client of the first computing node that the target data writing is complete via IPC response.

[0197] Step 659: The client of the first compute node sends a response to the HPC application indicating that the target data write is complete.

[0198] In some embodiments, because the present application adopts a strategy of prioritizing local data writing, significant uneven data distribution may occur under certain HPC application loads. The present application designs a capacity balancing strategy to address this problem.

[0199] As an example, for each group, a configuration file specifies one compute node within the group as the management node. This management node is used to record the data volume and remaining storage capacity of each compute node within the group. For instance, when each compute node starts up, it reports its storage capacity to the group's management node. Whenever the data volume of a compute node changes by 100 GiB (configurable), it reports the storage status of that compute node to the group's management node.

[0200] For example, the data block storage pool uses a cold / hot chain algorithm. The foreground tracks the data block access record status bits, while a background thread periodically scans and updates the cold / hot chain. The background thread determines whether the current compute node needs capacity balancing migration based on two metrics: local storage space occupancy and group capacity distribution (pulled from the management node). When the local storage space occupancy of a compute node exceeds Q (a threshold Q set in the configuration file), and other compute nodes in the group have a storage space occupancy lower than Q, data block migration is triggered, as follows:

[0201] 1. Remove data blocks from the cold chain.

[0202] 2. Copy the data block to the target compute node via RPC, and the target compute node updates table B.

[0203] 3. Update data block A entries via RPC (entries with bno < 896 are stored on the metadata block storage node; entries with bno ≥ 896 are stored on the storage node via hash).

[0204] 4. Release the local data block and update the local B table.

[0205] It should be understood that after step 3 above is completed, the updated data block is visible to other computing nodes and can be safely released locally. During the migration process, if read / write requests for data blocks occur (a low-probability event), to simplify the design, the migration is not interrupted; instead, an error is thrown to the upper layer, requesting a retry.

[0206] The methods provided by the embodiments of this application have been described in detail above with reference to Figures 1 to 6. The embodiments of the apparatus of this application will be described in detail below with reference to Figures 7 to 9. It should be understood that the descriptions of the method embodiments correspond to the descriptions of the apparatus embodiments; therefore, any parts not described in detail can be referred to the preceding method embodiments.

[0207] The method provided in this application embodiment can be executed by a computing node, which can also be referred to as a computing device or computer system. It includes a hardware layer, an operating system layer running on top of the hardware layer, and an application layer running on the operating system layer. The hardware layer includes hardware such as processing units, memory, and memory control units; the functions and structure of this hardware will be described in detail later. The operating system is any one or more computer operating systems that implement business processing through processes, such as Linux, Unix, Android, iOS, or Windows. The application layer includes applications such as browsers, address books, word processing software, and instant messaging software. The execution entity of the method provided in this application embodiment can be a computing node, or a functional module within a computing node capable of calling and executing programs.

[0208] The following describes in detail, with reference to Figure 7, a computing device provided in an embodiment of this application.

[0209] Figure 7 is a schematic diagram of the architecture of a computing device 1500 provided in an embodiment of this application. The computing device 1500 can be a server, a computer, or other device with computing capabilities. The computing device 1500 shown in Figure 7 includes at least one processor 1510 and a memory 1520.

[0210] It should be understood that this application does not limit the number of processors and memories in the computing device 1500.

[0211] The processor 1510 executes instructions in the memory 1520, causing the computing device 1500 to implement the method provided in this application. Alternatively, the processor 1510 executes instructions in the memory 1520, causing the computing device 1500 to implement the various functional modules provided in this application, thereby implementing the method provided in this application.

[0212] Optionally, the computing device 1500 also includes a communication interface 1530. The communication interface 1530 uses a transceiver module, such as, but not limited to, a network interface card or a transceiver, to enable communication between the computing device 1500 and other devices or communication networks.

[0213] Optionally, the computing device 1500 also includes a system bus 1540, wherein the processor 1510, memory 1520, and communication interface 1530 are respectively connected to the system bus 1540. The processor 1510 can access the memory 1520 through the system bus 1540; for example, the processor 1510 can perform data read / write or code execution in the memory 1520 through the system bus 1540. The system bus 1540 is a peripheral component interconnect express (PCI) bus or an extended industry standard architecture (EISA) bus, etc. The system bus 1540 is divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is used in Figure 7, but this does not mean that there is only one bus or one type of bus.

[0214] In one possible implementation, the processor 1510 primarily functions to interpret the instructions (or code) of a computer program and process data within the computer software. The instructions of the computer program and the data within the computer software can be stored in memory 1520 or cache 1516.

[0215] Optionally, processor 1510 may be an integrated circuit chip with signal processing capabilities. By way of example and not limitation, processor 1510 may be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. Among these, a general-purpose processor is a microprocessor, etc. For example, processor 1510 may be a central processing unit (CPU).

[0216] Optionally, each processor 1510 includes at least one processing unit 1512 and a memory control unit 1514.

[0217] Optionally, the processing unit 1512, also known as the core, is the most important component of the processor. The processing unit 1512 is manufactured from single-crystal silicon using a specific production process. All calculations, command reception, command storage, and data processing are performed by the core. Each processing unit independently executes program instructions, utilizing parallel computing capabilities to accelerate program execution. Various processing units have fixed logical structures; for example, a processing unit includes logical units such as a Level 1 cache, a Level 2 cache, an execution unit, an instruction-level unit, and a bus interface.

[0218] In one implementation example, the memory control unit 1514 controls the data interaction between the memory 1520 and the processing unit 1512. Specifically, the memory control unit 1514 receives memory access requests from the processing unit 1512 and controls access to memory based on the memory access requests. By way of example and not limitation, the memory control unit is a device such as a memory management unit (MMU).

[0219] In one implementation example, each memory control unit 1514 addresses the memory 1520 via the system bus. An arbitrator (not shown in Figure 7) is configured on the system bus to handle and coordinate contention for access by the multiple processing units 1512.

[0220] In one implementation example, the processing unit 1512 and the memory control unit 1514 are connected via internal chip connection lines, such as address lines, thereby enabling communication between the processing unit 1512 and the memory control unit 1514.

[0221] Optionally, each processor 1510 also includes a cache 1516, which is a buffer for data exchange (called a cache). When the processing unit 1512 needs to read data, it first looks for the required data in the cache. If the data is found, it is executed directly; otherwise, it looks for the data in memory. Since the cache operates much faster than memory, its purpose is to help the processing unit 1512 run faster.

[0222] The memory 1520 provides runtime space for processes in the computing device 1500. For example, the memory 1520 stores the computer program (specifically, the program code) used to generate the process. After the computer program is run by the processor to generate a process, the processor allocates corresponding storage space for the process in the memory 1520. Furthermore, the aforementioned storage space further includes text segments, initialized data segments, bit initialized data segments, stack segments, heap segments, etc. The memory 1520 stores data generated during the process's execution, such as intermediate data or process data, in the aforementioned process-specific storage space.

[0223] Optionally, the memory, also known as RAM, is used to temporarily store the data processed by the processor 1510, as well as data exchanged with external storage devices such as hard disks. As long as the computer is running, the processor 1510 will load the data that needs to be processed into RAM for processing, and after the processing is completed, the processing unit 1512 will send the result out.

[0224] By way of example and not limitation, memory 1520 is volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. Non-volatile memory is read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. Volatile memory is random access memory (RAM) used as an external cache. By way of example, but not limitation, many forms of RAM are available, such as static random access memory (SRAM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), double data rate synchronous dynamic random access memory (DDR SDRAM), enhanced synchronous dynamic random access memory (ESDRAM), synchronous linked dynamic random access memory (SLDRAM), and direct rambus RAM (DR RAM). It should be noted that the memory 1520 of the systems and methods described herein is intended to include, but is not limited to, these and any other suitable types of memory.

[0225] The structure of the computing device 1500 listed above is merely illustrative and is not limited thereto. The computing device 1500 in this application includes various hardware components in existing computer systems. For example, the computing device 1500 also includes other memories besides memory 1520, such as disk storage. Those skilled in the art should understand that the computing device 1500 may also include other devices necessary for normal operation. Furthermore, depending on specific needs, those skilled in the art should understand that the computing device 1500 may also include hardware devices for implementing other additional functions. In addition, those skilled in the art should understand that the computing device 1500 may only include the devices necessary for implementing the embodiments of this application, and not necessarily all the devices shown in FIG. 7.

[0226] This application also provides a computing device cluster. The computing device cluster includes at least one computing device. The computing device may be a server. In some embodiments, the computing device may also be a desktop computer, a laptop computer, or a smartphone, or other terminal device.

[0227] As shown in Figure 8, the computing device cluster includes at least one computing device 1500. The memory 1520 of one or more computing devices 1500 in the computing device cluster may store the same instructions for performing the above-described method.

[0228] In some possible implementations, the memory 1520 of one or more computing devices 1500 in the computing device cluster may also each store a portion of the instructions for executing the above-described methods. In other words, a combination of one or more computing devices 1500 can jointly execute the instructions of the above-described methods.

[0229] It should be noted that the memory 1520 in different computing devices 1500 within the computing device cluster can store different instructions, each used to execute a portion of the functions of the aforementioned device. That is, the instructions stored in the memory 1520 of different computing devices 1500 can implement the functions of one or more modules within the aforementioned device.

[0230] In some possible implementations, one or more computing devices in a computing device cluster can be connected via a network. This network can be a wide area network (WAN) or a local area network (LAN), etc. Figure 9 illustrates one possible implementation. As shown in Figure 9, two computing devices, 1500A and 1500B, are connected via a network. Specifically, they are connected to the network through communication interfaces in each computing device.

[0231] It should be understood that the functions of computing device 1500A shown in Figure 9 can also be performed by multiple computing devices 1500. Similarly, the functions of computing device 1500B can also be performed by multiple computing devices 1500.

[0232] In this embodiment, a computer program product containing instructions is also provided. The computer program product may be a software or program product containing instructions capable of running on a computing device or stored on any usable medium. When run on a computing device, it causes the computing device to perform the methods provided above, or causes the computing device to perform the functions of the apparatus provided above.

[0233] In this embodiment, a computer-readable storage medium is also provided. This computer-readable storage medium can be any available medium that a computing device can store, or a data storage device such as a data center containing one or more available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid-state drive). The computer-readable storage medium includes instructions that, when executed on a computing device, cause the computing device to perform the method described above.

[0234] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0235] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0236] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0237] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

[0238] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0239] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0240] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0241] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method of data processing, characterized by, The method is applied to a computing cluster comprising a plurality of computing nodes, and storage devices on the plurality of computing nodes constitute a burst buffer (BB) storage system. The method comprises: A first computing node in the plurality of computing nodes acquires an input / output (IO) request issued by an application, wherein the IO request comprises an access path of a target data block, the access path is information of an N-level directory in a BB file system in the BB storage system, N-level directory information of an Nth-level directory in the N-level directory information is information of the target data block, and the N-level directory is distributed in storage devices on the plurality of computing nodes; The first computing node determines a computing node where a root directory in the access path is located according to metadata of the root directory, and sends the access path to the computing node where the root directory is located; An i-th-level directory in the N-level directory is located in a second computing node, which receives a sub-path sent by a computing node where an i-1th-level directory is located, a first directory in the sub-path is information of the i-th-level directory, the i-th-level directory is determined according to the information of the i-th-level directory, the i-th-level directory comprises metadata of an i+1th-level directory, a third computing node where the i+1th-level directory is located is determined according to the metadata of the i+1th-level directory, and a sub-path with the i+1th-level directory information as a first directory is sent to the third computing node; A fourth computing node where the Nth-level directory is located receives information of the target data block sent by a computing node where an N-1th-level directory is located, acquires metadata of the target data block according to the information of the target data block, and returns the metadata of the target data block to the first computing node; The first computing node acquires the target data block according to the metadata of the target data block.

2. The method of claim 1, wherein, The method further comprises: The plurality of computing nodes are divided into a plurality of groups, computing nodes in each group are fully connected, and peer-to-peer connection is adopted between groups, wherein the peer-to-peer connection is to connect computing nodes with the same number in different groups.

3. The method of claim 2, wherein, The metadata of the i+1th-level directory comprises grouping information and identification information of a computing node where the i+1th-level directory is located, The determination of the third computing node where the i+1th-level directory is located according to the metadata of the i+1th-level directory comprises: The third computing node where the i+1th-level directory is located is determined according to the grouping information and the identification information of the computing node where the i+1th-level directory is located.

4. The method according to any one of claims 1 to 3, characterized in that, The metadata of the target data block comprises a first table item, the first table item is used to record grouping information and identification information of a fifth computing node storing the target data block, The acquisition of the target data block by the first computing node according to the metadata of the target data block comprises: The first computing node determines the fifth computing node storing the target data block according to the first table item, and sends a request message to the fifth computing node storing the target data block, wherein the request message is used to instruct to acquire the target data block. The fifth computing node storing the target data block acquires the target data block according to a second table item, and returns the target data block to the first computing node, wherein the second table item is used to record a storage position of the target data block in the computing node.

5. The method of claim 4, wherein, The target data block has a size greater than a preset threshold, and the first table item and metadata of the target data block are carried in a metadata block.

6. The method according to any one of claims 1 to 5, characterized in that, The first computing node is located in a first group, and the method further comprises: A management node in the first group acquires storage spaces respectively occupied by other computing nodes in the first group; The management node migrates data on a computing node whose occupied storage space exceeds a threshold to other computing nodes in the first group, so that each computing node in the first group respectively occupies a storage space less than the threshold.

7. A computing cluster, characterized by The computing cluster comprises a plurality of computing nodes, storage devices on the plurality of computing nodes constitute a burst buffer (BB) storage system, and the plurality of computing nodes comprise: A first computing node configured to acquire an input / output (IO) request issued by a first application, wherein the IO request comprises an access path of a target data block, the access path is information of an N-level directory in a BB file system in the BB storage system, N-level directory information of the N-level directory information is information of the target data block, and the N-level directory is distributed on storage devices of the plurality of computing nodes. The first computing node is further configured to determine a computing node where a root directory of the access path is located according to metadata of the root directory, and send the access path to the computing node where the root directory is located. A second computing node where an i-level directory in the N-level directory is located, configured to receive a sub-path sent by a computing node where an i-1-level directory is located, a first directory in the sub-path is information of the i-level directory, determine the i-level directory according to the information of the i-level directory, the i-level directory comprises metadata of an i+1-level directory, determine a third computing node where the i+1-level directory is located according to the metadata of the i+1-level directory, and send a sub-path with information of the i+1-level directory as the first directory to the third computing node. A fourth computing node where an N-level directory is located, configured to receive information of the target data block sent by a computing node where an N-1-level directory is located, acquire metadata of the target data block according to the information of the target data block, and return the metadata of the target data block to the first computing node. The first computing node is further configured to acquire the target data block according to the metadata of the target data block.

8. The computing cluster of claim 7, wherein, The computing cluster further comprises: A first management node configured to divide the plurality of computing nodes into a plurality of groups, fully connect computing nodes in each group, and adopt peer-to-peer connection between groups, wherein the peer-to-peer connection is to connect computing nodes with the same number in different groups.

9. The computing cluster of claim 8, wherein, The metadata of the i+1-level directory comprises group information and identification information of a computing node where the i+1-level directory is located, and the second computing node is specifically configured to: Determine a third computing node where the (i+1)th catalog is located according to grouping information and identification information of the computing node where the (i+1)th catalog is located.

10. The computing cluster according to any of claims 7 to 9, c h a r a c t e r i z e d b y Metadata of the target data block includes a first table item, the first table item is used for recording grouping information and identification information of a fifth computing node storing the target data block, The first computing node is specifically configured to: Determine the fifth computing node storing the target data block according to the first table item, and send a request message to the fifth computing node storing the target data block, the request message being used for instructing to acquire the target data block. The fifth computing node is specifically configured to: Acquire the target data block according to a second table item, and return the target data block to the first computing node, wherein the second table item is used for recording a storage position of the target data block in the computing node.

11. The computing cluster of claim 10, wherein, The size of the target data block is greater than a preset threshold, and the first table item and metadata of the target data block are carried in one metadata block.

12. The computing cluster according to any of claims 7 to 11, characterized in that, The first computing node is located in a first group, and the first group further includes a second management node, The second management node is configured to migrate data on a computing node whose occupied storage space exceeds a threshold to other computing nodes in the first group, so that each computing node in the first group occupies a storage space less than the threshold.

13. A computing cluster, characterized by The computing cluster includes a plurality of computing nodes, each computing node including a processor and a memory; The processors of the plurality of computing nodes are configured to execute instructions stored in the memories of the plurality of computing nodes to cause the computing cluster to perform the method of any one of claims 1 to 6.

14. A computer program product comprising instructions, characterized in that, The instructions, when executed by the computing cluster, cause the computing cluster to perform the method of any one of claims 1 to 6.

15. A computer readable storage medium, characterized in that, The computer program instructions, when executed by the computing cluster, cause the computing cluster to perform the method of any one of claims 1 to 6.

Images