Cache management method and device and computer readable storage medium

Abstract

The present application provides a cache management method, applicable to a computing cluster running a first process and second process of a first user and a cache service process. The method comprises: a first process acquires a first IO request corresponding to the first process; when a current first memory space of the first process (a section of space in a shared memory pool of the computing cluster and shared by the first process and the second process) is not enough to store data corresponding to the first IO request, the first process sends a first cache application instruction to the cache service process to apply for allocating a second memory space in the shared memory pool; the second process acquires a second IO request corresponding to the second process; and when the first memory space corresponding to the second process is not enough to store data corresponding to a second IO request, the second process sends a second cache application instruction to the cache service process to apply for allocating the second memory space. The method can not only solve the problem of unauthorized access between processes of different users but can also realize dynamic allocation of a shared memory pool.

Description

Cache management method, device and computer-readable storage medium

[0001] This application claims priority to the Chinese patent application filed with the State Intellectual Property Office of China on September 28, 2023, with application number 202311286765.1, and priority to the Chinese patent application entitled “Cache Management Method, Device and Computer-Readable Storage Medium”, all contents of which are incorporated by reference into this application. Technical Field

[0002] The present application relates to the field of computer technology, and in particular to a cache management method, device, and computer-readable storage medium. Background Art

[0003] Cache refers to the space in a computer system's memory used to cache disk files. The cache exchanges data with the processor before the disk does, resulting in a much faster transfer rate. Cache settings are a crucial factor in the high performance of all modern computer systems.

[0004] As shown in Figure 1, a cache service process and user processes (the first process of the first user, the second process of the first user, and the process of the second user as shown in Figure 1) are running in the computing cluster. The computing cluster includes a shared memory pool, from which all user processes running on the computing cluster can apply for memory space as cache.

[0005] Currently, the specific implementation process for a user process to request memory space from the shared memory pool for cache use typically involves the user process sending a cache request instruction to the cache service process. Upon receiving the cache request instruction, the cache service process allocates the entire shared memory pool to the user process for cache use. This means that each user process can use the entire shared memory pool as a cache, which can easily lead to unauthorized access between processes of different users.

[0006] Summary of the Invention

[0007] The present application provides a cache management method, device and computer-readable storage medium, which can solve the problem of unauthorized access between processes of different users and realize the dynamic allocation of shared memory pool in computing clusters.

[0008] In a first aspect, a cache management method is provided, which can be applied to a computing cluster including at least one computing device, the computing cluster running a first process and a second process of a first user and a cache service process, and the computing cluster including a shared memory pool. The method includes: a first process obtains a first input and output (IO) request corresponding to the first process; when the current first memory space of the first process is insufficient to store data corresponding to the first IO request, the first process sends a first cache application instruction to the cache service process, the first memory space being a section of space in the shared memory pool and being shared by the first process and the second process; the cache service process allocates a second memory space in the shared memory pool to the first process according to the first cache application instruction; the second process obtains a second IO request corresponding to the second process; when the first memory space corresponding to the second process is insufficient to store data corresponding to the second IO request, the second process sends a second cache application instruction to the cache service process; the cache service process allocates the second memory space to the second process according to the second cache application instruction.

[0009] In the above scheme, since the first memory space in the shared memory pool is shared only by the first process of the first user and the second process of the first user, and is not shared by processes of other users, the first process of the first user and the second process of the first user have the authority to access the data in the first memory space, while processes of other users do not have the authority to access the data in the first memory space, thereby preventing the data in the first memory space from being accessed without authorization. Similarly, since the second memory space in the shared memory pool is shared only by the first process of the first user and the second process of the first user, and is not shared by processes of other users, the first process of the first user and the second process of the first user have the authority to access the data in the second memory space, while processes of other users do not have the authority to access the data in the second memory space, thereby preventing the data in the second memory space from being accessed without authorization.

[0010] In addition, in the above scheme, since the cache service process allocates the second memory space to the first process according to the first cache application instruction sent by the first process when the current first memory space of the first process is not enough to store the data corresponding to the first IO request, and allocates the second memory space to the second process according to the second cache application instruction sent by the second process when the first memory space corresponding to the second process is not enough to store the data corresponding to the second IO request, dynamic allocation of the shared memory pool is realized. It can be understood that when the shared memory pool can be dynamically allocated, waste of memory pool resources can be avoided and efficient use of memory pool resources can be achieved.

[0011] In one possible implementation, the cache service process allocates the second memory space in the shared memory pool to the first process based on the first cache request instruction. This includes: when the cache service process determines that the frequency of cache request instructions received from the first user's process exceeds a frequency threshold, allocating multiple second memory spaces in the shared memory pool to the first process based on the first cache request instruction. This reduces the number of memory space requests by the first user's process.

[0012] In one possible implementation, the cache service process allocates the second memory space in the shared memory pool to the first process based on the first cache request instruction, including: the cache service process allocates the second memory space in the shared memory pool to the first process based on the first capacity carried in the first cache request instruction, where the capacity of the second memory space is the first capacity. In this way, memory space in the shared memory pool can be allocated on demand based on user process needs.

[0013] In order to improve the flexibility of the solution, in a possible implementation, the capacity of the second memory space is fixed.

[0014] In a possible implementation, the first memory space is shared by the first process, the second process, and the cache service process.

[0015] By implementing the above implementation method, the cache service process can assist the first process / second process in performing IO operations through the first memory space, that is, the cache service process reads the IO data corresponding to the first process / second process from the disk to the first memory space, or the cache service process writes the IO data corresponding to the first process / second process from the first memory space to the disk for persistent storage, thereby improving the IO performance of the user process.

[0016] In one possible implementation, the method further includes: after the cache service process has stored all the data in the first memory space, storing the data in the first memory space to a disk in the computing cluster; and the cache service process releasing the first memory space shared by the first process, the second process, and the cache service process. This allows for efficient and circular utilization of the memory space in the shared memory pool.

[0017] In one possible implementation, the cache service process releases the first memory space shared by the first process, the second process, and the cache service process, including: when the cache service process determines that the usage heat of the memory space in the namespace of the first user is lower than the heat threshold, the cache service process releases the first memory space shared by the first process, the second process, and the cache service process, wherein the namespace of the first user includes the memory space allocated to the first process and the memory space allocated to the second process in the shared memory pool.

