A distributed file system handle pool

Abstract

The application relates to a distributed file system handle pool, comprising a handle cache, an operation handle interface provided by the handle pool and a background thread: the handle cache is used for realizing multi-level indexing and caching handles; the operation handle interface is used for receiving user operations to operate the handles in the handle cache; and the background thread is used for dynamically adjusting the handle state and the handle quantity in the handle cache. The application uses a Map container to realize a hierarchical handle pool, uses the Key and the Value of the handle pool to index directories, buckets and files of a data storage system respectively, constructs multi-level indexes, meets the demand of a user for establishing a mapping relationship between upper-layer directories and lower-layer data storage system directories and buckets according to business rules, dynamically adjusts the handle state and the handle quantity in the handle pool, timely eliminates idle handles, plays a flow limiting role, improves handle reuse efficiency and relieves the pressure of the lower-layer data storage system.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of distributed file system, in particular to a distributed file system handle pool. BACKGROUND

[0002] With the advent of the information age, global data is showing explosive growth. Among them, massive unstructured data is stored in a distributed file system in a file format. A file is composed of file metadata and file data, and a multi-level storage distributed file system of file metadata and file data is a commonly used massive file storage solution. In a multi-level storage distributed file system of metadata and data, commonly used data storage systems include file storage systems (such as HDFS) and object storage systems (such as Ceph). The file data in the file system generally occupies more storage space than the file metadata, so the file data read and write performance determines the throughput of the entire file system. A handle is a special storage resource abstraction. When an application program wants to reference a basic storage unit file or object of other systems (such as a file storage system or an object storage system), a handle is used. A multi-level storage distributed file system uses the underlying data storage system to read and write handles to complete the upper layer file data read and write, so the efficiency of using the underlying data storage system to read and write handles has a great influence on system performance. Existing multi-level storage distributed file systems reuse data storage system handles by building a handle pool to ensure file read and write performance. However, the common handle pool does not distinguish the levels of the handles in the pool, which prevents users from establishing a mapping relationship between the upper layer directories and the underlying data storage system directories and buckets according to business rules; it does not have automatic adjustment capability, which results in low handle reuse efficiency, affects file read and write performance, and further affects user experience. SUMMARY

[0003] Based on the above problems, the present application provides a distributed file system handle pool.

[0004] A distributed file system handle pool includes a handle cache, an operation handle interface provided by a handle pool, and a background thread:

[0005] The handle cache is used to implement multi-level indexing and cache handles;

[0006] The operation handle interface is used to receive user operations on the handles in the handle cache;

[0007] The background thread is used to dynamically adjust the handle state and the number of handles in the handle cache.

[0008] The operation handle interface includes at least a get handle interface, a return handle interface, a close handle interface, and a create handle interface;

[0009] The background threads at least include: a handle creation thread, a handle closing thread, a handle replacement thread, and a handle pool health check thread.

[0010] It should be understood that the distributed file system handle pool provided by the application uses a multi-level index to meet the requirement of storing file data of an upper directory into a specified directory or bucket of a data storage system, and a user uses an interface provided by the handle pool to operate a handle, and then completes interaction with the data storage system through the handle; the handle state and the number of handles in the handle pool are dynamically adjusted, the data storage system handles are efficiently reused, the pressure on the underlying storage system is reduced, and the read and write performance of the distributed file system is ensured.

[0011] Further, in the distributed file system handle pool, the handle cache is used to implement a multi-level index and a cached handle, and includes:

[0012] The handle cache is implemented by a thread-safe Map container, the Key index of the handle cache stores a directory or a bucket of a data storage system, and the Value of the handle cache indexes a file or an object of the data storage system.

[0013] The Value of the handle pool represents a handle set in a directory or a bucket of the data storage system specified by the Key, and the Value of the handle cache is implemented by a thread-safe set.

[0014] It should be understood that the distributed file system handle pool provided by the application adopts a thread-safe Map container to implement a hierarchical handle pool, wherein the Key of the handle pool is used to index a directory or a bucket of a data storage system, so that a user can establish a corresponding relationship between an upper directory and a directory or a bucket of the data storage system according to business rules through the Key of the handle pool, thereby facilitating business use; the Value of the handle pool represents a handle set in a directory or a bucket of the data storage system specified by the Key, and is implemented by a thread-safe set, and the elements in the set are handles of the data storage system, which index files and objects of the data storage system.

