A method and system for improving distributed storage performance in container scenarios
By customizing the file system finite automatic state machine algorithm model of distributed storage systems in container scenarios, adding worker thread pool and monitoring mechanism, the performance bottleneck problem of distributed storage systems in container scenarios is solved, and the writing speed and stability are improved reduces hardware dependency and optimizes IO throughput.
Patent Information
- Application Number
- CN202210730898.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2022-06-24
- Publication Date
- 2024-11-08
- Estimated Expiration
- 2042-06-24
AI Technical Summary
In container scenarios, existing distributed storage systems cannot effectively use partitions created by bcache kernel module for cache, and the hot cache mechanism has performance losses. The asynchronous IO read and write model causes queue accumulation under low-speed devices, affecting read and write performance, especially In scenarios with intensive write operations, multi-dimensional data reading and writing operations in delayed write scenarios increase system load, resulting in small file write performance bottlenecks.
Through the customized file system finite automatic state machine algorithm model of distributed storage systems, the worker thread pool is added to process IO write requests, control the frequency of asynchronous IO data dropping, optimize the number of data dropping times in delayed write scenarios, and separate IO requests and submit thread pools, monitor and batch process queue stacking transactions, and reduce the number of IO drops.
Improve the write speed and stability of distributed storage systems in the container cloud platform, reduce dependence on expensive hardware, enhance system concurrency and IO throughput, optimize write operation performance, reduce system load, and improve overall performance and usability.
Smart Images