[0018] It can be understood that the usage heat of the memory space in the namespace of the first user is higher than or equal to the heat threshold, which means that the usage heat of the memory space in the namespace of the first user is relatively high. In this case, the cache service process does not release the first memory space shared by the first process, the second process and the cache service process, which can reduce the frequency of the first user's process applying for memory space.

[0019] In one possible implementation, the cache service process releases the first memory space shared by the first process, the second process, and the cache service process, including: the cache service process generates marking information, the marking information indicates that the first memory space is unavailable; the cache service process sends marking information to the first process, the marking information is used by the first process to release the first memory space corresponding to the first process; the cache service process sends marking information to the second process, the marking information is used by the second process to release the first memory space corresponding to the second process; the cache service process releases the first memory space corresponding to the cache service process.

[0020] In a possible implementation, the first process, the second process, and the cache service process run on the same computing device or different computing devices in the computing cluster.

[0021] In a second aspect, a cache management apparatus is provided, which is applied to a computing cluster including at least one computing device, wherein the computing cluster runs a first process and a second process of a first user and a cache service process, and the computing cluster includes a shared memory pool. The apparatus includes:

[0022] an acquisition module, configured to acquire, through the first process, a first IO request corresponding to the first process;

[0023] a sending module, configured to send a first cache request instruction to the cache service process through the first process when a current first memory space of the first process is insufficient to store data corresponding to the first IO request, wherein the first memory space is a section of space in the shared memory pool and is shared by the first process and the second process;

[0024] a memory allocation module, configured to allocate, through the cache service process according to the first cache application instruction, a second memory space in the shared memory pool to the first process;

[0025] The acquisition module is further configured to acquire, through the second process, a second IO request corresponding to the second process;

[0026] The sending module is further configured to send a second cache application instruction to the cache service process through the second process when the first memory space corresponding to the second process is insufficient to store data corresponding to the second IO request;

[0027] The memory allocation module is further configured to allocate the second memory space to the second process according to the second cache application instruction through the cache service process.

[0028] In a possible implementation, the memory allocation module is specifically configured to:

[0029] When the cache service process determines that the frequency of cache application instructions received from the first user's process is higher than a frequency threshold, the cache service process allocates multiple second memory spaces in the shared memory pool to the first process according to the first cache application instruction.

[0030] In a possible implementation, the memory allocation module is specifically configured to:

[0031] The cache service process allocates a second memory space in the shared memory pool to the first process according to the first capacity carried in the first cache application instruction, where the capacity of the second memory space is the first capacity.

[0032] In a possible implementation, the capacity of the second memory space is fixed.

[0033] In a possible implementation, the first memory space is shared by the first process, the second process, and the cache service process.

[0034] In a possible implementation, the apparatus further includes: a memory release module;

[0035] The memory release module is used to:

[0036] After the first memory space is full of data, the cache service process stores the data in the first memory space in the disk of the computing cluster;

[0037] The first memory space shared by the first process, the second process, and the cache service process is released through the cache service process.

[0038] In a possible implementation, the memory release module is specifically configured to:

[0039] When the cache service process determines that the usage heat of the memory space in the namespace of the first user is lower than a heat threshold, the first memory space shared by the first process, the second process and the cache service process is released, wherein the namespace of the first user includes the memory space allocated to the first process and the memory space allocated to the second process in the shared memory pool.

[0040] In a possible implementation, the memory release module is specifically configured to:

[0041] Generate marking information by the cache service process, where the marking information indicates that the first memory space is unavailable;

[0042] Sending the marking information to the first process through the cache service process, where the marking information is used by the first process to release the first memory space corresponding to the first process;

[0043] Sending the marking information to the second process through the cache service process, where the marking information is used by the second process to release the first memory space corresponding to the second process;

[0044] The first memory space corresponding to the cache service process is released through the cache service process.

[0045] In a possible implementation, the first process, the second process, and the cache service process run on the same computing device or different computing devices in the computing cluster.

[0046] Regarding the cache management device provided in the second aspect and the relevant beneficial effects and descriptions of any implementation of the second aspect, please refer to the relevant beneficial effects and descriptions of the aforementioned first aspect and any implementation of the first aspect, and will not be repeated here.

[0047] In a third aspect, a computing cluster is provided, comprising at least one computing device, each of the at least one computing device comprising a processor and a memory; the processor of the at least one computing device is used to execute instructions stored in the memory of the at least one computing device, so that the computing cluster implements the method provided in the first aspect or any possible implementation of the first aspect.

[0048] In a fourth aspect, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores instructions, and the instructions are used to implement the method provided in the first aspect or any possible implementation of the first aspect.

[0049] In a fifth aspect, a computer program product is provided, comprising a computer program, which, when read and executed by a computing device, enables the computing device to perform the method provided in the first aspect or any possible implementation of the first aspect. BRIEF DESCRIPTION OF THE DRAWINGS

[0050] FIG1 is a schematic diagram of the structure of a computing cluster provided in an embodiment of the present application;

[0051] FIG2 is an interactive diagram of a cache management method provided in an embodiment of the present application;

[0052] FIG3 is a schematic diagram of a method for implementing memory space isolation in a shared resource pool according to an embodiment of the present application;

[0053] FIG4 is a schematic diagram of a cache service process marking a cache block as unavailable provided by an embodiment of the present application;

[0054] FIG5 is a schematic diagram of a local-first and remote-later cache application provided in an embodiment of the present application;

[0055] FIG6 is a schematic structural diagram of a cache management device provided in an embodiment of the present application;

[0056] FIG7 is a schematic diagram of the structure of a computing device provided in an embodiment of the present application;

[0057] FIG8 is a schematic diagram of the structure of a computing cluster provided in an embodiment of the present application. DETAILED DESCRIPTION

[0058] The technical solution provided in this application will be described below in conjunction with the accompanying drawings.

[0059] First, the application scenario of this application is introduced.

[0060] Refer to Figure 1, which is a structural diagram of a computing cluster provided by an embodiment of the present application. As shown in Figure 1, the user space of the computing cluster runs a cache service process and multiple user processes. In Figure 1, the processes of multiple users are taken as the process of the first user and the process of the second user as an example, wherein the process of the first user includes the first process of the first user and the second process of the first user.