[0015] Further, in the distributed file system handle pool, a handle obtaining interface is used to obtain a handle from the handle cache.

[0016] A handle returning interface is used to return a handle to the handle cache.

[0017] A handle closing interface is used to scan and close handles in the handle cache.

[0018] A handle creating interface is used to create a handle and add the handle to the handle cache.

[0019] It should be understood that the above is an interface involved in the distributed file system handle pool provided by the application and the role of the interface.

[0020] Further, the above-mentioned one kind of distributed file system handle pool, create handle thread is used for asynchronously executing create handle task;

[0021] Close handle thread is used for asynchronously executing close handle task;

[0022] Check handle state thread is used for asynchronously executing check handle state task;

[0023] Replace handle state thread is used for asynchronously executing replace handle state task;

[0024] Handle pool health check thread is used for asynchronously executing health check task.

[0025] It should be understood that the above is the kind and role of the background thread involved in the handle pool of the distributed file system provided by the present application.

[0026] Further, the above-mentioned one kind of distributed file system handle pool, the background thread is used for dynamically adjusting the number of handles in the handle cache, comprising:

[0027] When the number of available handles in the handle cache is less than the number of user requests, trigger create handle task;

[0028] The create handle thread of the handle pool creates handles using the create handle interface provided by the handle pool;

[0029] Trigger the user request of create handle task, wait and get available handle.

[0030] It should be understood that the above is one of the methods for dynamically adjusting the number of handles in the handle cache by the background thread in the handle pool of the distributed file system provided by the present application: when the number of available handles is less than the number of user requests, create handle task will be triggered;The create handle thread of the handle pool creates the handle of the underlying data storage system using the create handle interface, and adds the directory of the underlying data storage system, the bucket index, and the handle index of the underlying data storage system to the handle cache;When the number of created handles is equal to the number of user requests, get handle from the handle cache using the get handle interface provided by the handle pool.

[0031] Further, the above-mentioned one kind of distributed file system handle pool, the background thread is used for dynamically adjusting the number of handles in the handle cache, further comprising:

[0032] When the number of available handles in the handle cache is greater than the number of user requests, get handle from the handle cache using the get handle interface provided by the handle pool.

[0033] It should be understood that the above is one of the ways provided by the present application to dynamically adjust the number of handles in the handle cache in the distributed file system handle pool through a background thread: when the number of available handles cached in the handle cache corresponding to the Key is greater than the number of user requests, the handle is directly obtained from the handle cache, and the obtained handle is encapsulated as a file input stream and an output stream and returned to the client.

[0034] Further, in the above-mentioned distributed file system handle pool, the background thread is used to dynamically adjust the number of handles in the handle cache, including:

[0035] When the time for which the handle is cached in the handle cache reaches a preset time, a handle closing task is triggered;

[0036] The handle closing thread uses the handle closing interface provided by the handle pool to scan and close the handles in the handle cache.

[0037] It should be understood that the above is one of the ways provided by the present application to dynamically adjust the number of handles in the handle cache in the distributed file system handle pool through a background thread: when the time for which the handle is cached in the handle cache reaches a preset time, a handle closing task is triggered, and the handle closing thread uses the handle closing interface provided by the handle pool to scan and close the handles in the handle cache, thereby achieving the purpose of clearing the expired handles in the handle cache.

[0038] Further, in the above-mentioned distributed file system handle pool, the background thread is used to dynamically adjust the number of handles in the handle cache, including:

[0039] The handle pool periodically triggers a health check task;

[0040] The handle pool health check thread maintains a preset number of handles.

[0041] It should be understood that the above is one of the ways provided by the present application to dynamically adjust the number of handles in the handle cache in the distributed file system handle pool through a background thread: the handle pool periodically triggers a health check task, and the handle pool health check thread maintains a preset number of handles, including checking whether the handles in the handle cache are available and the keep-alive of the handles in the handle cache.

