Method for storage, electronic device, program product

Abstract

The invention relates to a method for storage, an electronic device, and a program product. The embodiment of the invention relates to a storage method. The method includes receiving data by a first container of a first set of containers. The method further includes transmitting the data from the first container to a second container of the first set of containers via a transport protocol, where the second container is to assist in implementing functionality of the first set of containers and includes a large memory page, and writing the data into the disk via the second container. By using the method provided by the invention, the memory can be shared among different container sets or a plurality of containers, the storage performance of a large object in an object storage system is remarkably improved, and some containers have special resources thereof.

Description

Technical Field

[0001] The embodiments of the present disclosure relate to the field of computers, and in particular, to a storage method, an electronic device, and a program product. Background Art

[0002] Cloud-native object storage systems can provide high-performance storage to customers or consumers. For example, a cloud-native object storage system running on Kubernetes can be centrally managed across edge locations, automate operations, provide flexibility through its open design, ensure zero-trust security, and provide multi-cloud connectivity. The NVMe (Nonvolatile Memory Express) version of the cloud-native object storage system can be based on NVMe-over-Fabrics (NVMe-oF), enabling access to storage such as solid-state drives.

[0003] At the same time, the cloud-native object storage system can also be expanded to any capacity and sites can be connected with just a click, and can serve as a globally accessible data lake for enterprise workloads such as cloud-native, artificial intelligence, analytics, and archiving. Summary of the invention

[0004] The embodiments of the present disclosure relate to a storage method, an electronic device, and a computer program product.

[0005] According to a first aspect of the present disclosure, a method for storage is provided. The method includes receiving data through a first container in a first container set. The method also includes transmitting the data from the first container to a second container in the first container set via a transmission protocol, wherein the second container is used to assist in implementing a function of the first container set and includes a large memory page, and writing the data to a disk via the second container.

[0006] According to a second aspect of the present disclosure, an electronic device for storage is provided. The electronic device includes at least one processor; and a memory coupled to the at least one processor and having instructions stored thereon, the instructions causing the electronic device to perform an action when executed by the at least one processor, the action including receiving data through a first container in a first container set. The electronic device also includes transmitting data from the first container to a second container in the first container set via a transmission protocol, wherein the second container is used to assist in implementing the function of the first container set and includes a large memory page, and writing data to a disk via the second container.

[0007] According to a third aspect of the present disclosure, there is provided a computer program product, which is tangibly stored on a non-volatile computer-readable medium and includes machine-executable instructions, which when executed cause a machine to perform the steps of the method implemented in the first aspect of the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] The above and other objects, features and advantages of the present disclosure will become more apparent through a more detailed description of exemplary embodiments of the present disclosure in conjunction with the accompanying drawings, wherein like reference numerals generally represent like elements throughout the exemplary embodiments of the present disclosure.

[0009] Figure 1 A schematic diagram of an example storage system in which devices and / or methods according to embodiments of the present disclosure may be implemented;

[0010] Figure 2 A flowchart of a method for storing according to some embodiments of the present disclosure is shown;

[0011] Figure 3 An internal structure diagram of an engine container set as a second container set according to some embodiments of the present disclosure is shown;

[0012] Figure 4 A schematic diagram of an IO path for interaction between an engine container set and a data head service container set implemented according to some embodiments of the present disclosure is shown;

[0013] Figure 5 A schematic diagram showing memory sharing between a sidecar container and another container according to some embodiments of the present disclosure is shown;

[0014] Figure 6 Some experimental results according to some embodiments of the present disclosure are illustrated;

[0015] Figure 7 A schematic block diagram of an example device that can be used to implement embodiments of the present disclosure is shown. DETAILED DESCRIPTION

[0016] The preferred embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although some specific embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided to make the present disclosure more thorough and complete, and to fully convey the scope of the present disclosure to those skilled in the art.

[0017] As used herein, the term "including" and its variations mean open inclusion, i.e., "including but not limited to". Unless otherwise stated, the term "or" means "and / or". The term "based on" means "based at least in part on". The terms "an example embodiment" and "an embodiment" mean "at least one example embodiment". The term "another embodiment" means "at least one additional embodiment". The terms "first", "second", etc. may refer to different or the same objects, unless explicitly indicated to be different.

[0018] Cloud native object storage systems can provide high-performance storage and meet the needs of modern workloads such as AI, big data, and machine learning, so their performance becomes critical. Memory replication can be avoided as much as possible by leveraging shared memory technology. However, in storage systems based on Kubernetes, shared memory across container sets ("pods") is not allowed for security and isolation reasons.