[0061] A computing cluster may include at least one computing device, which may be a personal computer, laptop, physical server, or cloud server. When a computing cluster includes multiple computing devices, the multiple computing devices may be connected via a communication network using any communication mechanism or standard. The communication network may be a wide area network, a local area network, a point-to-point connection, or any combination thereof.

[0062] When the computing cluster includes multiple computing devices, the above-mentioned cache service process, the process of the first user, and the process of the second user can run on the same computing device or different computing devices in the computing cluster. For example, the multiple computing devices include computing device A and computing device B, the cache service process, the first process of the first user, and the second process of the first user run on computing device A, and the process of the second user runs on computing device B.

[0063] As shown in Figure 1, the kernel space of a computing cluster is configured with a shared memory pool. This shared memory pool allows all user processes running on the computing cluster to request memory space as a cache. If the computing cluster consists of a single computing device, the shared memory pool can be part or all of the memory of that single computing device. If the computing cluster consists of multiple computing devices, the shared memory pool can be global memory consisting of part or all of the memory of these multiple computing devices.

[0064] Currently, the specific implementation process for a user process to request memory space from the shared memory pool for cache is as follows: the user process sends a cache request instruction to the cache service process. After receiving the cache request instruction, the cache service process allocates the entire shared memory pool to the user process for cache use based on the cache request instruction. In other words, each user process can use the entire shared memory pool as a cache.

[0065] With this shared memory pool, user processes only need to access the shared memory pool to read and write I / O data when performing input / output (IO) operations. The cache service process handles both reading I / O data required by the user process from the shared memory pool and writing I / O data written by the user process to the shared memory pool to disk. This eliminates the need for user processes to access the disk, thereby improving I / O performance.

[0066] It should be understood that the computing cluster shown in Figure 1 is only an example. In a specific implementation, the computing cluster can also run other user processes in addition to the first process of the first user, the second process of the first user, and the process of the second user. The computing cluster can also include other or more component modules, and this application does not make specific limitations on this.

[0067] In the computing cluster shown in Figure 1, since the cache service process allocates the entire shared memory pool to processes of different users, when the first user's process puts its own IO data into the shared memory pool, the second user's process can also access the shared memory pool, thereby obtaining the IO data of the first user's process, which can easily lead to unauthorized access problems.

[0068] In response to the above problems, the present application provides a cache management method and a cache management device, which can not only ensure that processes of different users have no permission to access the IO data of processes of other users in the shared memory pool when using the shared memory pool, but also realize dynamic allocation of the shared memory pool and efficient utilization of the shared memory pool.

[0069] The following describes the cache management method provided by the present application in conjunction with the computing cluster shown in Figure 1 and the flowchart shown in Figure 2. Referring to Figure 2, Figure 2 is a flowchart of a cache management method provided by an embodiment of the present application, specifically comprising the following steps:

[0070] S201: The cache service process allocates a first memory space in a shared memory pool to a first process and a second process for sharing by the first process and the second process.

[0071] S202: The first process obtains a first IO request corresponding to the first process.

[0072] S203: When the current first memory space of the first process is insufficient to store data corresponding to the first IO request, the first process sends a first cache application instruction to the cache service process.

[0073] S204: After receiving the first cache application instruction sent by the first process, the cache service process allocates the second memory space in the shared memory pool to the first process according to the first cache application instruction.

[0074] S205: The second process obtains a second IO request corresponding to the second process.

[0075] S206: When the first memory space corresponding to the second process is insufficient to store data corresponding to the second IO request, the second process sends a second cache application instruction to the cache service process.

[0076] S207: After receiving the second cache application instruction sent by the second process, the cache service process allocates the second memory space to the second process according to the second cache application instruction.

[0077] The following first introduces concepts such as IO requests (such as the first IO request and the second IO request), data corresponding to the IO requests, and the cache service process allocating memory space in the shared memory pool to the user process involved in the embodiments of the present application.

[0078] In an embodiment of the present application, an IO request is used to instruct a user process to perform an IO operation. Specifically, it can be a read / write data request (which can be simply referred to as a read / write request) from a user process to the disk of a computing cluster, which is used to read IO data from the disk into the memory space allocated to the user process (i.e., the cache of the user process), or to write IO data into the memory space allocated to the user process, and then subsequently write the IO data from the memory space allocated to the user process to the disk for persistent storage.

[0079] When the IO request is a read request, the data corresponding to the IO request is the data that the user process needs to read from the disk. When the IO request is a write request, the data corresponding to the IO request is the data that the user process needs to write to the disk. In the following embodiments, the data corresponding to the IO request is collectively referred to as IO data.

[0080] In an embodiment of the present application, a cache service process allocates a first memory space in a shared memory pool to a first process, a cache service process allocates a first memory space in a shared memory pool to a second process, a cache service process allocates a second memory space in a shared memory pool to a first process, and a cache service process allocates a second memory space in a shared memory pool to a second process. Taking the cache service process allocating the first memory space in the shared memory pool to the first process as an example, the cache service process can send the address of the first memory space to the first process. The address of the first memory space is used by the first process to establish a mapping relationship between the virtual address space of the first process and the first memory space. After the mapping relationship is established, the first process can read and write the first memory space according to the mapping relationship. However, processes that are not allocated the first memory space cannot perform IO operations through the first memory space.

[0081] Optionally, the cache service process can also establish a mapping relationship between the virtual address space of the cache service process and the first memory space. After the mapping relationship is established, a first memory space shared by the cache service process and the first process is formed. The cache service process can assist the first process in performing IO operations through the first memory space, that is, the cache service process reads the IO data corresponding to the first process from the disk to the first memory space, or the cache service process writes the IO data corresponding to the first process from the first memory space to the disk for persistent storage.

[0082] In the embodiments of the present application, it involves the first process and the second process sharing the first memory space, and the first process and the second process sharing the second memory space, and also involves the situation where multiple processes share the same memory space, such as the first process, the second process and the cache service process sharing the first memory space. Taking the first process and the second process sharing the first memory space as an example, the first process and the second process sharing the first memory space means that the first process and the second process are both allocated the first memory space as a cache, that is, the first process and the second process have established their own mapping relationship between the virtual address space and the first memory space, so the first process and the second process can both perform IO operations through the first memory space. However, processes that do not share the first memory space cannot perform IO operations through the first memory space.