[0042] Further, in the above-mentioned distributed file system handle pool, the background thread is used to dynamically adjust the state of the handles in the handle cache, including:

[0043] When there are a first part of handle requests in a waiting state and a second part of handles in an idle state in the handle cache, a replace handle task is triggered to be executed;

[0044] The replace handle state thread replaces the second part of handles in the idle state with the first part of handles in the waiting state, and triggers a create handle task.

[0045] The creating handle thread pool creates new handles for the first part of handle requests in a waiting state using the creating handle interface.

[0046] It should be understood that the above is one of the methods for dynamically adjusting the handle state in the handle cache in the distributed file system handle pool provided by the present application: when there are requests for handles of partial keys in a waiting state, the handles of partial keys are in an idle state, a handle replacement task is triggered, that is, the handles of inactive keys in an idle state are evicted, and new handles are created for active keys.

[0047] Further, the above-mentioned dynamic adjustment of the handle state in the handle cache in the distributed file system handle pool further comprises:

[0048] After the client uses the handle to complete file data reading and writing;

[0049] The handle in the handle cache is changed to an idle state by calling the handle return interface.

[0050] It should be understood that the above is one of the methods for dynamically adjusting the handle state in the handle cache in the distributed file system handle pool provided by the present application: after the client uses the handle to complete file data reading and writing, the handle is changed to an idle state by calling the handle return interface of the handle pool, and the handle is reused by other requests.

[0051] The advantage of the embodiment of the present application is that: the present application uses a Map container to implement a hierarchical handle pool, constructs a multi-level index, that is, uses the Key and Value of the handle pool to index the directory, bucket and file of the data storage system, and meets the demand of the user to establish the mapping relationship between the upper directory and the bottom directory, bucket of the data storage system according to the business rules. The self-adaptive adjustment mechanism transparent to the user is realized by using a background thread, the idle handle is evicted in time, the flow limiting effect is played, and the pressure on the bottom data storage system is relieved. The self-adaptive adjustment mechanism is used to dynamically adjust the handle state and the number of handles in the handle pool, improve the handle reuse efficiency, and ensure that the number of handles changes with the user request volume on the premise that the bottom data storage system is not greatly stressed, so as to guarantee the performance of the distributed file system. BRIEF DESCRIPTION OF DRAWINGS

[0052] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the drawings needed to be used in the embodiments or the prior art description will be briefly introduced. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can be obtained by those skilled in the art without creative labor.

[0053] Figure 1A method for dynamically adjusting the number of handles in the handle cache provided in this application embodiment is illustrated. Figure One ;

[0054] Figure 2 A method for dynamically adjusting the number of handles in the handle cache provided in this application embodiment is illustrated. Figure Two ;

[0055] Figure 3 A method for dynamically adjusting the number of handles in the handle cache provided in this application embodiment is illustrated. Figure Three ;

[0056] Figure 4 This application provides a schematic diagram of a method for dynamically adjusting the handle state in the handle cache. Figure One ;

[0057] Figure 5 This application provides a schematic diagram of a method for dynamically adjusting the handle state in the handle cache. Figure Two . Detailed Implementation

[0058] To make the above-mentioned objectives, features, and advantages of this application more apparent and understandable, the specific embodiments of this application are described in detail below with reference to the accompanying drawings. Many specific details are set forth in the following description to provide a thorough understanding of this application. However, this application can be implemented in many other ways different from those described herein, and those skilled in the art can make similar modifications without departing from the spirit of this application. Therefore, this application is not limited to the specific embodiments disclosed below.

[0059] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used herein in the specification of this application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application. The term "and / or" as used herein includes any and all combinations of one or more of the associated listed items.

[0060] A distributed file system handle pool includes: a handle cache, an operation handle interface provided by the handle pool, and a background thread.

[0061] Handle caching is used to implement multi-level indexes and cache handles;

[0062] The operation handle interface is used to receive user operations and operate on the handles in the handle cache;

[0063] A background thread is used to dynamically adjust the handle status and number of handles in the handle cache.