[0019] With the rapid development of hardware across computing, storage, and networking, the software overhead has become significant. In the case of high throughput, the bottleneck that causes the software overhead is the excessive memory copy operations in the IO path, which plays a vital role in performance optimization. In addition, in performance testing, the total throughput of the storage system is usually not limited by the hardware, but by the software cost.

[0020] By minimizing the amount of data replication between container sets, shared memory can be incorporated on the IO path between two components. However, different components are deployed in different Kubernetes container sets and different namespaces, which complicates the implementation of shared memory across containers and also violates the Kubernetes resource isolation principle; ensuring cross-container security when sharing memory is difficult and requires careful consideration to avoid potential security risks; in addition, implementations such as NVMe-oF engines are usually based on the Storage Performance Development Kit (SPDK), which uses large memory pages and does not support conventional shared memory. At the same time, since sidecar containers also need to consume resources, it brings resource challenges.

[0021] At least to solve the above and other potential problems, an embodiment of the present disclosure provides a method for storage. The method includes receiving data through a first container in a first container set. The method also includes transmitting data from the first container to a second container in the first container set via a transport protocol, wherein the second container is used to assist in implementing the function of the first container set and includes a large memory page ("huge page"), and writing the data to the disk via the second container. By using this method, memory sharing between different container sets or multiple containers can be achieved. It can significantly improve the storage performance of large objects in cloud-based native object storage systems, and can be used as a useful reference for similar scenarios running on Kubernetes. According to the implementation of the present disclosure, resource consumption can also be reduced by creating a sidecar container with the same functionality as the original container set and placing it in a container set that wants to have shared memory access. According to the implementation of the present disclosure, some consumer containers / services have their own dedicated resources by owning the sidecar container when the sidecar container is located on the critical IO path. Other consumer containers / services can continue to share resources in the original container set as usual.

[0022] The basic principles and several exemplary embodiments of the present disclosure will be described in detail below with reference to the accompanying drawings. Figure 1 A schematic diagram of an example storage system 100 is shown in which devices and / or methods according to embodiments of the present disclosure may be implemented. Figure 1 The example storage system 100 in FIG. 1 may include a data head service container set (“dataheadSvc pod”) 101 and on-heap / off-heap memory 102 therein, UDS (“Unix Domain Socket”) buffers 104-1 and 104-2, an NVMe-oF engine container set 108, huge memory pages 112, an NVMe-oF protocol 116, and one or more disks 120 such as SSDs. It should be understood that Figure 1 The types and numbers of components, data transmission processes, arrangements, etc. shown are only exemplary, and the example storage system 100 may include components, data transmission processes, and various additional elements of different numbers and arrangements in different ways. For example, the storage system may also have one or more other container sets. It should also be understood that the above examples are only used to illustrate the storage method.

[0023] The data header service container set 101 may be a container set based on a header service protocol such as S3 (“Simple Storage Service”), which may accept various input data from users via a data header interface, such as object storage data such as photos, videos, documents, logs, backups, etc. uploaded by users, thereby storing the user data in the storage system 100. In the process of reading and writing user data, the data header service container set 101 may consume a large amount of resources in the storage system 100, such as CPU resources, memory resources, etc.

[0024] It should also be understood that in an embodiment of the present disclosure, as an example, a container set such as a data head service container set 101 and an NVMe-oF engine container set 108 may contain one or more containers that share the same network namespace, storage volumes, and other resources. Container sets are typically used to run different parts of an application that need to work together and need to share the same context. Containers within a container set can communicate directly with each other because they run in the same network namespace. Container sets such as a data head service container set 101 and an NVMe-oF engine container set 108 can be isolated from each other, with different container sets having different namespaces.

[0025] Since the data header service container set 101 itself has no capabilities, it can first store the data from the user in its own in-heap / off-heap memory 102 based on a JAVA virtual machine mechanism. The data header service container set 101 can then transfer the stored data to the NVMe-oF engine container set 108 via the UDS buffer 104. The NVMe-oF engine container set 108 can provide underlying IO storage services for other container sets, eventually write user data to the disk 120, and be responsible for accessing the drive / disk 120 on the remote host via the NVMe-oF engine structure.