[0083] In an embodiment of the present application, if a process of the first user other than the first process and the second process wants to share the first memory space, it needs to send a cache request instruction to the cache service process. The cache service process determines that the process is also the process of the first user, and then allocates the first memory space to the process according to the cache request instruction, so that the process also shares the first memory space. When a process of another user other than the first user's process, such as the second user's process, sends a cache request instruction to the cache service process, the cache service process determines that the process is not the process of the first user, and then allocates other memory spaces in the shared memory pool other than the first memory space to the second user's process according to the cache request instruction.

[0084] It can be seen that through the above process, the memory space in the shared memory pool allocated to processes of different users can be isolated, thereby avoiding the problem of unauthorized access between processes of different users.

[0085] In one possible embodiment, before the cache service process sends the address of the first memory space to the first process, the cache service process creates a namespace for the first user. Namespaces are a resource isolation solution at the user level. The cache service process creates different namespaces for different users. When allocating memory space in the shared memory pool to each user's process, the cache service process first adds the memory space allocated for the user's process to the user's namespace. Each user's process can access the memory space in its own namespace, but cannot access the memory space in other users' namespaces. The cache service process adds the memory space allocated for the user's process to the user's namespace, which can be understood as making the memory space allocated for the user's process a member of the user's namespace. As shown in Figure 3, the first and second memory spaces allocated for the first user's first process both become members of the first user's namespace, and the third and fourth memory spaces allocated for the second user's process both become members of the second user's namespace, thereby achieving isolation of memory space resources in the shared memory pool corresponding to different users.

[0086] Based on the above content, each step shown in FIG2 is introduced in detail below.

[0087] In S201, the cache service process allocates a first memory space in a shared memory pool to the first process and the second process for sharing. For a specific implementation process, please refer to the above description. For the sake of brevity, it will not be elaborated here.

[0088] Regarding the first IO request and the second IO request in S202 and S205, and regarding the data corresponding to the first IO request and the data corresponding to the second IO request in S203 and S206, please refer to the above description, which will not be elaborated here for the sake of brevity.

[0089] In S207, after receiving the second cache application instruction sent by the second process, the cache service process can first determine whether there is memory space in the memory space allocated by the first process that is not allocated to the second process. If it is determined that there is memory space in the memory space allocated by the first process that is not allocated to the second process, the memory space not allocated to the second process is allocated to the second process. If the first memory space allocated to the first process has been allocated to the second process, and the second memory space allocated to the first process has not been allocated to the second process, the second memory space is allocated to the second process. Otherwise, a section of the remaining memory space in the shared memory pool is allocated to the second process according to the second cache application instruction.

[0090] In S204, the cache service process allocates the second memory space in the shared memory pool to the first process, and in S207, the cache service process allocates the second memory space to the second process. For the specific implementation process, please refer to the relevant description above. For the sake of brevity of the specification, it will not be elaborated here.

[0091] It should be noted that the above-mentioned first memory space can be a memory space with continuous addresses in the shared memory pool, or a memory space with discontinuous addresses. The above-mentioned second memory space can be a memory space with continuous addresses in the shared memory pool, or a memory space with discontinuous addresses. This application does not make any specific limitations on this.

[0092] In a specific embodiment of the present application, the cache service process allocates memory space (such as the second memory space) in the shared memory pool to the user process according to a cache request instruction (such as the first cache request instruction) sent by the user process (such as the first process). The sizes of the memory space can be the following:

[0093] ①The size of the memory space allocated by the cache service process each time is fixed.

[0094] ② The cache service process allocates according to user needs, that is, the cache application instruction sent by the user process carries the capacity of the memory space to be applied for. The cache service process allocates memory space in the shared pool to the user process according to the capacity of the memory space to be applied for carried by the cache application instruction. The capacity of the allocated memory space is the same as the capacity of the memory space to be applied for carried by the cache application instruction.

[0095] It should be understood that the above-mentioned method ① and method ② are merely examples and should not be regarded as limitations on the implementation method of the cache service process dividing the memory space according to the first cache application instruction.

[0096] In one possible embodiment, upon receiving a first cache request instruction from a first process, the cache service process may count the frequency of cache request instructions received from the first user's processes (referring to all processes of the first user) and determine whether the frequency is above a frequency threshold. If the frequency is determined to be above the frequency threshold, multiple second memory spaces in the shared memory pool are allocated to the first process according to the first cache request instruction. If the frequency is determined to be below or equal to the frequency threshold, one second memory space in the shared memory pool is allocated to the first process according to the first cache request instruction. In this way, the number of memory space requests by the first user's processes can be reduced.

[0097] In a specific embodiment of the present application, the cache service process can also store the data in the first memory space / second memory space to the disk of the computing cluster for persistent storage after the first memory space / second memory space is full of data. Then, the cache service process releases (reclaims) the first memory space / second memory space shared by the first process and the second process and / or the cache service process, thereby realizing circular and efficient utilization of the memory space in the shared memory pool.

[0098] Taking the cache service process releasing the first memory space shared by the first process, the second process and the cache service process as an example, in a possible embodiment, the cache service process immediately releases the first memory space shared by the first process, the second process and the cache service process after storing the data in the first memory space to the disk of the computing cluster.

[0099] In another possible embodiment, if the cache service process isolates memory space resources in a shared memory pool that can be used by processes of different users by creating user-level namespaces for different users, then the cache service process can, after storing the data in the first memory space on the disk of the computing cluster, determine whether the usage heat of the memory space in the first user's namespace is lower than a heat threshold. If it is determined that the usage heat is lower than the heat threshold, the first memory space shared by the first process, the second process, and the cache service process is released. Otherwise, the first memory space shared by the first process, the second process, and the cache service process is not released. The usage heat of the memory space in the first user's namespace can be reflected by usage frequency or turnover rate.

[0100] It can be understood that the usage heat of the memory space in the namespace of the first user is higher than or equal to the heat threshold, which means that the usage heat of the memory space in the namespace of the first user is relatively high. In this case, the cache service process does not release the first memory space shared by the first process, the second process and the cache service process, which can reduce the frequency of the first user's process applying for memory space.

[0101] Furthermore, the specific process of the cache service process releasing the first memory space shared by a process, a second process, and the cache service process can be: the cache service process generates marking information, the marking information indicates that the first memory space is unavailable, and then the cache service process sends marking information to the first process, the marking information is used by the first process to release the first memory space corresponding to the first process, and sends marking information to the second process, the marking information is used by the second process to release the first memory space corresponding to the second process, and then the cache service process itself releases the first memory space corresponding to the cache service process. The above-mentioned first process / second process / cache service process releasing the first memory space corresponding to itself refers to the first process / second process / cache service process releasing the mapping relationship between its own virtual address space and the first memory space.