[0064] The operation handle interface at least includes: a get handle interface, a return handle interface, a close handle interface, and a create handle interface.

[0065] The background thread at least includes: a create handle thread, a close handle thread, a replace handle thread, and a handle pool health check thread.

[0066] Specifically, in the embodiment of the application, the multi-level index is used to store the file data of the upper directory into the specified data storage system directory and bucket, the user uses the interface provided by the handle pool to operate the handle, and then the handle is used to complete the interaction with the data storage system; the state and the number of the handles in the handle pool are dynamically adjusted, the data storage system handle is efficiently reused, the pressure on the underlying storage system is reduced, and the read and write performance of the distributed file system is ensured.

[0067] Further, in the handle pool of the distributed file system, the handle cache is used to implement the multi-level index and the cached handle, and includes:

[0068] The handle cache is implemented by a thread-safe Map container, the Key index of the handle cache stores the directory and the bucket of the data storage system, and the Value of the handle cache indexes the file and the object of the data storage system.

[0069] The Value of the handle pool represents the handle set in the directory or the bucket of the data storage system specified by the Key, and the Value of the handle cache is implemented by a thread-safe set.

[0070] Specifically, in the embodiment of the application, the thread-safe Map container is used to implement the hierarchical handle pool, the Key of the handle pool is used to index the directory or the bucket of the data storage system, so that the user can establish the corresponding relationship between the upper directory and the directory or the bucket of the data storage system according to the business rule, and facilitate the business use; the Value of the handle pool represents the handle set in the directory or the bucket of the data storage system specified by the Key, and is implemented by a thread-safe set, the elements in the set are the handles of the data storage system, and index the file and the object of the data storage system. After the user establishes the mapping relationship between the upper directory and the directory or the bucket of the data storage system according to the business rule, the user reads and writes the file in different directories by indexing the Key of the handle pool to different directories or buckets of the data storage system.

[0071] Further, in the handle pool of the distributed file system, the get handle interface is used to obtain the handle from the handle cache.

[0072] The return handle interface is used to return the handle to the handle cache.

[0073] The close handle interface is used to scan and close the handle in the handle cache.

[0074] The handle creation interface is used to create a handle and add the handle to the handle cache.

[0075] Specifically, the above are interfaces involved in the application embodiments and the roles of the interfaces.

[0076] Further, in the above distributed file system handle pool, the handle creation thread is used to asynchronously execute the handle creation task.

[0077] The handle closing thread is used to asynchronously execute the handle closing task.

[0078] The handle state checking thread is used to asynchronously execute the handle state checking task.

[0079] The handle state replacing thread is used to asynchronously execute the handle state replacing task.

[0080] The handle pool health check thread is used to asynchronously execute the health check task.

[0081] Specifically, the above are the types and roles of the background threads involved in the application embodiments.

[0082] Figure 1 A method for dynamically adjusting the number of handles in the handle cache provided by the application embodiments Figure One .

[0083] Further, in the above distributed file system handle pool, the background thread is used to dynamically adjust the number of handles in the handle cache, which includes Figure 1 S101-S103 three steps:

[0084] S101: When the number of available handles in the handle cache is less than the number of user requests, trigger the handle creation task;

[0085] S102: The handle creation thread of the handle pool uses the handle creation interface provided by the handle pool to create a handle;

[0086] S103: Trigger the user request of the handle creation task, and wait for and obtain the available handle.

[0087] Specifically, in the application embodiments, the above S101-S103 are one of the ways in which the background thread is used to dynamically adjust the number of handles in the handle cache: when the number of available handles is less than the number of user requests, the handle creation task is triggered; the handle creation thread of the handle pool uses the handle creation interface to create a handle of the underlying data storage system, and adds the directory of the underlying data storage system, the bucket index, and the handle index of the underlying data storage system to the handle cache; when the total number of created handles is equal to the number of user requests, the get handle interface provided by the handle pool is used to obtain a handle from the handle cache.

[0088] Further, in the distributed file system handle pool, the background thread is configured to dynamically adjust the number of handles in the handle cache, and the handle pool further comprises:

[0089] When the number of available handles in the handle cache is greater than the number of user requests, a handle is obtained from the handle cache using a handle obtaining interface provided by the handle pool.

[0090] It should be understood that the above is one of the methods for dynamically adjusting the number of handles in the handle cache by the background thread in the distributed file system handle pool provided by the present application: when the number of available handles in the handle cache corresponding to the Key is greater than the number of user requests, a handle is directly obtained from the handle cache, and the obtained handle is encapsulated as a file input stream and an output stream and returned to the client.

[0091] Figure 2 A method for dynamically adjusting the number of handles in the handle cache provided by the embodiment of the present application Figure Two .

[0092] Further, in the distributed file system handle pool, the background thread is configured to dynamically adjust the number of handles in the handle cache, and the handle pool further comprises: Figure 2 , comprising two steps S201 and S202:

[0093] S201: When the time of the handle cached in the handle cache reaches a preset time, a handle closing task is triggered;

[0094] S202: The handle closing thread scans and closes the handles in the handle cache using a handle closing interface provided by the handle pool.

[0095] Specifically, in the embodiment of the present application, the above S201 and S202 are one of the methods for dynamically adjusting the number of handles in the handle cache by the background thread: when the time of the handle cached in the handle cache reaches a preset time, a handle closing task is triggered, and the handle closing thread scans and closes the handles in the handle cache using a handle closing interface provided by the handle pool, thereby removing the expired handles in the handle cache.

[0096] Figure 3 A method for dynamically adjusting the number of handles in the handle cache provided by the embodiment of the present application Figure Three .

[0097] Further, in the distributed file system handle pool, the background thread is configured to dynamically adjust the number of handles in the handle cache, and the handle pool further comprises: Figure 3 , comprising two steps S301 and S302:

[0098] S301: The handle pool periodically triggers a health check task;

[0099] S302: The handle pool health check thread maintains a preset number of handles.

[0100] Specifically, in the embodiments of the present application, the above S301 to S302 are one of the methods for the background thread to dynamically adjust the number of handles in the handle cache: the handle pool periodically triggers a health check task, and the handle pool health check thread maintains a preset number of handles, including checking whether the handles in the handle cache are available, keeping the handles in the handle cache alive, and the like, to alleviate the cold start problem.

[0101] Figure 4 A method for dynamically adjusting the handle state in the handle cache provided by the embodiments of the present application is shown in the following Figure One .

[0102] Further, in the above distributed file system handle pool, the background thread is used to dynamically adjust the handle state in the handle cache, which includes Figure 4 , including S401 to S403 three steps:

[0103] S401: When there are first part handle requests in the waiting state and second part handles in the idle state in the handle cache, a replace handle task is triggered to be executed;

[0104] S402: The replace handle state thread replaces the second part handles in the idle state with the first part handles in the waiting state, and triggers a create handle task;

[0105] S403: The create handle thread uses the create handle interface to create new handles for the first part handle requests in the waiting state.

[0106] Specifically, in the embodiments of the present application, the above S401 to S403 are one of the methods for the background thread to dynamically adjust the handle state in the handle cache: when there are part of Key handle requests in the waiting state and part of Key handles in the idle state, a replace handle task is triggered, that is, the idle handles in the idle state under the inactive Key are eliminated, and new handles are created for the active Key. The idle handles in the cold directory with small request amount are eliminated, and handles are created and added to the hot directory with large request amount, so that the resources of the data storage system are more efficiently utilized.

[0107] Figure 5 A method for dynamically adjusting the handle state in the handle cache provided by the embodiments of the present application is shown in the following Figure Two .

[0108] Further, in the above distributed file system handle pool, the handle state in the handle cache is dynamically adjusted, which includes Figure 5 , and further includes S501 to S502 two steps:

[0109] S501: After the client uses the handle to complete file data reading, writing, etc.

[0110] S502: Call the return handle interface to change the handle in the handle cache to an idle state.

[0111] It should be understood that, in the above specific embodiments of the present application, S501 to S502 are one of the dynamic adjustment of the handle state in the handle cache: after the client uses the handle to complete file data reading, writing, etc., the return handle interface of the handle pool is called, the handle is changed to an idle state, and is available for reuse by other requests.