[0026] The UDS buffers 104-1 and 104-2 may be protocols for communication and data transfer between processes / container sets on the same computer. The data header service container set 101 may first write the data from the user into the send UDS buffer 140-2 of the socket. The NVMe-oF engine container set 108 may then store the data in its own UDS buffer 140-2. Since the data in the UDS buffer 140-2 cannot directly access the disk 120 via the NVMe-oF protocol 116, the NMe-oF engine container set 108 may first write / read the data into the large memory page 112. As an example, in an embodiment of the present disclosure, the large memory page 112 may be a memory page having a size larger than a general memory page, for example, the large memory page 112 may have a memory page of 2MB in size, while the general memory page size is typically around a few KB.

[0027] in this way, Figure 1 The diagram shows a data persistence IO path from the data head service container set 101 to the NVMe-oF engine container set 108. The data head service container set 101 can send IO data to the NVMe-oF engine container set 108 or receive IO data from the NVMe-oF engine container set 108 via the UDS buffers 104-1 and 104-2. Three data copy operations need to occur for each IO data. This increases the number of read and write times during the copy process and the resource consumption of the storage system 100.

[0028] The storage system 100 can be installed in any computing device that has processing computing resources or storage resources. For example, the computing device can have common capabilities such as receiving and sending data requests, real-time data analysis, local data storage, and real-time network connection. Computing devices can generally include various types of devices. Examples of computing devices may include, but are not limited to: desktop computers, notebook computers, smart phones, wearable devices, security equipment, smart manufacturing equipment, smart home equipment, Internet of Things devices, smart cars, drones, etc., and the present disclosure does not impose any restrictions on this.

[0029] Combined with the above Figure 1 A schematic diagram is described in which the method and / or process according to the embodiment of the present disclosure can be implemented. Figure 2 The flowchart of the method 200 for storage according to the embodiment of the present disclosure is described. The method 200 for storage according to the embodiment of the present disclosure can be executed at an edge device with computing capabilities, or at a cloud server, and the present disclosure does not limit this. In order to more effectively improve the read and write efficiency of storage, a method for storage according to an embodiment of the present disclosure is proposed.

[0030] At block 202, data is received through a first container in a first container set. According to an embodiment of the present disclosure, as an example, the first container set may be a data header service container set, which may accept various data uploaded by a user, such as object data such as photos and videos, and temporarily store the data in a container in the data header service container set.

[0031] At box 204, data is transferred from the first container to a second container in the first container set via a transport protocol, wherein the second container is used to assist in implementing the functionality of the first container set and includes large memory pages. According to an embodiment of the present disclosure, as an example, the second container may be a sidecar container. The sidecar container typically runs with a main application container set, such as a data header service container set, but does not provide the core functionality of the application, but provides some additional functionality or services to the application without modifying the code of the main application. As an example, the sidecar container may be used to collect logs generated by the main container and send them to a log collection system for monitoring and analysis. In some embodiments, the sidecar container may also be used to run a monitoring agent or a metric collector to monitor the performance indicators of the main container in real time and report to the monitoring system. In some embodiments, the sidecar container may be used to dynamically manage the configuration of the application, updating configuration parameters as needed. In summary, the sidecar container may assist in enhancing the functionality and performance of the application while maintaining the simplicity and maintainability of the application container.

[0032] As an example, the sidecar container can be initially deployed in a second container set such as an NVMe-oF engine container set. The second container set can connect and communicate with the first container set via the transmission protocol of the UDS buffer and transmit data. The second container set can also provide underlying service support for the services required by the first container set, such as being responsible for managing and running the first container, scheduling resources in the container, maintaining load balancing, and writing the data collected in the first container set to the disk of the storage system.

[0033] When the load in the first container set increases, the second container set first deploys one or more of its internal large memory pages to the second container, and then deploys the second container to the first container set. In order to enable one or more large memory pages to be dedicated to processing read and write requests between data, the processing system can generate IO threads by binding one or more large memory pages to a core in its central processor, and then deploy the IO threads to a second container such as a sidecar container. These IO threads can also be called IO worker threads, and are responsible for processing operations such as reading files, sending network requests, database queries, etc. They can be responsible for initiating and managing IO operations, and then returning the results to the main thread or other threads that need this data. This approach can improve the responsiveness of the application because the container / application will not be blocked by IO operations and can continue to perform other tasks.

[0034] At box 206, the data is written to the disk via the second container. Since the large memory pages have been deployed in the second container in the first container set, the second container can generate a large memory page file table based on the large memory pages deployed in the second container, wherein the large memory page file table may include large memory page files and sizes. The first container can then write the data to one or more large memory pages of the second container by modifying the large memory page file table, and write the data to a disk such as an SSD via the one or more large memory pages. Additionally or alternatively, in some embodiments, when the load or read and write operations in the first container set are reduced, the second container deployed in the first container set can be removed and redeployed to the second container set to wait for the reallocation of the second container set, so that the second container can be flexibly applied and deployed.