[0102] Furthermore, taking the cache service process sending marking information to the first process as an example, the cache service process may send the marking information to the first process in the following manner 1 or manner 2.

[0103] Mode 1: The cache service process receives a request for obtaining tag information corresponding to the first memory space periodically sent by the first process, and returns the tag information to the first process according to the acquisition request.

[0104] Specifically, the cache service process may query whether there is tag information corresponding to the first memory space according to the acquisition request, and when determining that there is tag information corresponding to the first memory space, return the tag information corresponding to the first memory space to the first process.

[0105] Optionally, after generating the marking information, the cache service process may also directly send the marking information to the first process.

[0106] Method 2: The cache service process adds tag information to the first memory space, and the first process can obtain the tag information when accessing the first memory space. As shown in Figure 4, in Figure 4, taking the first memory space as memory space 2 as an example, the cache service process adds tag information to memory space 2.

[0107] In a specific implementation, if there is a process in the first user's process (taking the first process as an example) that has not released the first memory space corresponding to the first process, and the cache service process has released the first memory space corresponding to the cache service process first, if the first process accesses the first memory space corresponding to the first process again, the IO data corresponding to the first process cannot be persistently stored to the disk, and even causes the first process to crash. In order to avoid the above situation, the cache service process can release the first memory space corresponding to the cache service process after determining that all user processes sharing the first memory space (i.e., the first process and the second process) have released their corresponding first memory spaces.

[0108] In one possible embodiment, if the cache service process sends marking information to the first process and the second process that share the first memory space through the above-mentioned method 1, the cache service process can start counting from the moment when it last received an acquisition request from the first user's process, and when the count reaches the first duration, determine that both the first process and the second process have released their corresponding first memory spaces. It can be understood that when the count from the moment when the cache service process last received an acquisition request from the first user's process reaches the first duration, it means that the first process and the second process have not sent an acquisition request to the cache service process for a long time, which generally indicates that both the first process and the second process have released their respective first memory spaces.

[0109] The above-mentioned first duration can be customized according to the actual scenario. For example, the cache service process can set a cycle. When the cache service process has waited for a certain number of cycles after receiving the acquisition request from the first user's process for the last time, it is determined that the first process and the second process both release their corresponding first memory space.

[0110] Optionally, after releasing the first memory space corresponding to itself, the first process / the second process may send a notification to the cache service process to notify that the first memory space corresponding to the first process / the second process has been released.

[0111] In a specific implementation, if the cache service process is to isolate the memory space resources in the shared memory pool that can be used by processes of different users by creating user-level namespaces for different users, taking the first process releasing the first memory space corresponding to the first process as an example, the first process can clear the first memory space in the namespace of the first user in the first process and release the mapping relationship between the virtual address space in the first process and the first memory space. The process of the second process releasing the first memory space corresponding to the second process and the process of the cache service process releasing the first memory space corresponding to the cache service process are similar to the process of the first process releasing the first memory space corresponding to the first process, and will not be elaborated here.

[0112] When multiple processes share the same memory space, taking the first process and the second process sharing the first memory space as an example, in order to ensure safe access to the first memory space and avoid resource contention and data inconsistency problems, a synchronization mechanism (such as locking) can be used to protect the first memory space to ensure that only one process can access the first memory space at a time.

[0113] When a computing cluster includes multiple computing devices and the shared memory pool of the computing cluster is composed of memories in multiple computing devices, when the cache service process receives a first cache request instruction from a first process, the cache service process can search for free memory space from the shared memory pool and allocate it to the first process based on the principle of local first and remote later.

[0114] The principle of local first and remote later. For example, as shown in Figure 5, assume that the first process is performed by computing device A, and the computing cluster also includes computing device B. The shared memory pool is composed of the memory of computing device A and the memory of computing device B. Then, computing device A is a local device for the first process, and computing device B is a remote device for the first process. When the memory service process allocates the first memory space to the first process, it first determines whether there is free memory space in the memory of computing device A that can be allocated. If so, it allocates it directly from the memory of computing device A. If not, it accesses computing device B to determine whether there is free memory space in the memory of computing device B that can be allocated.

[0115] In one possible embodiment, the computing cluster may be a high performance computing (HPC) cluster. HPC refers to a system that uses multiple processors on a single computing device or a computing system and environment across multiple computing devices in a cluster to perform complex computations.

[0116] It should be noted that, in the above embodiment, the description is made by taking the example that the process of the first user includes two processes, the first process and the second process. In a specific implementation, the process of the first user may include more processes. When the process of the first user includes more processes, the manner in which the more processes use the shared memory pool is similar to the manner in which the first process and the second process use the shared memory pool. For the sake of brevity of the specification, it will not be elaborated on.

[0117] It can be seen from the above embodiments that in the cache management method provided by the present application, since the first memory space in the shared memory pool is shared only by the first process of the first user and the second process of the first user, and is not shared by processes of other users, the first process of the first user and the second process of the first user have the authority to access the data in the first memory space, while processes of other users do not have the authority to access the data in the first memory space, thereby preventing the data in the first memory space from being accessed without authorization. Similarly, since the second memory space in the shared memory pool is shared only by the first process of the first user and the second process of the first user, and is not shared by processes of other users, the first process of the first user and the second process of the first user have the authority to access the data in the second memory space, while processes of other users do not have the authority to access the data in the second memory space, thereby preventing the data in the second memory space from being accessed without authorization.

[0118] In addition, in the above scheme, since the cache service process allocates the second memory space to the first process according to the first cache application instruction sent by the first process when the current first memory space of the first process is not enough to store the data corresponding to the first IO request, and allocates the second memory space to the second process according to the second cache application instruction sent by the second process when the first memory space corresponding to the second process is not enough to store the data corresponding to the second IO request, dynamic allocation of the shared memory pool is realized. It can be understood that when the shared memory pool can be dynamically allocated, waste of memory pool resources can be avoided and efficient use of memory pool resources can be achieved.

[0119] It should be understood that the size of the serial numbers of the steps in the embodiment shown in Figure 2 does not mean 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 embodiment of the present application.