Figure CN114995768B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the technical field of distributed storage and performance optimization, and in particular to a method and system for improving distributed storage performance in a container scenario. Background Art
[0002] In the existing container cloud distributed storage performance optimization and related technical solutions, the high-speed read and write characteristics of hardware such as nvme and ssd are mainly used to make a layer of hot cache for the storage of the container cloud, hot cache high-hit data, and the back-end shields the process of migrating low-hit data in the hot cache to low-speed devices (hdd). For users, data migration is transparent. In the user's perception, the distributed storage system that uses high-speed devices such as nvme and ssd as hot cache will be much faster than the distributed storage system that simply uses low-speed hdd devices. A customized file system is used to directly bypass the default file system of the operating system and directly manage the raw device of the disk, thereby avoiding the write amplification problem caused by double log writing to the distributed storage system (system log writing is a very frequent operation, and double write operations will increase the system load and affect system performance), thereby reducing the number of system log writes and improving distributed storage performance.
[0003] Existing known distributed storage in container scenarios mainly improves system performance through hot caching and customized file systems, but has the following main problems:
[0004] 1. In the container scenario, the storage nodes of the distributed storage system cannot recognize the partitions of the hard disk created by the bcache kernel module, so the partitions created by the bcache kernel module cannot be used as cache to improve performance.
[0005] 2. The hot cache mechanism of the existing distributed storage system has certain performance loss in the container scenario. For IO-intensive business scenarios with high requirements for read and write performance, such as database reading and writing, and virtual machine hard disks, it is difficult to meet business needs without using expensive hardware configurations such as all-flash.
[0006] 3. The existing distributed storage system adopts an asynchronous IO read and write operation model. The data write queue and disk operation are completed by different threads and queues. In scenarios where IO business is busy and low-speed devices are deployed, especially in scenarios with intensive write operations, it is easy to cause queue accumulation, affecting the read and write performance of the distributed storage system.
[0007] 4. In the scenario of delayed writing (overwriting RMW), the existing distributed storage system will first perform a log modification operation, that is, write metadata first, and then write data. Compared with new writing (no log modification), there will be one more metadata read and metadata modification operation. During the metadata writing and data writing process, data submission and data disk write operations will be performed. Due to the use of an asynchronous IO read and write model, in scenarios with intensive IO operations, especially intensive write operations, it is easy to cause accumulation of submission queues and disk write queues, thereby affecting the system write performance, especially the small file write performance.
[0008] 5. In the container cloud scenario, the write performance of distributed storage, especially small file writing, often becomes the bottleneck of the entire platform. In order to improve the performance and stability of the distributed storage system, it is necessary to transform the existing distributed storage file management system, modify the file management system finite state machine model, increase the worker thread pool, control the frequency of asynchronous IO data falling to disk, and control the number of data falling to disk in delayed write scenarios, so as to achieve a balance between the construction cost and performance improvement of the container cloud storage platform. Summary of the invention
[0009] The purpose of the present invention is to provide a method and system for improving distributed storage performance in a container scenario, which adopts a method of customizing a distributed storage system replica node to optimize the file system finite state machine algorithm model of the replica storage node.
[0010] In order to solve the above technical problems, the present invention provides a method for improving distributed storage performance in a container scenario, comprising the following steps:
[0011] Step 1: The storage node receives an IO write request and determines whether the IO write request reaches the system current limiting bottleneck;
[0012] If the IO write request does not reach the current limiting bottleneck, go to step 2;
[0013] If the IO write request reaches the current limiting bottleneck, go to step 3;
[0014] Step 2: The thread in the first worker thread pool processes the IO write request, encapsulates the IO write request into a transaction and sends it to the file system state machine through the thread in the first thread pool, and uses the thread in the first worker thread pool as the submit thread to execute step 4;
[0015] Step 3: The thread in the first worker thread pool processes the IO write request, encapsulates the IO write request into a transaction and sends it to the file system state machine through the thread in the first thread pool, wakes up the thread in the second worker thread pool through the semaphore, and uses the thread in the second worker thread pool as the submit thread; execute step 4;
[0016] Step 4: The commit thread inserts the transaction in the file system state machine into the first IO commit queue, and determines whether the first IO commit queue is backlogged;
[0017] If the queue is not accumulated, the transaction is written to the disk individually;
[0018] If the queue accumulates, transactions are flushed to disk in batches.
[0019] Preferably, determining whether the first IO submission queue is backlogged specifically includes the following steps:
[0020] The first IO submission queue is monitored, and transactions in the first IO submission queue are counted as queue length to determine whether the queue length exceeds a threshold. If the queue length exceeds the threshold, the queue is accumulated; otherwise, the queue is not accumulated.
[0021] Preferably, transactions are processed individually, which specifically includes the following steps:
[0022] The first disk placement thread is awakened by the semaphore, and the first disk placement thread migrates the transactions in the first IO submission queue to the second IO disk placement queue, and the first disk placement thread separately places the transactions in the second IO disk placement queue.
[0023] Preferably, the transaction is stored in batches, specifically including the following steps:
[0024] The second disk placement thread is awakened by the semaphore, and the second disk placement thread migrates the transactions in the first IO submission queue to the third IO batch disk placement queue for batch placement.
[0025] Preferably, the individual placement and batch placement specifically include the following steps:
[0026] The disk write thread processes transactions according to their IO write types; determines the IO write type of transactions; there are two types of IO writes, namely new writes and delayed writes;
[0027] If the IO write type is new write, the disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk and stores it in the new storage unit;
[0028] If the IO write type is delayed write, the disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk, reusing the old storage unit.
[0029] Preferably, the specific determination method for determining the IO write type of a transaction is:
[0030] The IO write type of the transaction is determined based on the transaction size and the storage unit of the raw device of the disk; if the transaction size is an integral multiple of the storage unit of the raw device of the disk, the IO write type of the transaction is new write; otherwise, the IO write type of the transaction is delayed write.
[0031] Preferably, the process of placing the dish comprises the following steps:
[0032] The storage node is an osd replica storage node.
[0033] The present invention also provides a system for implementing the above-mentioned method for improving distributed storage performance in a container scenario, comprising:
[0034] Customized file system module, used to manage raw disk devices, allocate space, reclaim space, store data, view, delete, and modify data;
[0035] The data encapsulation and transmission module is used to encapsulate the IO write request into a transaction and send it to the file system state machine;
[0036] Metadata cache module, used to save and change metadata information;
[0037] Object Gateway, used to parse access requests;
[0038] Node monitoring module, used to monitor the status of storage nodes;
[0039] Notification delivery module, used to keep the status of cluster nodes consistent.
[0040] Compared with the prior art, the present invention has the following beneficial effects:
[0041] 1. The present invention deeply customizes the file system of the distributed system storage node, improves the algorithm model of the file system finite automatic state machine, enhances the concurrency and IO throughput of the distributed storage system storage node, and improves the write speed of the distributed system in the container cloud platform environment;
[0042] 2. The present invention makes up for the deficiency that bcache technology cannot be used in container scenarios, reduces the dependence of distributed storage systems on expensive hardware nvme hard disks and RDMA network cards, reduces the dependence on operating system kernels, and is more versatile;
[0043] 3. The present invention mainly optimizes the distributed storage customized file system in the container cloud deployment scenario, modifies the finite state machine model of the file system, increases the worker thread pool for file system data to be dropped to disk, controls the frequency of data drop to disk, and controls the number of times the customized file system delays writing to disk, thereby optimizing the write operation of distributed storage in the container scenario, improving the write performance of the distributed operating system, and ensuring the stability and availability of distributed storage in the container scenario. BRIEF DESCRIPTION OF THE DRAWINGS
[0044] The specific implementation modes of the present invention are further described in detail below with reference to the accompanying drawings.
[0045] Figure 1 It is a flow chart of a method for improving distributed storage performance in a container scenario of the present invention;
[0046] Figure 2 It is a schematic diagram of the platform architecture of a method for improving distributed storage performance in a container scenario of the present invention;
[0047] Figure 3 It is a functional architecture diagram of a system for improving distributed storage performance in a container scenario according to the present invention;
[0048] Figure 4 It is a schematic diagram of the deployment architecture of a system for improving distributed storage performance in a container scenario according to the present invention. DETAILED DESCRIPTION
[0049] Many specific details are set forth in the following description to facilitate a full understanding of the present invention. However, the present invention can be implemented in many other ways than those described herein, and those skilled in the art can make similar generalizations without violating the connotation of the present invention, so the present invention is not limited to the specific implementation disclosed below.
[0050] The terms used in one or more embodiments of this specification are only for the purpose of describing specific embodiments, and are not intended to limit one or more embodiments of this specification. The singular forms of "a", "said" and "the" used in one or more embodiments of this specification and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and / or" used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.
[0051] It should be understood that although the terms first, second, etc. may be used to describe various information in one or more embodiments of this specification, this information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of one or more embodiments of this specification, the first may also be referred to as the second, and similarly, the second may also be referred to as the first. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".
[0052] The present invention proposes a method for improving distributed storage performance in a container scenario, which specifically includes the following steps:
[0053] (1) The storage node receives an IO write request and determines whether the IO write request reaches the system current limiting bottleneck;
[0054] If the IO write request does not reach the current limiting bottleneck, go to step 2;
[0055] If the IO write request reaches the current limiting bottleneck, go to step 3;
[0056] In this embodiment: if an IO request carries 5T of data in 3 seconds, the system flow limit bottleneck is to accommodate 1GB of data flow in 1 second. 5T of data in 3 seconds exceeds 3GB of flow, reaching the system flow limit bottleneck.
[0057] (2) The IO write request does not reach the current limiting bottleneck, and the thread in the first worker thread pool processes the IO write request. The thread in the first thread pool encapsulates the IO write request into one or more transactions and enters the file system state machine, and uses the thread in the first worker thread pool as the submission thread to execute step 4;
[0058] In this embodiment, the IO write request is encapsulated into one or more transactions, specifically including the following steps: if the data size of the IO write request is less than or equal to 4M, it only needs to be encapsulated as a data block into one transaction; if the data size of the IO write request is greater than 4M, the IO write request needs to be divided into several 4M data blocks as several transactions;
[0059] The storage node is an osd replica storage node;
[0060] (3) The IO write request reaches the current limiting bottleneck, a second worker thread pool is added, and the threads in the first worker thread pool process the IO write request. The threads in the first thread pool encapsulate the IO write request into one or more transactions and enter the file system state machine. The threads in the second worker thread pool are awakened by the semaphore, and the threads in the second worker thread pool are used as the submission threads; execute step 4;
[0061] In this step, the threads that process IO requests and the threads that process IO submissions are separated to increase the concurrent processing capability of the file system state machine, and the worker thread pool performs load sharing according to a simple polling algorithm;
[0062] The IO request processing thread and the IO queue submission thread are separated, that is, the worker thread that originally processed IO requests only handles IO request segmentation, encapsulation, and response. When the system reaches the current limiting bottleneck, it no longer processes the work submitted by the IO queue. The IO queue submission work is handled by a dedicated new worker thread pool (the second worker thread pool).
[0063] (4) The submission thread (a thread in the first worker thread pool or a thread in the second worker thread pool) inserts the transaction in the file system state machine into the first IO submission queue, and determines whether the first IO submission queue is backlogged;
[0064] The specific queue accumulation judgment method is as follows: monitoring the first IO submission queue, counting the transactions in the first IO submission queue as the queue length, and judging whether the queue length exceeds a threshold;
[0065] If the queue length does not exceed the threshold, go to step 5;
[0066] If the queue length exceeds the threshold, go to step 6;
[0067] (5) The first disk flushing thread is awakened by a semaphore, and the first disk flushing thread migrates the transactions in the first IO submission queue to the second IO disk flushing queue, and the first disk flushing thread flushes the transactions in the second IO disk flushing queue separately;
[0068] The disk write thread processes transactions according to their IO write types; determines the IO write type of transactions; IO write types are divided into two types, namely new write (simple write) and delayed write (overwrite write);
[0069] If the IO write type is new write, the first disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk and stores them in the new storage unit;
[0070] If the IO write type is delayed write, the first disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk; the metadata corresponding to the transaction is modified and stored in the storage unit that has stored the metadata; the data is stored in the reused storage unit;
[0071] (6) Add an IO queue accumulation state to the file system state machine; when the first IO submission queue is accumulated, add a second disk placement thread and a third IO batch disk placement queue. The second disk placement thread migrates transactions in the first IO submission queue to the third IO batch disk placement queue for batch placement. Batch placement can reduce the number of IO placements and speed up IO processing;
[0072] If the IO write type is new write, the second disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk and stores them in the new storage unit.
[0073] If the IO write type is delayed write, the second disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk; the metadata corresponding to the transaction is modified and stored in the storage unit that has stored the metadata; the data is stored in the reused storage unit;
[0074] The first disk placement thread and the second disk placement thread are used for single disk placement and batch disk placement respectively.
[0075] In step 5 and step 6, the specific method for determining the IO write type of the transaction is:
[0076] The IO write type of the transaction is determined based on the transaction size and the storage unit of the raw device of the disk; if the transaction size is an integral multiple of the storage unit of the raw device of the disk, the IO write type of the transaction is new write; otherwise, the IO write type of the transaction is delayed write;
[0077] In a specific embodiment of the present invention:
[0078] The smallest storage unit size of the raw device of the disk is 4K (the actual situation is more complicated, hdd is 512 bytes, nvme is 4K, and 4K is unified here). The IO write request is divided into 4M data blocks, which correspond to a memory area. The file system manages this memory area and divides it into a data linked list of 4K in size.
[0079] If the transaction file size is 8K, the file system state machine only needs to allocate 2 new storage units from the data linked list, and then map these 2 memory units to 2 storage units of the raw device of the disk, which is a new write;
[0080] If the transaction file size is 1K, the file system state machine will search the free space list to see if there is any memory unit that can be reused (corresponding to the storage unit that has already stored some data);
[0081] For example, if there is a memory unit that uses 2K, the file system state machine will mark this memory unit with the number 10001, offset 899, and size 2K. This 10001 memory unit is allocated to the 1K file. The file system state machine calculates whether there is any overlapping data between the 1K file and the 10001 memory unit based on the offset and size. After merging, the part that does not meet 4K is filled with 0, and then corresponds to the storage unit of the raw device of the disk. This is delayed writing (overwrite writing).
[0082] Overwriting and merging old data: a 1K file, the free list allocates a memory unit with 2K of memory space for this transaction. If this memory unit has 0.5K of duplicate content with the file, the used content space becomes 2.5K. This is overwriting and merging old data.
[0083] In an embodiment of the present invention, metadata includes a space free list freelist, a memory data area onode, and a write-ahead log WAL, etc.; modifying metadata means that the space free list freelist allocates a number of memory units to the file from the area included in the memory data area onode, the space free list freelist itself changes, and the content, size, offset, and production time of the data area included in the memory data area onode are all changed. The write-ahead log WAL is a log that records these changes, so it also changes. These changes are to modify the metadata.
[0084] The present invention improves the distributed storage read and write performance by optimizing the finite state machine algorithm of the distributed storage file system, increasing the file system worker thread pool, controlling the frequency of asynchronous IO data falling to disk, and controlling the number of data falling to disk in a delayed write scenario.
[0085] In the file management layer of the distributed storage system, a finite state machine algorithm state is added. When the IO operation reaches the system current limiting bottleneck value, the IO submission operation is separated from the worker thread pool that processes the IO request message of the storage node of the distributed storage, and a dedicated IO submission worker thread pool is added to share the IO submission operation.
[0086] Add a monitoring mechanism for asynchronous IO queues. When it is found that IO operations are accumulated in the system's first IO submission queue, migrate the accumulated queue IO transactions to the batch disk placement queue, add a dedicated IO disk placement worker thread, and complete the IO disk placement operations in batches.
[0087] In the delayed write scenario of the distributed storage system, when the system reaches the flow limiting bottleneck or detects that there is IO operation accumulation in the first IO submission queue, the IO disk write operations of metadata write and data write operations are migrated from the heavy and time-consuming IO path to the worker thread with lighter load, and the delayed write IO disk is completed in batches, reducing the number of IO disk write operations and reducing the overall system load, thereby improving the system performance of the distributed storage system in the container scenario, and reducing the dependence on specific kernel modules such as the bcache kernel module technology, and reducing the dependence on expensive high-speed hardware devices such as nvme hard disks and RDMA standard network cards.
[0088] The present invention customizes the file system in the storage node of the distributed storage system, directly manages the raw device of the disk, modifies the file system finite automatic state machine algorithm, adds the system current limiting state, the first IO submission queue monitoring mechanism, and controls the IO drop frequency and the number of delayed write IO drops, thereby improving the write performance of distributed storage in a container environment.
[0089] The present invention increases the worker thread pool, shares the system load of IO writing of storage nodes in busy business scenarios, improves the read and write model of asynchronous IO of the file system, and enhances the IO writing throughput of the distributed storage system;
[0090] From the actual production and stress test results, the IO write operation of the distributed storage system often becomes the bottleneck of the cloud platform. The present invention deeply customizes the file system of the storage node to improve the performance and stability of the entire platform.
[0091] The present invention also provides a method for improving distributed storage performance in a container scenario, including:
[0092] Customized file system module, used to implement management, space allocation, space recovery, data storage, viewing, deletion, and modification of raw disk devices; the disk is a distributed storage system hard disk; that is, it is used for transactions to be written to disk individually or in batches;
[0093] Replica object storage module, used for data replica data redundancy, fault isolation, data recovery and synchronization;
[0094] A data encapsulation and transmission module is used to encapsulate data blocks into transactions and send them to the file system state machine for processing;
[0095] Metadata cache module, used to save and change metadata information;
[0096] Object Gateway, used to parse access requests;
[0097] The node monitoring module is used to monitor the status of the storage node; to monitor the status of the storage node; to determine whether the IO write request has reached the system current limiting bottleneck; and to determine whether the first IO submission queue is queued.
[0098] Notification delivery module, used to keep the status of cluster nodes consistent.
[0099] The core nodes of the distributed storage system are mon monitoring nodes and osd replica storage nodes. A set of mon monitoring nodes is deployed to monitor the osd replica storage nodes, mainly completing functions such as distributed consensus system, customer request authentication, and storage node map monitoring.
[0100] Deploy osd replica storage nodes, mainly to complete the customized file system to perform raw device management of disks, home group management, replica data control, data synchronization, replica node heartbeat detection and other functions.
[0101] In the several embodiments provided by the present invention, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic, for example, the division of the modules, modules or units is only a logical function division, and there may be other division methods in actual implementation, for example, multiple units, modules or components can be combined or integrated into another device, or some features can be ignored or not executed.
[0102] The units may or may not be physically separated, and the components displayed as units may be one physical unit or multiple physical units, that is, they may be located in one place or distributed in multiple different places. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.
[0103] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.
[0104] In particular, according to the embodiments disclosed in the present invention, the process described above with reference to the flowchart can be implemented as a computer software program. For example, the embodiments disclosed in the present invention include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from the network through the communication part, and / or installed from a removable medium. When the computer program is executed by the central processing unit (CPU), the above-mentioned functions defined in the method of the present invention are executed. It should be noted that the above-mentioned computer-readable medium of the present invention can be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, a system, device or device of an electrical, magnetic, optical, electromagnetic, infrared segment, or semiconductor, or any combination of the above.
[0105] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present invention. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession 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 operation, or can be implemented with a combination of dedicated hardware and computer instructions.
[0106] The above is only a specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any changes or substitutions within the technical scope disclosed by the present invention should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention should be based on the protection scope of the claims.
Claims
1. A method for improving distributed storage performance in a container scenario, characterized in that: The following steps are involved: The storage node receives the IO write request and determines whether the IO write request reaches the system current limiting bottleneck; If the IO write request does not reach the current limiting bottleneck, the thread in the first worker thread pool processes the IO write request, encapsulates the IO write request into a transaction through the thread in the first thread pool and sends it to the file system state machine, and uses the thread in the first worker thread pool as the submission thread; If the IO write request reaches the current limiting bottleneck, the thread in the first worker thread pool processes the IO write request, encapsulates the IO write request into a transaction and sends it to the file system state machine through the thread in the first thread pool, wakes up the thread in the second worker thread pool through the semaphore, and uses the thread in the second worker thread pool as the submission thread; The commit thread inserts the transaction in the file system state machine into the first IO commit queue, and determines whether the first IO commit queue is queued; If the queue is not accumulated, the transaction is written to the disk individually; If the queue is accumulated, transactions are flushed to disk in batches; Transactions are written to disk individually, which includes the following steps: The first disk placement thread is awakened by a semaphore, and the first disk placement thread migrates transactions in the first IO submission queue to the second IO disk placement queue, and the first disk placement thread separately places transactions in the second IO disk placement queue; The transaction is batched and stored on disk, which includes the following steps: The second disk placement thread is awakened by the semaphore, and the second disk placement thread migrates the transactions in the first IO submission queue to the third IO batch disk placement queue for batch placement.
2. According to claim 1, a method for improving distributed storage performance in a container scenario is characterized in that: Determining whether the first IO submission queue is backlogged specifically includes the following steps: The transactions in the first IO submission queue are counted as the queue length, and whether the queue length exceeds a threshold is determined; if the queue length exceeds the threshold, the queue is accumulated; otherwise, the queue is not accumulated.
3. According to claim 1, a method for improving distributed storage performance in a container scenario is characterized in that: The specific steps of single and batch placement include: The disk write thread processes transactions according to their IO write types; determines the IO write type of transactions; there are two types of IO writes, namely new writes and delayed writes; If the IO write type is new write, the disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk and stores it in the new storage unit; If the IO write type is delayed write, the disk write thread sends the metadata and data corresponding to the transaction in the file system state machine to the raw device of the disk, reusing the old storage unit.
4. According to claim 3, a method for improving distributed storage performance in a container scenario is characterized in that: The specific method for determining the IO write type of a transaction is: The IO write type of the transaction is determined based on the transaction size and the storage unit of the raw device of the disk; if the transaction size is an integral multiple of the storage unit of the raw device of the disk, the IO write type of the transaction is new write; otherwise, the IO write type of the transaction is delayed write.
5. According to claim 1, a method for improving distributed storage performance in a container scenario is characterized in that: The storage node is an osd replica storage node.
6. A system for implementing the method for improving distributed storage performance in a container scenario as described in any one of claims 1 to 5, characterized in that: include: Customized file system module, used for storing transactions individually or in batches; The data encapsulation and transmission module is used to encapsulate the IO write request into a transaction and send it to the file system state machine; Object Gateway, used to parse access requests; Node monitoring module, used to monitor the status of storage nodes; Used to determine whether the IO write request has reached the system current limiting bottleneck; used to determine whether the first IO submission queue is queued.