[0035] Combination of the above Figure 2 The flowchart of the method 200 for storing according to an embodiment of the present disclosure is described below. Figure 3 The internal structure diagram of the NVMe-oF engine container set 300 as the second container set according to an embodiment of the present disclosure is described. The NVMe-oF engine container set 300 can provide underlying services such as storage and operation for one or more containers in the memory system including the first container set.

[0036] like Figure 3 As shown, the NVMe-oF engine container set 300 may include, but is not limited to, UDS listener thread 301, IO worker threads 303-1 to 303-n, large memory pages 305-1 to 305-n, binding cores 307-1 to 307-n, manager thread 309, hard disk 312 and other elements. The NVMe-oF engine container set 300 can also communicate and transmit data via the NVMe-oF protocol with one or more hard disks such as SSDs mounted in the storage system, so that data from the user can be transmitted to the storage system. It should be understood that the NVMe-oF engine container set 300 may also include components of different numbers and arranged in different ways, and / or various additional elements, etc. It should also be understood that the above examples are only used to illustrate the NVMe-oF engine container set 300.

[0037] IO worker threads 303-1 to 303-n can also be called task threads, which are unique work units and can consume a large amount of resources in the process. Multiple task threads can share services or resources with each other. These task threads can simultaneously access, modify or use certain shared resources, such as shared memory areas, database connection pools, network sockets, etc. The number of task threads can be increased or decreased based on the service capabilities required by the consumer service / data header service container set.

[0038] refer to Figure 3 , the IO worker threads 303-1 to 303-n may further include one or more large memory pages 305-1 to 305-n, which may be used to process workloads such as large databases, high-performance computing, virtualization, etc., to improve memory access efficiency and reduce memory management overhead. Ordinary memory pages are usually 4KB or smaller in size. In contrast, large memory pages 305-1 to 305-n are larger memory pages, usually 2MB or larger in size. This larger page size may have several performance advantages, including but not limited to reducing the number of memory page tables, thereby reducing the overhead of page table lookups, because when using small pages, more page table entries are required to manage the same amount of memory; large memory pages may also improve TLB (Translation Lookaside Buffer) hit rates, thereby reducing memory access time; since the number of pages that need to be managed using large memory pages 305-1 to 305-n is smaller, memory management overhead may be reduced.

[0039] The IO worker threads 303-1 to 303-n may also include one or more cores 307-1 to 307-n bound from multiple cores of the central processing unit CPU. These cores may be dedicated to processing the data of the IO worker threads 303-1 to 303-n without participating in the processing of other computing resources, so that the IO worker threads 303-1 to 303-n can more efficiently utilize the processing computing resources, thereby reducing the overhead of thread switching and reducing the risk of competition conditions, so as to maximize the use of the CPU's computing resources and ensure that tasks are executed in a highly scalable manner on multiple threads.

[0040] The NVMe-oF engine container set 300 may also include a UDS listener thread 301, which may be used to listen to UDS connection requests from, for example, a data header service container set and / or other container sets and containers and accept these connections. When the UDS listener thread 301 receives these connections, it may assign one or more of the IO worker threads 303-1 to 303-n to these connections via the manager thread 309 for processing incoming data.

[0041] According to an embodiment of the present disclosure, as an example, the manager thread 309 can allocate IO worker threads 303-1 to 303-n based on the number of UDS interfaces in the UDS listener thread 301. For example, the UDS listener thread 301 can have 10 UDS interfaces, and each UDS interface can be bound to 100 IO worker threads in multiple IO worker threads 303-1 to 303-n via the manager thread 309, so that mutual binding between one UDS interface and multiple IO worker threads can be achieved. The IO worker thread can also be designed as a non-blocking thread, which can continue to perform other tasks or polling operations without having to wait for a certain operation to be completed or a certain condition to be satisfied.

[0042] When receiving data from other container sets, the UDS listener thread 301 can poll (periodically check) whether the (multiple) IO worker threads bound to each UDS interface are being used to determine their availability. If the (multiple) IO worker threads are currently performing read and write operations, the UDS listener thread 301 can choose not to call the (multiple) IO worker threads.