[0120] Next, the cache management device provided by this application will be introduced. It should be understood that the unit modules within the cache management device can also be divided into multiple categories. Each module can be a software module, a hardware module, or partly a software module and partly a hardware module. This application does not limit this. When the cache management device includes multiple unit modules, each of the multiple unit modules can be deployed on the same computing device (such as a server) or on different computing devices. This application does not make specific limitations.

[0121] Refer to Figure 6, which is a structural diagram of a cache management device 600 provided in an embodiment of the present application. The device 600 can be applied to the computing cluster shown in Figure 1 including at least one computing device. As shown in Figure 6, the device 600 includes: an acquisition module 610, a sending module 620 and a memory allocation module 630.

[0122] The following is an illustrative introduction to the functions of each module of the cache management device 600. It should be understood that the functions of each module described below are merely functions that the cache management device 600 may have in some embodiments of this application, and this application does not limit the functions of each module.

[0123] An acquisition module 610 is configured to acquire, through a first process, a first IO request corresponding to the first process;

[0124] a sending module 620 configured to send a first cache request instruction to the cache service process via the first process when a first memory space currently in the first process is insufficient to store data corresponding to the first IO request, wherein the first memory space is a space in a shared memory pool and is shared by the first process and the second process;

[0125] The memory allocation module 630 is configured to allocate a second memory space in the shared memory pool to the first process according to the first cache request instruction through the cache service process;

[0126] The acquisition module 610 is further configured to acquire, through the second process, a second IO request corresponding to the second process;

[0127] The sending module 620 is further configured to send a second cache application instruction to the cache service process through the second process when the first memory space corresponding to the second process is insufficient to store data corresponding to the second IO request;

[0128] The memory allocation module 630 is further configured to allocate the second memory space to the second process according to the second cache application instruction through the cache service process.

[0129] In some possible embodiments, the memory allocation module 630 is specifically configured to:

[0130] When the cache service process determines that the frequency of the cache application instructions received from the first user's process is higher than a frequency threshold, the cache service process allocates multiple second memory spaces in the shared memory pool to the first process according to the first cache application instruction.

[0131] In some possible embodiments, the memory allocation module 630 is specifically configured to:

[0132] The cache service process allocates a second memory space in the shared memory pool to the first process according to the first capacity carried in the first cache application instruction, where the capacity of the second memory space is the first capacity.

[0133] In some possible embodiments, the capacity of the second memory space is fixed.

[0134] In some possible embodiments, the first memory space is shared by the first process, the second process, and the cache service process.

[0135] In some possible embodiments, as shown in FIG6 , the apparatus 600 further includes: a memory release module 640 ;

[0136] The memory release module 640 is used to:

[0137] After the first memory space is full of data, the cache service process stores the data in the first memory space in a disk of the computing cluster;

[0138] The first memory space shared by the first process, the second process and the cache service process is released through the cache service process.

[0139] In some possible embodiments, the memory release module 640 is specifically used to release the first memory space shared by the first process, the second process and the cache service process when the usage heat of the memory space in the namespace of the first user is lower than the heat threshold through the cache service process, wherein the namespace of the first user includes the memory space allocated to the first process and the memory space allocated to the second process in the shared memory pool.

[0140] In some possible embodiments, the memory release module 640 is specifically configured to:

[0141] Generate marking information by the cache service process, where the marking information indicates that the first memory space is unavailable;

[0142] Sending marking information to the first process through the cache service process, where the marking information is used by the first process to release the first memory space corresponding to the first process;

[0143] Sending marking information to the second process through the cache service process, where the marking information is used by the second process to release the first memory space corresponding to the second process;

[0144] The first memory space corresponding to the cache service process is released through the cache service process.

[0145] In some possible embodiments, the first process, the second process, and the cache service process run on the same computing device or different computing devices in the computing cluster.

[0146] Specifically, the specific implementation of various operations performed by the cache management device 600 can refer to the cache management method provided in this application shown in Figure 2 above, and for the sake of brevity of the specification, it will not be repeated here.

[0147] In a specific implementation, the acquisition module 610, the sending module 620, the memory allocation module 630, and the memory release module 640 can all be implemented by software or hardware. For example, the implementation of the sending module 620 will be described below using the sending module 620 as an example. Similarly, the implementation of the acquisition module 610, the memory allocation module 630, and the memory release module 640 can refer to the implementation of the sending module 620.

[0148] As an example of a software functional unit, the sending module 620 may include code running on a computing instance. The computing instance may include at least one of a physical host (computing device), a virtual machine, and a container. Furthermore, the computing instance may be one or more. For example, the sending module 620 may include code running on multiple hosts / virtual machines / containers. It should be noted that the multiple hosts / virtual machines / containers used to run the code may be distributed in the same region or in different regions. Furthermore, the multiple hosts / virtual machines / containers used to run the code may be distributed in the same availability zone (AZ) or in different AZs, each AZ including one data center or multiple geographically close data centers. Typically, a region may include multiple AZs.

[0149] Similarly, multiple hosts / virtual machines / containers running the code can be distributed within the same virtual private cloud (VPC) or across multiple VPCs. Typically, a VPC is set up within a region. Cross-region communication between two VPCs within the same region, or between VPCs in different regions, requires a communication gateway within each VPC to interconnect the VPCs.

[0150] As an example of a hardware functional unit, the sending module 620 may include at least one computing device, such as a server. Alternatively, the sending module 620 may be implemented using an application-specific integrated circuit (ASIC) or a programmable logic device (PLD). The PLD may be a complex programmable logical device (CPLD), a field-programmable gate array (FPGA), a generic array logic (GAL), or any combination thereof.

[0151] When the sending module 620 includes multiple computing devices, the multiple computing devices can be distributed in the same region or in different regions. The multiple computing devices included in the sending module 620 can be distributed in the same AZ or in different AZs. Similarly, the multiple computing devices included in the sending module 620 can be distributed in the same VPC or in multiple VPCs. The multiple computing devices can be any combination of computing devices such as servers, ASICs, PLDs, CPLDs, FPGAs, and GALs.