[0112] Those skilled in the art can understand that, although some embodiments described herein include certain features included in other embodiments but not others, the combination of features of different embodiments means within the scope of the present application and forms different embodiments.

[0113] Those skilled in the art can understand that the description of each embodiment is focused on, and the parts not described in detail in a certain embodiment can refer to the relevant description of other embodiments.

[0114] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited to this. Any person skilled in the art can easily think of various equivalent modifications or replacements within the technical range disclosed by the present application, and these modifications or replacements should be covered within the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

Claims

1. A distributed file system handle pool, characterized in that, include: Handle caching, handle pools providing handle operation interfaces, and background threads: The handle cache is used to implement multi-level indexes and cache handles; The operation handle interface is used to receive user operations and operate on the handles in the handle cache. The background thread is used to dynamically adjust the handle status and number of handles in the handle cache; The operation handle interface includes at least: a handle acquisition interface, a handle return interface, a handle close interface, and a handle creation interface; The background threads include at least: a handle creation thread, a handle closing thread, a handle status check thread, a handle status replacement thread, and a handle pool health check thread; The handle cache is used to implement multi-level indexing and cache handles, including: The handle cache is implemented using a thread-safe Map container. The key of the handle cache indexes the directory and bucket of the data storage system, and the value of the handle cache indexes the file and object of the data storage system. Wherein, the Value of the handle pool represents the set of handles in the directory or bucket of the data storage system specified by the Key, and the Value of the handle cache is implemented by a thread-safe collection.

2. A distributed file system handle pool according to claim 1, characterized in that, The handle acquisition interface is used to acquire a handle from the handle cache; The handle return interface is used to return the handle to the handle cache; The handle close interface is used to scan and close handles in the handle cache; The handle creation interface is used to create handles and add them to the handle cache.

3. A distributed file system handle pool according to claim 1, characterized in that, The handle creation thread is used to asynchronously execute the handle creation task; The handle-closing thread is used to asynchronously execute the handle-closing task; The handle status checking thread is used to asynchronously execute the handle status checking task; The handle replacement state thread is used to asynchronously execute handle replacement state tasks; The handle pool health check thread is used to perform health check tasks asynchronously.

4. A distributed file system handle pool according to claim 1, characterized in that, The background thread is used to dynamically adjust the number of handles in the handle cache, including: When the number of available handles in the handle cache is less than the number of user requests, a handle creation task is triggered; The handle pool's handle creation thread uses the aforementioned handle creation interface to create handles; The user request that triggers the handle creation task waits and obtains an available handle.

5. A distributed file system handle pool according to claim 4, characterized in that, The background thread is used to dynamically adjust the number of handles in the handle cache, and also includes: When the number of available handles in the handle cache is greater than the number of user requests, the handle retrieval interface is used to retrieve handles from the handle cache.

6. A distributed file system handle pool according to claim 1, characterized in that, The background thread is used to dynamically adjust the number of handles in the handle cache, including: When the handle is cached in the handle cache for a preset time, the handle shutdown task is triggered. The handle closing thread uses the handle closing interface to scan and close handles in the handle cache.

7. A distributed file system handle pool according to claim 1, characterized in that, The background thread is used to dynamically adjust the number of handles in the handle cache, including: The handle pool periodically triggers a handle pool health check task; The handle pool health check thread maintains a preset number of handles.

8. A distributed file system handle pool according to claim 1, characterized in that, The background thread is used to dynamically adjust the handle state in the handle cache, including: When the handle cache contains a first part of handle requests that are in a waiting state and a second part of handles that are in an idle state, the handle replacement task is triggered. The handle replacement thread replaces the second part of the handle that is in an idle state with the first part of the handle that is in a waiting state, triggering the handle creation task; The handle creation thread handle pool uses the handle creation interface to create new handles for the first batch of handle requests that are in a waiting state.

9. A distributed file system handle pool according to claim 1, characterized in that, The dynamic adjustment of the handle state in the handle cache further includes: After the client completes file data reading and writing using the handle, it calls the handle return interface to make the handle in the handle cache idle.

Images