[0043] When it is determined that the IO worker threads bound to each UDS interface are available, the UDS listener thread 301 can assign read and write tasks to these IO worker threads. The IO worker thread can then write the data to its internal large memory page, and write the data to one or more hard disks 312 such as SSDs mounted in the storage system via the NVMe-oF protocol. The IO worker threads 303-1 to 303-n can be deployed to a sidecar container set such as a second container.

[0044] In this way, the NVMe-oF engine container set 300 is divided into two instances, namely, a sidecar container with reduced task threads. The sidecar container can then be assigned to the container set of key consumers of the head service in the IO path, such as the data head service container set. Placing the sidecar container in the container set of the consumer service makes it more flexible and can more easily implement shared memory or other operations that do not support cross-container sets. This method can also be a general solution to solve similar problems / scenarios.

[0045] Figure 4 FIG. 4 is a schematic diagram of an IO path 400 for interacting between an engine container set and a data head service container set according to an embodiment of the present disclosure. Figure 4As shown, when the load in the data header service container set 401 increases, the NVMe-oF engine container set 403 may redeploy one or more memory pages of the deployed large memory page 405-1 therein to a second container such as the sidecar container 407, such as the large memory page 405-2, through an IO worker thread. The sidecar container 407 may then be deployed to the data header service container set 401. The sidecar container 407 may allocate memory based on the deployed large memory page 405-2 therein and create a memory file mapping ("memory file mapping", mmp).

[0046] Memory file mapping can map part or the entire memory file in (multiple) large memory pages 405-2 to the process space of the data header service container set 401, so that data can be read and written directly in the memory without the need for explicit data read and write operations and copy operations, which can reduce data transmission, for example, which can be achieved through pointers or indexes.

[0047] As an example, the sidecar container 407 may allocate the large memory page 405-2 deployed therein, thereby creating a memory file of the large memory page 405-2. The sidecar container 407 may generate a large memory page file table 408-1 based on the necessary information associated with the memory file of the large memory page 405-2. The large memory page file table 408-1 may include large memory page files and capacity sizes such as mem_file_map_0, mem_file_map_1...mem_file_map_N. The large memory page file table 408-1 may then be transmitted to the first container such as container 409 of the data header service container set 401 via the UDS transmission protocol to form another large memory page file table 408-2. The large memory page file table 408-2 may be mapped to the process space of the container 409 in a memory file mapping manner. In this way, memory sharing between different containers can be achieved.

[0048] When the container 409 receives data from the user, it may first temporarily store the data in its corresponding off-heap / on-heap memory 410, and then the container 409 may modify the data in the huge memory page file table 408-2. The modified data in the huge memory page file table 408-2 may then be transmitted to the sidecar container 407 via the UDS transmission protocol. The sidecar container 407 modifies the huge memory page file table 408-1 and the huge memory page 405-2 accordingly based on the modified data. The modified data may eventually be read or written into the huge memory page 405-2 of the sidecar container 407. The sidecar container 407 may then write the data from the huge memory page 405-2 to a target hard disk 414 such as an SSD via a transmission protocol such as the NVMe-oF protocol.

[0049] At the same time, the NVMe-oF engine container set 403 can also receive input data from the memory of other service containers 418 in the storage system via the UDS transmission protocol through its own UDS buffer 416. These input data can also be written into the large memory page 405-1 and eventually read / written into the target hard disk 414 such as an SSD. In this way, the service of the NVMe-oF engine container set 403 can be divided into two or more instances, and the task threads can still be regarded as unique resources. The total number of task threads remains unchanged, and the CPU, memory, and other resources consumed by the storage system / cluster may not be affected, which is crucial for systems with limited resources. Task threads can be deployed to different container sets according to the increase / decrease in load in different container sets in the storage system.

[0050] Figure 5 A schematic diagram of a sidecar container sharing memory 500 with another container according to some embodiments of the present disclosure is illustrated. Since processes running in containers are isolated from each other even in the same container set. According to an embodiment of the present disclosure, a method for sharing memory across containers in the same container set is provided. As an example, a sidecar container 503 from an NVMe-oF engine container set can be deployed into a consumer container set 501 such as a data head service container set. In the context of the present disclosure, as an example, a consumer container can be a container that obtains data from other containers or external services, performs certain operations, or consumes certain resources to support different functions and requirements of an application.

[0051] The sidecar container 503 can then allocate large memory pages from the NVMe-oF engine container set in its process space, so that the allocated large memory pages form one or more memory files, and create a large memory page file table 510-1 based on the allocated memory pages. The large memory page file table 510-1 may include necessary information associated with the memory file, such as the memory file name and size.