[0152] It should be noted that, in other embodiments, the sending module 620 can be used to execute any steps executed by the first process, the second process, and the cache service process in the cache management processing method shown in FIG2 ; the acquiring module 610 can be used to execute any steps executed by the first process, the second process, and the cache service process in the cache management processing method shown in FIG2 ; the memory allocation module 630 can be used to execute any steps executed by the first process, the second process, and the cache service process in the cache management processing method shown in FIG2 ; the memory release module 640 can be used to execute any steps executed by the first process, the second process, and the cache service process in the cache management processing method shown in FIG2 ;

[0153] The steps that the acquisition module 610, the sending module 620, the memory allocation module 630 and the memory release module 640 are responsible for implementing can be specified as needed. The cache management processing method is implemented by respectively implementing different steps in the cache management processing method shown in Figure 2 through the acquisition module 610, the sending module 620, the memory allocation module 630 and the memory release module 640.

[0154] The present application also provides a computing device that can deploy the cache management apparatus 600 shown in Figure 6. Referring to Figure 7 , as shown in Figure 7 , the computing device 700 includes a processor 710 , a memory 720 , and a communication interface 730 , wherein the processor 710 , the memory 720 , and the communication interface 730 can be interconnected via a bus 740 .

[0155] The processor 710 can read the program code (including instructions) stored in the memory 720 and execute the program code stored in the memory 720, so that the computing device 700 executes the cache management method provided in this application as shown in Figure 2, or enables the computing device 700 to deploy the cache management device 600.

[0156] Processor 710 can have various specific implementation forms, such as a central processing unit (CPU), or a combination of a CPU and a hardware chip. The hardware chip can be an application-specific integrated circuit (ASIC), a programmable logic device (PLD), or a combination thereof. The PLD can be a complex programmable logic device (CPLD), a field-programmable gate array (FPGA), a generic array logic (GAL), or any combination thereof. Processor 710 executes various types of digitally stored instructions, such as software or firmware programs stored in memory 720, which enables computing device 700 to provide various services.

[0157] The memory 720 is used to store program code and is controlled for execution by the processor 710. The program code may include one or more software modules, which may be the software modules provided in the embodiment shown in FIG6 , such as the code of the acquisition module 610, the code of the sending module 620, the code of the memory allocation module 630, and the code of the memory release module 640.

[0158] The memory 720 may include a volatile memory, such as a random access memory (RAM); the memory 720 may also include a non-volatile memory, such as a read-only memory (ROM), a flash memory, a hard disk drive (HDD), or a solid-state drive (SSD); the memory 720 may also include a combination of the above types.

[0159] The communication interface 730 may be a wired interface (e.g., an Ethernet interface, a fiber optic interface, or other types of interfaces (e.g., an InfiniBand interface)) or a wireless interface (e.g., a cellular network interface or a wireless local area network interface) for communicating with other computing devices or apparatuses. The communication interface 730 may utilize a protocol suite based on the Transmission Control Protocol / Internet Protocol (TCP / IP), such as the Remote Function Call (RFC) protocol, the Simple Object Access Protocol (SOAP) protocol, the Simple Network Management Protocol (SNMP) protocol, the Common Object Request Broker Architecture (CORBA) protocol, and distributed protocols.

[0160] Bus 740 may be a Peripheral Component Interconnect Express (PCIe) bus, an Extended Industry Standard Architecture (EISA) bus, a unified bus (Ubus or UB), a Compute Express Link (CXL), a Cache Coherent Interconnect for Accelerators (CCIX), or the like. Bus 740 may be divided into an address bus, a data bus, a control bus, or the like. In addition to a data bus, bus 740 may also include a power bus, a control bus, and a status signal bus. However, for clarity, various buses are labeled as bus 740 in the figure. For ease of illustration, FIG7 shows only one thick line, but this does not mean that there is only one bus or one type of bus.

[0161] The computing device 700 may be a server, such as a central server, an edge server, or a local server in a local data center. In some embodiments, the computing device 700 may also be a terminal device such as a desktop computer or a laptop computer.

[0162] The computing device 700 is used to execute the cache management method provided in the present application as shown in FIG. 2 . The specific implementation process is detailed in the above method embodiment and will not be repeated here.

[0163] It should be understood that computing device 700 is only an example provided in an embodiment of the present application, and computing device 700 may have more or fewer components than those shown in FIG. 7 , may combine two or more components, or may have different configurations of components.

[0164] An embodiment of the present application further provides a computing cluster, which can deploy the cache management device 600 shown in FIG6 , and the operations and / or functions of each module in the computing cluster are respectively for implementing the corresponding steps in the cache management method shown in FIG2 .

[0165] 8 , as shown in FIG8 , a computing cluster 800 includes at least one computing device 700. The memory 720 in one or more computing devices 700 in the computing cluster 800 may store the same instructions for executing the cache management method shown in FIG2 .

[0166] In some possible implementations, the memory 720 of one or more computing devices 700 in the computing cluster 800 may also store partial instructions for executing the cache management method shown in FIG2 . In other words, the combination of one or more computing devices 700 may jointly execute instructions for executing the cache management method shown in FIG2 .

[0167] It should be noted that the memories 720 in different computing devices 700 in the computing cluster 800 may store different instructions, each for executing a portion of the functions of the cache management apparatus 600. That is, the instructions stored in the memories 720 in different computing devices 700 may implement the functions of one or more of the acquisition module 610, the sending module 620, the memory allocation module 630, and the memory release module 640.

[0168] An embodiment of the present application further provides a computer-readable storage medium, which stores instructions. When the instructions are executed, some or all of the steps of the cache management method described in the above embodiment can be implemented.

[0169] The embodiment of the present application also provides a computer program product. When the computer program product is read and executed by a computer, it can implement some or all of the steps of the cache management method recorded in the above method embodiment.

[0170] In the above embodiments, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0171] In the above embodiments, it can be implemented in whole or in part by software, hardware or any combination thereof. When software is used for implementation, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the process or function described in the embodiment of the present application is generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another computer-readable storage medium. For example, the computer instructions can be transmitted from a website, computer, server or data center to another website, computer, server or data center by wired (e.g., coaxial cable, optical fiber, digital subscriber line) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that a computer can access or a data storage device such as a server or data center that includes one or more available media integrations. The available medium can be a magnetic medium (e.g., a floppy disk, a hard disk, a tape), an optical medium, or a semiconductor medium.

[0172] The above is only a specific embodiment of the present application. Those skilled in the art may conceive of changes or substitutions based on the specific embodiment provided in this application, and all such changes or substitutions shall fall within the scope of protection of this application.