[0052] The sidecar container 503 can then transfer / mount the large memory page file table 510-1 to a consumer container 505 in the consumer container set 501 via the UDS transmission protocol and the emptyDir storage volume 507, where the emptyDir storage volume 507 is a temporary directory created by the container, which can conveniently provide shared storage for containers in the container set without the need for additional configuration.

[0053] The consumer container 505 can generate another large memory page file table 510-2 based on the transmitted large memory page file table 510-1, and map the large memory page file table 510-2 to its own consumer process space in a memory file mapping manner, thereby achieving access to the deployed large memory pages in the sidecar container 503. The consumer container 505 can then modify the deployed large memory pages in the sidecar container 503, such as reading and writing.

[0054] The sidecar container 503 can also further identify the memory updates made by the consumer container 505 through the memory file mapping. The method implemented by the present disclosure does not require any additional dependencies, such as new libraries or frameworks, making it a simple and flexible solution that can be easily implemented in other scenarios.

[0055] Figure 6 Graph 600 illustrates some experimental results according to some embodiments of the present disclosure. Figure 6 Used to verify the concept ("Proof of Concept", POC) proposed in the present disclosure. According to an embodiment of the present disclosure, the experiment can be carried out in a test bed with large writes (for example, the object size is 256MB). The configuration of the test bed may include: the CPU is Intel (R) Xeon (R) Gold 6430, the dynamic random access memory (DRAM) is 256GB, DDR5, the operating system is SUSE Linux Enterprise Server 15 (x86_64, version 15, patch level 14), the front-end network interface card (NIC) is BCM5720Gigabit Ethernet PCIe, 50Gb / s, the back-end network interface card is MellanoxMT2892Family [ConnectX-6Dx], 200Gb / s, the SPDK version is v22.01.x, the large memory page size is 2MB, and the load tool is Mongoose-4.3.2.

[0056] Figure 6 The vertical axis represents the throughput of the storage system implemented according to different methods, which can be used to represent the speed or capacity of data that can be processed or transmitted in a computer system or storage system. It is usually used to measure the performance and efficiency of the system. Throughput includes read throughput and write throughput. Read throughput refers to the speed at which the system can read data from a storage device (such as a hard disk, solid-state drive, memory, etc.). Write throughput refers to the speed at which the system can write data to a storage device. The level of read and write throughput directly affects the performance and response time of the system, and is also one of the key indicators for evaluating the performance of storage and computing systems.

[0057] The horizontal axis represents the write and read operations based on the HTTP (Hypertext Transfer Protocol) protocol and the HTTPS (HTTPSsecure) protocol respectively. Figure 6 It can be seen that the throughput of writing via the http protocol according to the basic method is 13.5GB / S, while the throughput of writing via the http protocol according to the method implemented in the present disclosure can reach 20GB / S. The throughput of writing via the https protocol according to the basic method is 13GB / S, while the throughput of writing via the https protocol according to the method implemented in the present disclosure can reach 17GB / S.

[0058] According to the basic method, the throughput of reading via the http protocol is 18GB / S, while according to the method implemented in the present disclosure, the throughput of reading via the http protocol can reach 22GB / S. According to the basic method, the throughput of reading via the https protocol is 18GB / S, while according to the method implemented in the present disclosure, the throughput of reading via the https protocol can reach 22GB / S. These experimental results prove that compared with the performance of the basic method, the optimization of the method implemented in the present disclosure can bring great benefits to the improvement of read and write performance.

[0059] In this way, the present disclosure proposes a general solution based on cross-container set process communication in Kubernetes, which can share memory or other resources. It is achieved by decomposing flexible task threads into sub-instances specifically for consumer containers. The method implemented in accordance with the present disclosure successfully implements shared memory on Kubernetes. The shared memory is implemented using a flexible method and the UDS connection attached to the sidecar container can ensure flexibility and load balancing. The method implemented in accordance with the present disclosure can also provide a reference for storage systems that encounter similar challenges. It should also be understood that although Kubernetes is used as an example container orchestration and management platform in the present disclosure, the method implemented in accordance with the present disclosure can also be applied to any other known or unknown platforms based on other architectures or configurations, such as Docker Swarm, Nomad, Azure KubernetesService, etc., and the present disclosure does not impose any restrictions on this.

[0060] Figure 7 A schematic block diagram of an example device 700 that may be used to implement embodiments of the present disclosure is shown. Figure 1The computing device in the device 700 can be implemented by using the device 700. As shown in the figure, the device 700 includes a central processing unit (CPU) 701, which can perform various appropriate actions and processes according to computer program instructions stored in a read-only memory (ROM) 702 or computer program instructions loaded from a storage unit 708 to a random access memory (RAM) 703. In the RAM 703, various programs and data required for the operation of the storage device 700 can also be included. The CPU 701, the ROM 702, and the RAM 703 are connected to each other via a bus 404. An input / output (I / O) interface 705 is also connected to the bus 704.

[0061] A number of components in the device 700 are connected to the I / O interface 705, including: an input unit 706, such as a keyboard, a mouse, etc.; an output unit 707, such as various types of displays, speakers, etc.; a storage page 708, such as a disk, an optical disk, etc.; and a communication unit 709, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit 709 allows the device 700 to exchange information / data with other devices through a computer network such as the Internet and / or various telecommunication networks.

[0062] The various processes and processing described above, such as method 200, may be performed by processing unit 701. For example, in some embodiments, method 200 may be implemented as a computer software program, which is tangibly contained in a machine-readable medium, such as storage unit 708. In some embodiments, part or all of the computer program may be loaded and / or installed on device 700 via ROM 702 and / or communication unit 709. When the computer program is loaded into RAM 703 and executed by CPU 701, one or more actions of method 200 described above may be performed.

[0063] The present disclosure may be a method, an apparatus, a system and / or a computer program product. The computer program product may include a computer-readable storage medium carrying computer-readable program instructions for executing various aspects of the present disclosure.

[0064] Computer readable storage medium can be a tangible device that can hold and store instructions used by an instruction execution device. Computer readable storage medium can be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the above. More specific examples (non-exhaustive list) of computer readable storage medium include: portable computer disk, hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanical encoding device, such as a punch card or a convex structure in a groove on which instructions are stored, and any suitable combination of the above. The computer readable storage medium used here is not interpreted as a transient signal itself, such as a radio wave or other freely propagating electromagnetic wave, an electromagnetic wave propagated by a waveguide or other transmission medium (e.g., a light pulse by an optical fiber cable), or an electrical signal transmitted by a wire.

[0065] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device, or downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network can include copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in the computer-readable storage medium in each computing / processing device.

[0066] The computer program instructions for performing the operation of the present disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages, such as Smalltalk, C++, etc., and conventional procedural programming languages, such as "C" language or similar programming languages. Computer-readable program instructions may be executed entirely on a user's computer, partially on a user's computer, as an independent software package, partially on a user's computer, partially on a remote computer, or completely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., using an Internet service provider to connect via the Internet). In some embodiments, an electronic circuit, such as a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may be customized by utilizing the state information of the computer-readable program instructions, and the electronic circuit may execute the computer-readable program instructions, thereby realizing various aspects of the present disclosure.

[0067] Various aspects of the present disclosure are described herein with reference to the flowcharts and / or block diagrams of the methods, devices (systems) and computer program products according to the embodiments of the present disclosure. It should be understood that each box in the flowchart and / or block diagram and the combination of each box in the flowchart and / or block diagram can be implemented by computer-readable program instructions.

[0068] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing device, thereby producing a machine, so that when these instructions are executed by the processing unit of the computer or other programmable data processing device, a device that implements the functions / actions specified in one or more boxes in the flowchart and / or block diagram is generated. These computer-readable program instructions can also be stored in a computer-readable storage medium, and these instructions cause the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable medium storing the instructions includes a manufactured product, which includes instructions for implementing various aspects of the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0069] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device so that a series of operating steps are performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions executed on the computer, other programmable data processing apparatus, or other device to implement the functions / actions specified in one or more boxes in the flowchart and / or block diagram.

[0070] The flow chart and block diagram in the accompanying drawings show the possible architecture, function and operation of the system, method and computer program product according to multiple embodiments of the present disclosure. In this regard, each square box in the flow chart or block diagram can represent a part of a module, program segment or instruction, and a part of a module, program segment or instruction includes one or more executable instructions for realizing the specified logical function. In some alternative implementations, the function marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two continuous square boxes can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs the specified function or action, or can be implemented with a combination of special hardware and computer instructions.

[0071] The embodiments of the present disclosure have been described above, and the above description is exemplary, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The choice of terms used herein is intended to best explain the principles of the embodiments, practical applications, or technical improvements to the technology in the market, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.

Claims