Claims

1. A cache management method, characterized in that: Applied to a computing cluster including at least one computing device, the computing cluster runs a first process and a second process of a first user and a cache service process, the computing cluster includes a shared memory pool, and the method includes: The first process obtains a first input / output (IO) request corresponding to the first process; When the current first memory space of the first process is insufficient to store data corresponding to the first IO request, the first process sends a first cache application instruction to the cache service process, where the first memory space is a section of space in the shared memory pool and is shared by the first process and the second process; The cache service process allocates a second memory space in the shared memory pool to the first process according to the first cache application instruction; The second process obtains, by the second process, a second IO request corresponding to the second process; When the first memory space corresponding to the second process is insufficient to store data corresponding to the second IO request, the second process sends a second cache application instruction to the cache service process; The cache service process allocates the second memory space to the second process according to the second cache application instruction.

2. The method according to claim 1, characterized in that The cache service process allocates the second memory space in the shared memory pool to the first process according to the first cache application instruction, including: When the cache service process determines that the frequency of the cache application instructions received from the process of the first user is higher than a frequency threshold, the cache service process allocates a plurality of second memory spaces in the shared memory pool to the first process according to the first cache application instructions.

3. The method according to claim 1 or 2, characterized in that: The cache service process allocates the second memory space in the shared memory pool to the first process according to the first cache application instruction, including: The cache service process allocates a second memory space in the shared memory pool to the first process according to the first capacity carried in the first cache application instruction, and the capacity of the second memory space is the first capacity.

4. The method according to claim 1 or 2, characterized in that: The capacity of the second memory space is fixed.

5. The method according to any one of claims 1 to 4, characterized in that: The first memory space is shared by the first process, the second process and the cache service process.

6. The method according to any one of claims 1 to 5, characterized in that: The method further comprises: After the first memory space is full of data, the cache service process stores the data in the first memory space in a disk of the computing cluster; The cache service process releases the first memory space shared by the first process, the second process, and the cache service process.

7. The method according to claim 6, characterized in that The cache service process releases the first memory space shared by the first process, the second process, and the cache service process, including: When the cache service process determines that the usage heat of the memory space in the namespace of the first user is lower than a heat threshold, the cache service process releases the first memory space shared by the first process, the second process and the cache service process, wherein the namespace of the first user includes the memory space allocated to the first process and the memory space allocated to the second process in the shared memory pool.

8. The method according to claim 6 or 7, characterized in that: The cache service process releases the first memory space shared by the first process, the second process, and the cache service process, including: The cache service process generates marking information, where the marking information indicates that the first memory space is unavailable; The cache service process sends the marking information to the first process, where the marking information is used by the first process to release the first memory space corresponding to the first process; The cache service process sends the marking information to the second process, where the marking information is used by the second process to release the first memory space corresponding to the second process; The cache service process releases the first memory space corresponding to the cache service process.

9. The method according to any one of claims 1 to 8, characterized in that: The first process, the second process and the cache service process run on the same computing device or different computing devices in the computing cluster.

10. A cache management device, characterized in that: Applied to a computing cluster including at least one computing device, the computing cluster runs a first process and a second process of a first user and a cache service process, the computing cluster includes a shared memory pool, and the apparatus includes: An acquisition module, configured to acquire, through the first process, a first IO request corresponding to the first process; a sending module, configured to send a first cache application instruction to the cache service process through the first process when the current first memory space of the first process is insufficient to store data corresponding to the first IO request, wherein the first memory space is a section of space in the shared memory pool and is shared by the first process and the second process; a memory allocation module, configured to allocate a second memory space in the shared memory pool to the first process through the cache service process according to the first cache application instruction; The acquisition module is further used to acquire, through the second process, a second IO request corresponding to the second process; The sending module is further configured to send a second cache application instruction to the cache service process through the second process when the first memory space corresponding to the second process is insufficient to store data corresponding to the second IO request; The memory allocation module is further configured to allocate the second memory space to the second process through the cache service process according to the second cache application instruction.

11. The device according to claim 10, characterized in that The memory allocation module is specifically used for: When the cache service process determines that the frequency of the cache application instructions received from the first user's process is higher than a frequency threshold, multiple second memory spaces in the shared memory pool are allocated to the first process according to the first cache application instructions.

12. The device according to claim 10 or 11, characterized in that The memory allocation module is specifically used for: The cache service process allocates a second memory space in the shared memory pool to the first process according to the first capacity carried in the first cache application instruction, and the capacity of the second memory space is the first capacity.

13. The device according to claim 10 or 11, characterized in that The capacity of the second memory space is fixed.

14. The device according to any one of claims 10 to 13, characterized in that The first memory space is shared by the first process, the second process and the cache service process.

15. The device according to any one of claims 10 to 14, characterized in that The device also includes: a memory release module; The memory release module is used to: After the first memory space is full of data, the cache service process stores the data in the first memory space in a disk of the computing cluster; The first memory space shared by the first process, the second process and the cache service process is released through the cache service process.

16. The device according to claim 15, characterized in that The memory release module is specifically used for: When the cache service process determines that the usage heat of the memory space in the namespace of the first user is lower than a heat threshold, the first memory space shared by the first process, the second process and the cache service process is released, wherein the namespace of the first user includes the memory space allocated to the first process and the memory space allocated to the second process in the shared memory pool.

17. The device according to claim 15 or 16, characterized in that The memory release module is specifically used for: Generate marking information by the cache service process, where the marking information indicates that the first memory space is unavailable; Sending the marking information to the first process through the cache service process, where the marking information is used by the first process to release the first memory space corresponding to the first process; Sending the marking information to the second process through the cache service process, where the marking information is used by the second process to release the first memory space corresponding to the second process; The first memory space corresponding to the cache service process is released through the cache service process.

18. The device according to any one of claims 10 to 17, characterized in that The first process, the second process and the cache service process run on the same computing device or different computing devices in the computing cluster.

19. A computing cluster, characterized in that: It includes at least one computing device, each of which includes a processor and a memory; the processor of the at least one computing device is used to execute instructions stored in the memory of the at least one computing device, so that the computing cluster executes the method according to any one of claims 1 to 9.

20. A computer storage medium, characterized in that The computer storage medium stores a computer program for inter-process communication, and when the computer program is executed by a processor, the method according to any one of claims 1 to 9 is implemented.

Images