1. A method for storage, the method comprising: receiving data via a first container in a first container set; transmitting the data from the first container to a second container in the first container set via a transmission protocol, wherein the second container is used to assist in implementing a function of the first container set and includes a large memory page; and The data is written to the disk via the second container.

2. The method according to claim 1, wherein the second container is in a second container set, and wherein the second container set is connected to the first container set via the transmission protocol and provides services required for the first container set, further comprising: In response to a load change in the first container set, deploying one or more large memory pages of the large memory pages of the second container set into the second container; as well as Deploy the second container into the first container set.

3. The method according to claim 2, deploying the one or more large memory pages in the large memory pages of the second container set into the second container comprises: Generating an IO worker thread by binding the large memory page to a core in a central processing unit; as well as Deploy the IO worker thread into the second container.

4. The method of claim 1 , wherein writing the data to the disk via the second container comprises: A large memory page file table is generated by the second container based on the large memory page deployed in the second container, wherein the large memory page file table includes the large memory page file and size.

5. The method according to claim 1, further comprising: Transmitting the large memory page file table to the first container via a transmission protocol; as well as The first container maps the large memory page file table to the process space of the first container through memory file mapping.

6. The method according to claim 5, further comprising: The first container writes the data into the huge memory page of the second container by modifying the huge memory page file table in the process space; as well as The data is written to the disk via the huge memory page.

7. The method according to claim 3, further comprising: The IO worker threads are allocated according to the number of interfaces of the transport protocol connected to the second container set, so that each interface of the transport protocol has the same number of the IO worker threads.

8. The method according to claim 1, further comprising: In response to a reduction in load in the first set of containers, the second container is removed from the first set of containers.

9. The method of claim 3, wherein the IO worker thread is a non-blocking IO thread, and the IO worker thread is polled to confirm the availability of the IO worker thread to be deployed to the second container.

10. An electronic device comprising: processor; as well as A memory is coupled to the processor and stores instructions that, when executed by the processor, cause the device to perform the following actions: receiving data through a first container in a first container set of the electronic device; transmitting the data from the first container to a second container in the first container set via a transmission protocol, wherein the second container is used to assist in implementing a function of the first container set and includes a large memory page; and The data is written to the disk via the second container.

11. The electronic device according to claim 10, wherein the second container is in a second container set, and wherein the second container set is connected to the first container set via the transmission protocol and provides services required by the first container set, further comprising: In response to a load change in the first container set, deploying one or more large memory pages of the large memory pages of the second container set into the second container; as well as Deploy the second container into the first container set.

12. The electronic device according to claim 11, deploying the one or more large memory pages of the large memory pages of the second container set into the second container comprises: Generating an IO worker thread by binding the large memory page to a core in a central processing unit; as well as Deploy the IO worker thread into the second container.

13. The electronic device of claim 10, wherein writing the data to the disk via the second container comprises: A large memory page file table is generated by the second container based on the large memory page deployed in the second container, wherein the large memory page file table includes the large memory page file and size.

14. The electronic device according to claim 10, further comprising: Transmitting the large memory page file table to the first container via a transmission protocol; as well as The first container maps the large memory page file table to the process space of the first container through memory file mapping.

15. The electronic device according to claim 14, further comprising: The first container writes the data into the huge memory page of the second container by modifying the huge memory page file table in the process space; as well as The data is written to the disk via the huge memory page.

16. The electronic device according to claim 12, further comprising: The IO worker threads are allocated according to the number of interfaces of the transport protocol connected to the second container set, so that each interface of the transport protocol has the same number of the IO worker threads.

17. The electronic device according to claim 10, further comprising: In response to a reduction in load in the first set of containers, the second container is removed from the first set of containers. 18 . The electronic device of claim 12 , wherein the IO worker thread is a non-blocking IO worker thread, and the IO worker thread is polled to confirm availability of the IO worker thread to be deployed to the second container.

19. A computer program product tangibly stored on a non-transitory computer readable storage medium and comprising computer executable instructions that, when executed, cause a computer to: receiving data via a first container in a first container set; transmitting the data from the first container to a second container in the first container set via a transmission protocol, wherein the second container is used to assist in implementing a function of the first container set and includes a large memory page; and The data is written to the disk via the second container.

20. The computer program product according to claim 19, wherein the second container is in a second container set, and wherein the second container set is connected to the first container set via the transmission protocol and provides services required for the first container set, further comprising: In response to a load change in the first container set, deploying one or more large memory pages of the large memory pages of the second container set into the second container; as well as Deploy the second container into the first container set.

Images