KR20210067014A - Apparatus and method for caching - Google Patents

Abstract

Provided is a caching device. The caching device according to one embodiment of the present invention may comprise a cache and a cache processing module. Here, in response to determining that a called write-related function does not correspond to a preset function, the cache processing module processes the write-related function according to a first processing routine, and processes the write-related function according to a second processing routine in response to determining that the called write-related function corresponds to the preset function. The first processing routine is a routine that processes dirty data to be generated by writing the target data of the write-related function to the cache, and the second processing routine may be a routine for processing dirty data existing in the cache to be reflected in a storage. Therefore, the present invention is capable of providing safe data in an event of the cache failing.

Description

Caching device and method {APPARATUS AND METHOD FOR CACHING}

The present invention relates to a caching apparatus and method. More particularly, it relates to a caching device capable of providing data safety while ensuring high data write performance in consideration of occurrence of a cache failure, and a caching method performed by the device.

A cache is a temporary storage in which data is stored, and is a device used to improve data read and write performance of applications. Data write performance is closely related to the write policy of the cache, and the write policy of the cache is largely divided into a write-through policy and a write-back policy.

As shown in FIG. 1 , the write-through policy is a policy in which a requested write operation is completed when specific data (e.g. x=100) is written to both the cache and the storage. On the other hand, the write back policy is a policy in which a write operation is completed immediately when specific data (e.g. x=100) is written to the cache.

The advantages and disadvantages of the cache write policy as described above are clear. Since the write-through policy always guarantees data coherency, it is robust against a cache failure, but has a disadvantage in that data write performance is limited by storage write performance. Although the write back policy can guarantee high write performance, there is a disadvantage in that data safety cannot be guaranteed because the latest data (eg, dirty data) is lost when a failure occurs in the cache. Therefore, when only one write policy is adhered to, data safety and high write performance cannot be guaranteed together.

Meanwhile, a cache management module that performs overall cache management, such as performing control according to a cache write policy, is generally implemented in an operating system. For example, as shown in FIG. 2 , the cache management module is implemented in a kernel layer (eg, a block layer) in a typical implementation manner.

When the cache management module is implemented inside the operating system, all dirty data existing in the cache is flushed to the storage according to the "fsync()" function call of the application. For example, as shown in Fig. 2, when the application (#1) calls the "fsync()" function on file A to reflect the dirty data D1 of file A to storage, it exists in the cache. The dirty data (D2) of file B used by the application (#2) is also flushed to storage. In this case, there is a problem that the write delay by the fsync() function for file A affects the performance of other applications (#2). That is, there is a problem that the write delay by the fsync() function of the application (#1) affects the performance of the other application (#2) using the file B. In addition, the application (#1), which called the "fsync()" function to reflect the dirty data (D1) of file A to the storage, not only the dirty data of file A (D1) but also the dirty data of file B (D2) Since it has to wait until the flushing of , the response time of the "fsync()" function of the application (#1) becomes unnecessarily long.

Korean Patent Publication No. 10-2013-0010690 (published on January 30, 2013)

The technical problem to be solved by the present invention is to provide a caching device capable of providing data safety against a failure situation of a cache and a caching method performed by the device.

Another technical problem to be solved by the present invention is to provide a caching device capable of providing data safety and guaranteeing high write performance at the same time, and a caching method performed by the device.

Another technical problem to be solved by the present invention is a caching device and caching performed by the device that can solve the problem that write delay according to flushing of dirty data of a specific file degrades the performance of applications using different files to provide a way

Another technical problem to be solved by the present invention is to provide a caching device and a caching method performed by the device that can solve the problem that write delay caused by flushing of dirty data of a specific application degrades the performance of other applications will be.

The technical problems of the present invention are not limited to the technical problems mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the following description.

In order to solve the above technical problem, a caching device according to an embodiment of the present invention includes a cache and a cache processing module, wherein the cache processing module, the called write-related function does not correspond to a preset function In response to determining that no, the write-related function is processed according to a first processing routine, and in response to determining that the called write-related function corresponds to the preset function, the write-related function is executed according to a second processing routine. and the first processing routine is a routine for writing the target data of the write-related function to the cache so that dirty data is generated, and the second processing routine includes: It may be a routine that processes data to be reflected in storage.

In one embodiment, the first processing routine is a routine that writes the target data of the write-related function to the cache so that dirty data associated with the first file is generated, and the second processing routine includes: It is a routine that processes dirty data associated with the existing first file to be reflected in storage, and does not reflect dirty data associated with a second file existing in the cache to the storage, wherein the first file is related to the called write. It can be the target file of the function.

In some embodiments, the first processing routine may include a routine for generating mapping information between an offset of the target data in the first file and a storage location on the cache.

In some embodiments, the first processing routine is responsive to determining that a size of cache data associated with the first file present in the cache is greater than or equal to a threshold, and stores the target data to the storage, and exists in the cache. in response to determining that the size of cache data associated with the first file is less than the threshold, storing the target data in the cache. In this case, the first processing routine may include a routine for updating the cache data using the target data in response to determining that the cache data corresponding to the target data exists in the cache.

In one embodiment, the first processing routine is a routine that writes target data of the write-related function to the cache to generate dirty data related to a first task, and the second processing routine includes: A routine that processes dirty data associated with the first task to be reflected in storage, and does not reflect dirty data associated with a second task existing in the cache to the storage, wherein the first task executes the write-related function It can be a called task.

In an embodiment, the preset function may be a synchronization function.

In an embodiment, the cache processing module may flush dirty data of the cache to the storage using a worker operating in the background.

In some embodiments, the cache processing module flushes dirty data associated with a first file having a modification frequency less than a threshold to storage, and flushes dirty data associated with a second file having a modification frequency greater than or equal to the threshold to storage. may not be

In an embodiment, the hooking module and the processing module may be located in an application layer.

In order to solve the above technical problem, a caching method performed in a caching device according to another embodiment of the present invention includes the steps of: determining whether a called write-related function corresponds to a preset function; processing the write-related function according to a first processing routine in response to determining that it does not correspond to the function; and in response to determining that the write-related function corresponds to the preset function, processing the write-related function according to a second processing routine The first processing routine is a routine for writing the target data of the write-related function to a cache so that dirty data is generated, and the second processing routine is present in the cache It may be a routine that processes dirty data to be reflected in storage.

In order to solve the above technical problem, a computer program according to another embodiment of the present invention includes the steps of determining whether a called write-related function corresponds to a preset function in combination with a computing device; processing the write-related function according to a first processing routine in response to determining that it does not correspond to, and in response to determining that the write-related function corresponds to the preset function, processing the write-related function according to a second processing routine step is executed, wherein the first processing routine writes the target data of the write-related function to a cache and processes so that dirty data is generated, and the second processing routine includes: It may be a routine that processes dirty data to be reflected in storage.

1 is a diagram for explaining and comparing cache write policies.
2 is a diagram for explaining a problem that may occur when a cache management module is implemented in an operating system.
3 is a block diagram illustrating a computing device according to a first embodiment of the present invention.
4 is an exemplary diagram illustrating an implementation location of a cache management module according to an embodiment of the present invention.
5A and 5B are block diagrams illustrating a cache management module according to some embodiments of the present invention.
6 is an exemplary diagram for explaining a process in which a write-related function is processed according to a first processing routine according to some embodiments of the present invention.
7 is an exemplary diagram for explaining a process in which a write-related function is processed according to a second processing routine according to an embodiment of the present invention.
8A to 8D illustrate changes in metadata generated and referenced by a cache management module according to various embodiments of the present invention in various cases in which a plurality of tasks call a write-related function targeting a plurality of files; It is an example for doing.
9 is a hardware configuration diagram illustrating a caching device according to an embodiment of the present invention.
10 is a block diagram illustrating a computing device according to a second embodiment of the present invention.
11 to 12B are flowcharts illustrating a caching method according to some embodiments of the present invention.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. Advantages and features of the present invention and methods of achieving them will become apparent with reference to the embodiments described below in detail in conjunction with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below, but may be implemented in various different forms, and only these embodiments allow the disclosure of the present invention to be complete, and common knowledge in the art to which the present invention pertains It is provided to fully inform those who have the scope of the invention, and the present invention is only defined by the scope of the claims.

In adding reference numerals to the components of each drawing, it should be noted that the same components are given the same reference numerals as much as possible even though they are indicated on different drawings. In addition, in describing the present invention, if it is determined that a detailed description of a related known configuration or function may obscure the gist of the present invention, the detailed description thereof will be omitted.

Unless otherwise defined, all terms (including technical and scientific terms) used herein may be used with the meaning commonly understood by those of ordinary skill in the art to which the present invention belongs. In addition, terms defined in a commonly used dictionary are not to be interpreted ideally or excessively unless clearly defined in particular. The terminology used herein is for the purpose of describing the embodiments and is not intended to limit the present invention. As used herein, the singular also includes the plural unless specifically stated otherwise in the phrase.

In addition, in describing the components of the present invention, terms such as first, second, A, B, (a), (b), etc. may be used. These terms are only for distinguishing the components from other components, and the essence, order, or order of the components are not limited by the terms. When a component is described as being “connected”, “coupled” or “connected” to another component, the component may be directly connected or connected to the other component, but another component is between each component. It should be understood that elements may be “connected,” “coupled,” or “connected.”

As used herein, "comprises" and/or "comprising" refers to the presence of one or more other components, steps, operations and/or elements mentioned. or addition is not excluded.

Hereinafter, some embodiments of the present invention will be described in detail with reference to the accompanying drawings.

3 is a block diagram illustrating a computing device 10 according to a first embodiment of the present invention. In particular, Figure 3 illustrates that the caching device 100 according to an embodiment of the present invention is implemented in a general computing device.

Referring to FIG. 3 , the computing device 10 according to the first embodiment may be configured to include a caching device 100 , an application 160 , and a storage 180 . However, this is only a preferred embodiment for achieving the object of the present invention, and it goes without saying that some components may be added or deleted as necessary. In addition, it is noted that each component of the computing device 10 shown in FIG. 3 represents functionally separated functional elements, and at least one component may be implemented in a form integrated with each other in an actual physical environment. . Meanwhile, in the present specification, the application 160 includes a running program, process, thread, and the like, and in the following description, these are collectively referred to as an application or task.

In the first embodiment, the caching device 100 is a device that provides a caching function for read and write data of the application 160 . In order to provide the caching function, the caching device 100 may be configured to include a cache management module 120 and a cache 140 .

The cache management module 120 is a module that performs overall control and management functions for the cache 140 . A detailed description of the detailed configuration and operation of the cache management module 120 will be described later with reference to the drawings below with reference to FIG. 5 .

According to an embodiment of the present invention, as shown in FIG. 4 , the cache management module 120 may be implemented to be located in the application layer 31 (eg, a user level library). That is, the cache management module 120 manages dirty data information of the cache 140 in the application layer 31 . Also, the cache management module 120 may directly store write data in the cache 140 without going through the kernel of the operating system. According to this embodiment, the kernel cannot know the dirty data information of the cache. In some embodiments, even if the kernel processes a synchronization function (eg, fsync()) that targets a particular file, dirty data in other files is not flushed to storage 180 . In some other embodiments, even if the kernel processes a particular application's synchronization function (eg, fsync( )), dirty data of other applications is not flushed to storage 180 . Accordingly, the problem that the write delay by the synchronization function for a specific file of a specific application negatively affects the performance of another application using the other file can be solved. In addition, the response time of the synchronization function may be shortened compared to the case where other files unrelated to the target file of the synchronization function are also flushed to the storage 180 .

For reference, the term "application layer" may be used interchangeably with various terms such as user level, user area, and application area in the technical field.

Referring back to FIG. 3 , the cache 140 is a device used to improve data read and write performance of the application 160 . As long as the cache 140 is implemented as a device having a relatively faster access speed than the storage 180 , it may be implemented in any device. For example, the cache 140 may be implemented as a non-volatile memory such as a solid state drive (SSD) or a hard disk drive (HDD), and may include a static random access memory (SRAM), a dynamic random access memory (DRAM), or the like. It may be implemented as a volatile memory.

In the first embodiment, the application 160 is any software provided with a caching function from the caching device 100 .

In the first embodiment, the storage 180 is a device used to store data of the application 160 . The storage 180 may be implemented as a device having a relatively slower access speed than the cache 140 .

In this specification, the term "storage" is a term used to distinguish it from a cache. Accordingly, the storage 180 may also be implemented as a non-volatile memory such as an SSD or a hard disk drive (HDD), or may be implemented as a volatile memory such as a static random access memory (SRAM) or a dynamic random access memory (DRAM). .

So far, the computing device 10 according to the first embodiment of the present invention has been described with reference to FIG. 1 . Hereinafter, the configuration and operation of the cache management module 120 according to an embodiment of the present invention will be described with reference to FIGS. 5A to 8D .

5A is a block diagram illustrating the cache management module 120 according to an embodiment of the present invention, and FIG. 5B is a block diagram illustrating the cache management module 120 according to another embodiment of the present invention. The cache management module 120 of the embodiment shown in Fig. 5A is configured to include an application interface module 121 and a processing module 123, and the cache management module 120 of the embodiment shown in Fig. 5B is a hooking module 121a. ) and the processing module 123 is different in that it is configured to include. The configuration and operation method of the processing module 123 shown in FIGS. 5A and 5B are similar. 5A and 5B show only the components related to the embodiment of the present invention. Accordingly, those skilled in the art to which the present invention pertains can see that other general-purpose components other than those shown in FIGS. 5A and 5B may be further included. In addition, as the components of the cache management module 120 shown in FIGS. 5A and 5B represent functional elements that are functionally separated, at least one component may be implemented in a form that is integrated with each other in an actual physical environment. Take note.

First, in the embodiment shown in FIG. 5A , the application interface module 121 provides an API of a function related to reading or writing data to applications, and detects a call to a function related to reading or writing data of a running application or task. When a function related to reading or writing data is detected, the application interface module 121 provides the called function, target file, target data, and the like to the processing module 123 .

In the embodiment shown in FIG. 5B , the hooking module 121 hooks write-related functions (eg, write system calls such as write() and fsync()) and read-related functions called by a running application or task. . For convenience of description, only the processing of the hooking module 121 for the write-related function will be described below. The hooking module 121 sets a hook for the write-related function, detects a write-related function call of a task through the hooking, intercepts the control flow of the detected write-related function, and provides it to the processing module 123 .

Any method may be used as a method for the hooking module 121 to hook a write-related function. For example, the hooking module 121 may hook a write-related function using at least one hooking technique widely known in the art.

The processing module 123 applies a write-related function detected by the application interface module 121 or hooked by the hooking module 121a (hereinafter referred to as a “called write-related function” without distinction) as appropriate. It is processed according to the processing routine. Specifically, the processing module 123 determines whether the called write-related function corresponds to a preset function, and in response to determining that the called write-related function does not correspond to the preset function, processes the called write-related function according to the first processing routine do. On the contrary, in response to determining that the called write-related function corresponds to a preset function, the processing module 123 processes the called write-related function according to a second processing routine. In this case, the first processing routine means a routine for writing the target data of the called write-related function to the cache 140 or the storage 180 . In addition, the second processing routine refers to a routine that processes dirty data existing in the cache 140 to be reflected in the storage.

According to an embodiment of the present invention, the preset function may be a synchronization function (eg, fsync()). This is because a task synchronization request can be interpreted as an intention of a task requesting data safety guarantee. According to the present embodiment, data safety at the task level can be guaranteed by using the task synchronization request as a hint. In addition, since write-related functions other than the synchronization function will be processed according to the write-back policy, high write performance can also be guaranteed. Hereinafter, it is assumed that the preset function is a synchronization function, and descriptions of some embodiments of the present invention are continued. However, this is only for convenience of understanding, and according to embodiments, any number of different types of functions may be set as a reference function for determining a processing routine.

Also, according to an embodiment of the present invention, the processing module 123 may flush the dirty data in the cache to the storage using a worker operating in the background. The worker may be implemented in any form, such as a thread or a process.

In an example, the worker may flush dirty data according to a predetermined period. In another example, the worker may flush dirty data in response to determining that the rate of dirty data in the cache is greater than or equal to a threshold. In another example, the worker may flush dirty data in response to determining that the number of standby I/O operations in the storage is less than a threshold. In another example, the worker may flush dirty data based on a combination of the foregoing examples.

Meanwhile, in some embodiments, when the processing module 123 flushes the dirty data of the cache to the storage using a worker operating in the background, the dirty data is selectively selected in consideration of the modification frequency for each file. can be flushed with When the processing module 123 flushes the dirty data in the background, the dirty data associated with the file whose modification frequency measured for a certain time is equal to or greater than the threshold is not flushed, and only the dirty data associated with the file whose modification frequency is less than the threshold is flushed. . Since a file having a high modification frequency measured for a predetermined time in the past may be expected to have a high modification frequency in the future, dirty data associated with such a file is excluded from a background flush target, thereby improving flush efficiency.

According to the above-described embodiment, some or all of the dirty data may be flushed through the background worker even before the dirty data in the cache is flushed to the storage according to the second processing routine. Accordingly, data safety is further improved, and processing delay due to dirty data flushing can be minimized.

A process in which the processing module 123 processes a write-related function called according to the cache write policy will be described in detail with reference to FIGS. 6, 7, 8A to 8D, and 11 to 12B.

Each component of FIG. 5 may mean software or hardware such as a field programmable gate array (FPGA) or an application-specific integrated circuit (ASIC). However, the above components are not meant to be limited to software or hardware, and may be configured to reside in an addressable storage medium, or may be configured to execute one or more processors. The functions provided in the components may be implemented by more subdivided components, or may be implemented as one component that performs a specific function by combining a plurality of components.

Hereinafter, a process in which the called write-related function is processed according to each processing routine will be described with reference to FIGS. 6 and 7 .

First, FIG. 6 illustrates a process in which a write-related function called according to some embodiments of the present invention is processed according to a first processing routine.

6 , in response to determining that the called write-related function does not correspond to a synchronization function (eg, fsync()), the processing module 123 converts the called write-related function according to the first processing routine. handle

In one embodiment, the first processing routine may be a routine that stores target data of the called write-related function in an appropriate location in the cache 140 and completes the write operation.

In this case, the processing module 123 generates metadata for the target data and stores the generated metadata in a specific area of the cache 140 . The metadata includes an identifier of the task that called the write-related function, mapping information between write information of the target data (eg, file descriptor, file offset, size of target data, etc.) and a storage location in the cache 140 . can do. The metadata may be referenced when an operation such as reading or flushing dirty data is performed.

8A is a diagram for exemplarily explaining metadata generated, stored, and referenced by the processing module 123 according to an embodiment of the present invention. The first item in the table shown in FIG. 8A is that the target data was stored in cache block 100 by a write-related function called by task #1 to write the target data to the offset 0 position of file A, It indicates that the state of the cache block address 100 is "dirty". Similarly, in the second item of the table shown in FIG. 8A, the target data is stored at cache block 200 by a write-related function called by task #2 to write the target data to the offset 0 position of the file B. and the status of the cache block address 200 is "dirty". A process in which the metadata is referenced and updated in the process of performing an operation such as flushing of the cache will be described later.

In another embodiment, the first processing routine may select a storage location of the target data in consideration of the size of the dirty data stored in the cache 140 . For example, when a write function for the first file is called, sizes of dirty data about the first file existing in the cache 140 may be identified. When the size of the dirty data related to the first file is less than the threshold, the target data is stored in an appropriate location of the cache 140 to generate dirty data and a write operation may be completed. If the size of the dirty data regarding the first file existing in the cache 140 is equal to or greater than the threshold, the processing module 123 may directly store the target data in the storage 180 instead of the cache 140 . However, when dirty data corresponding to the target data already exists in the cache 140 , the target data is not stored in the storage 180 and the dirty data existing in the cache 140 is used as the target data. Can be updated. As another example, when the write function is called by the first task, sizes of dirty data associated with the first task existing in the cache 140 may be identified. When the size of the dirty data related to the first task is less than the threshold, the target data may be stored in an appropriate location of the cache 140 to generate dirty data and a write operation may be completed. If the size of the dirty data related to the first task existing in the cache 140 is greater than or equal to the threshold, the processing module 123 stores the target data in the storage 180 instead of the cache, so that the It is possible to prevent the size of the dirty data related to the first task from further increasing. However, when dirty data corresponding to the target data already exists in the cache 140 , the dirty data existing in the cache 140 is updated with the target data without storing the target data in the storage 180 . can do. By processing the write-related function in the first processing routine by the above-described method, dirty data related to some files or some tasks occupies too much storage space of the cache 140 , and thus the cache 140 utilization efficiency is reduced. can be resolved.

In the above-described embodiment, it has been described that the storage location of the target data is determined as either one of the storage 180 and the cache 140 according to whether the size of the dirty data related to the specific file or the specific task is less than or equal to the threshold. A storage location of the target data may be determined according to whether the size of cache data (including dirty data and clean data in the cache) related to a specific file or a specific task is less than or equal to or greater than the threshold.

Next, FIG. 7 illustrates a process in which a write-related function called according to an embodiment of the present invention is processed according to a second processing routine.

7 , in response to determining that the called write-related function corresponds to a synchronization function (eg, fsync()), the processing module 123 processes the called write-related function according to the second processing routine. do. Specifically, the processing module 123 processes the dirty data stored in the cache 140 to be flushed to the storage 180 by transmitting a synchronization command for the dirty data to the cache 140 .

So far, a process in which a write-related function called according to each processing routine is processed has been described with reference to FIGS. 6 and 7 . Hereinafter, a processing procedure of the second processing routine according to some embodiments of the present invention will be described with reference to FIGS. 8A to 8D .

According to an embodiment of the present invention, when the synchronization function for the first file is called by the first task, the processing module 123 transmits a synchronization command for the dirty data about the first file to the cache 140 . By doing so, dirty data regarding the first file stored in the cache 140 is flushed to the storage 180 . In this case, dirty data about the second file, which is different from the first file, stored in the cache 140 is not flushed to the storage 180 . As a result, the write delay caused in the process of reflecting the dirty data of the first file from which the synchronization function is called to the storage 180 has a negative effect on the performance of the synchronization function call or other tasks unrelated to the first file. will not reach In addition, the response time of the synchronization function is shortened compared to a case in which dirty data of a second file irrelevant to the first file from which the synchronization function is called is also flushed to the storage 180 .

FIG. 8B shows that, in a situation in which data stored in the cache 140 has a state as shown in FIG. 8A , task #1 calls a synchronization function for file A, and the processing module 123 performs a second processing routine It is a diagram explaining the result of processing the synchronization function call by When the sync function for file A is called by task #1, only dirty data about file A is flushed to storage 180, and only the caching status of file A is changed from "dirty" to "clean" ( reference numeral 801 in Fig. 8b). That is, task #2 and task #3 irrelevant to file A from which the synchronization function is called are not affected by the write delay due to the synchronization function call. In addition, in the task #1, it is possible to avoid unnecessary delay in response time due to the dirty data of files B and C being flushed together to the storage 180 .

FIG. 8C shows that, in a situation in which data stored in the cache 140 has a state as shown in FIG. 8A , task #3 calls a synchronization function for file B, and the processing module 123 performs a second processing routine It is a diagram explaining the result of processing the synchronization function call by When the sync function for file B is called by task #3, only dirty data about file B is flushed to storage 180, and only the caching status of file B is changed from "dirty" to "clean". In some embodiments, in addition to the dirty data of file B stored in cache 140 by task #3 that called the synchronization function, the dirty data of file B stored in cache 140 by task #1 is also stored in storage 180 ), and the caching status may be changed from “dirty” to “clean” (reference numerals 802 and 803 in FIG. 8C ). In some other embodiments, only dirty data of file B stored in cache 140 by task #3 that called the synchronization function is flushed to storage 180 by task #1 that does not call the synchronization function. Dirty data of file B stored in cache 140 is not flushed to storage 180 .

According to another embodiment of the present invention, when the synchronization function is called by the first task, the processing module 123 transmits a synchronization command for the dirty data associated with the first task to the cache 140, so that the cache ( The dirty data associated with the first task on 140 ) is processed to be flushed to the storage 180 . In this case, dirty data stored in the cache 140 and associated only with a second task different from the first task is not flushed to the storage 180 . Accordingly, the write delay caused in the process of reflecting the dirty data associated with the first task that called the synchronization function to the storage 180 does not negatively affect the performance of other tasks unrelated to the synchronization function call. In addition, the response time of the synchronization function may be shortened compared to a case in which dirty data related to another task that is not related to the first task that called the synchronization function is also flushed to the storage 180 .

FIG. 8D shows that, in a situation in which data stored in the cache 140 has a state as shown in FIG. 8A , task #2 calls a synchronization function, and the processing module 123 performs the synchronization by a second processing routine. It is a diagram explaining the result of processing a function call. When the synchronization function is called by task #2, only dirty data about files C and D, generated by task #2, is flushed to storage 180, and only the caching status of files C and D is "dirty" " is changed to "clean" (reference numerals 804 and 805 in Fig. 8D). In this case, the dirty data generated by the task #1 and task #3 different from the task #2 are not flushed to the storage 180 . That is, task #1 and task #3 are not affected by write delay due to the call of the synchronization function of task #2. In addition, in the task #2, it is possible to avoid unnecessary delay in response time due to the dirty data generated by the task #1 and the task #3 being flushed to the storage 180 together.

So far, the configuration and operation of the cache management module 120 according to the embodiment of the present invention has been described with reference to FIGS. 5 to 8D. Hereinafter, the hardware configuration of the caching device 100 according to an embodiment of the present invention will be described.

9 is a hardware configuration diagram showing the caching device 100 according to an embodiment of the present invention.

Referring to FIG. 9 , the caching device 100 includes one or more processors 101 , a bus 105 , a cache 107 , and a memory 103 for loading a computer program executed by the processor 101 and , a storage 109 for storing the cache management software 109a. However, only the components related to the embodiment of the present invention are shown in FIG. 9 . Accordingly, a person skilled in the art to which the present invention pertains can see that other general-purpose components other than the components shown in FIG. 9 may be further included.

The processor 101 controls the overall operation of each component of the caching device 100 . The processor 101 includes a central processing unit (CPU), a micro processor unit (MPU), a micro controller unit (MCU), a graphic processing unit (GPU), or any type of processor well known in the art. can be In addition, the processor 101 may perform an operation on at least one application or program for executing the method according to the embodiments of the present invention. The caching device 100 may include one or more processors.

The memory 103 stores various data, commands and/or information. The memory 103 may load one or more programs 109a from the storage 109 to execute the caching method according to embodiments of the present invention. A RAM is shown as an example of the memory 103 in FIG. 9 .

When the cache management software 109a is loaded into the memory 103 , the cache management module 120 shown in FIG. 5 may be implemented on the memory 103 .

The bus 105 provides communication between the components of the caching device 100 . The bus 105 may be implemented as various types of buses, such as an address bus, a data bus, and a control bus.

The cache 107 supports wired and wireless Internet communication of the caching device 100 . Also, the cache 107 may support various communication methods other than Internet communication. To this end, the cache 107 may be configured to include a communication module well known in the art.

The storage 109 may non-temporarily store the one or more programs 109a. In Figure 9, cache management software 109a is shown as an example of the one or more programs 109a.

The storage 109 is a non-volatile memory such as a read only memory (ROM), an erasable programmable ROM (EPROM), an electrically erasable programmable ROM (EEPROM), a flash memory, a hard disk, a removable disk, or well in the art to which the present invention pertains. It may be configured to include any known computer-readable recording medium.

The cache 107 may operate as a temporary storage for the storage 109 or as a temporary storage for a separate storage (not shown).

The cache management software 109a may include instructions that, when loaded into the memory 103 , cause the processor 101 to perform a caching method according to some embodiments of the present invention. Here, the instruction refers to a series of instructions grouped based on a function, which is a component of a computer program and is executed by a processor.

For example, the cache management software 109a may detect or hook a call of a write-related function, an operation of determining whether the called write-related function corresponds to a preset function, and an operation of determining whether the called write-related function corresponds to a preset function. in response to determining that it does not correspond, processing the called write-related function according to a first processing routine; and in response to determining that it corresponds to the preset function, converting the called write-related function according to a second processing routine. It may include instructions for performing a processing operation.

So far, the hardware configuration of the caching device 100 according to an embodiment of the present invention has been described with reference to FIG. 9 . Hereinafter, in order to provide more convenience of understanding, the computing device 20 according to the second embodiment of the present invention will be briefly described.

10 is a block diagram illustrating a computing device 20 according to a second embodiment of the present invention. In particular, Figure 10 illustrates that the caching device 100 according to an embodiment of the present invention is implemented in a server that provides a cloud storage service.

Referring to FIG. 10 , the computing device 20 operates as a predetermined server providing a cloud storage service, and the caching device 100 provides a caching function to a plurality of clients 301 , 303 , 305 using the cloud storage service. can provide For example, the caching device 100 creates a virtual cache for each client (301, 303, 305), and provides an independent caching function to each client (301, 303, 305) through the created virtual cache. can provide In this case, each of the virtual caches may correspond to a portion of the physical cache 140 .

In the second embodiment, the computing device 20 may provide a cloud storage service to the clients 301 , 303 , and 305 through the service modules 151 , 153 , and 155 . The service modules 151 , 53 , and 155 may be implemented as a virtual machine, a container, or the like, but the scope of the present invention is not limited thereto.

When the cache management module 120 is implemented in the operating system as in the prior art, the service performance of the other clients 303 and 305 may be deteriorated due to the synchronization process for the virtual cache of the client 301 .

However, according to the embodiment of the present invention, when the cache management module 120 is implemented in the application area, synchronization processing for the virtual cache of the client 301 does not affect the service performance of other clients 303 and 305 . does not Accordingly, when the cache device 100 according to an embodiment of the present invention is implemented in a server that provides a cloud storage service, it is possible to provide a more seamless storage service and improve the service satisfaction of users.

In the second implementation, the clients 301 , 303 , 305 may communicate with the computing device 20 via a network. Here, the network includes all types of wired/wireless networks such as a local area network (LAN), a wide area network (WAN), a mobile radio communication network, and a Wibro (Wireless Broadband Internet). can be implemented.

So far, the computing device 20 according to the second embodiment of the present invention has been described with reference to FIG. 10 . As described above, the caching device 100 according to an embodiment of the present invention can be used universally in various devices (eg, computing devices 10 and 20).

Hereinafter, a caching method according to some embodiments of the present invention will be described in detail with reference to FIG. 11 and the following drawings. Hereinafter, each step of the caching method may be performed by a device having a cache. For example, the device may be a caching device 100 . Hereinafter, it is assumed that the caching method is performed by the above-described caching device 100 to continue the description. However, for convenience of description, the description of the operating subject of each step included in the caching method may be omitted. Further, each step of the caching method may be implemented with instructions of a computer program (eg, cache management software 109a) executed by a processor when loaded into a memory.

11 is a flowchart of a caching method according to some embodiments of the present invention. However, this is only a preferred embodiment for achieving the object of the present invention, and it goes without saying that some steps may be added or deleted as necessary.

Referring to FIG. 11 , the caching method according to the present embodiment starts in step S100 in which the caching device 100 detects a call to a write-related function.

In step S140, the caching device 100 determines whether the called write-related function corresponds to a preset function. The preset function refers to a reference function for determining a processing routine. For example, the preset function may be a synchronization function such as "fsync()", but the scope of the present invention is not limited thereto.

In step S160, in response to the determination that does not correspond to the preset function, the caching device 100 processes the called write-related function according to the first processing routine.

In an embodiment, as shown in FIG. 12A , the caching device 100 stores target data of a write-related function in a cache and generates mapping information for the target data ( S162 and S164 ). As described above, the mapping information is metadata used for cache management, and the identifier of the task that called the write-related function, write information of the target data (eg, file descriptor, file offset, size of target data, etc.) and mapping information between a storage location on the cache 140 . In addition, the caching device 100 does not store the target data in the storage, but completes the processing of the called write-related function.

In another embodiment, the caching device 100 determines whether the sum of the sizes of the dirty data related to the target file of the write-related function is equal to or greater than a threshold as shown in FIG. 12B ( S181 ). If the sum of the sizes of the dirty data is less than the threshold, the target data is stored in a cache and mapping information for the target data is generated (S182 and S184). In addition, the caching device 100 does not store the target data in the storage, but completes the processing of the called write-related function. If the sum of the sizes of the dirty data is equal to or greater than the threshold, the target data is directly stored in the storage 180 instead of the cache 140, and a processing operation for the called write-related function is completed. However, even if the sum of the sizes of the dirty data is equal to or greater than the threshold, if the dirty data corresponding to the target data already exists in the cache 140 , the target data is not stored in the storage 180 and is not stored in the cache 140 . ) may be updated with the target data. In step S181 of the above-described embodiment, the target data is stored in the cache 140 or the storage 180 based on the size of the dirty data related to the target file of the write-related function, but associated with the task that calls the write-related function. A storage location of the target data may be determined based on the size of the dirty data. Further, in step S181 of the above-described embodiment, the storage location of the target data is determined based on the size of the dirty data related to the target file, but based on the size of cache data (including dirty data and clean data) related to the target file. , it is also noted that the storage location of the target data may be determined.

It will be described again with reference to FIG. 11 . In step S180, in response to the determination that the preset function corresponds to, the caching device 100 processes the called write-related function according to the second processing routine. As described above, the second processing routine refers to a routine that processes dirty data existing in the cache to be reflected in the storage. In some embodiments, the second processing routine flushes and reflects only dirty data related to the target file of the write-related function to storage, and does not reflect dirty data related to other files to the storage. In some other embodiments, the second processing routine flushes and reflects only dirty data related to the task that called the write-related function to the storage, and does not reflect dirty data related to other tasks to the storage.

So far, a caching method according to some embodiments of the present invention has been described with reference to FIGS. 11 to 12B. According to the above-described method, some of the various types of write-related functions called by the application are processed according to the write back policy, and dirty data is reflected in the storage as the specific function is called. Accordingly, data safety may be improved compared to the case where only the write-back policy is adhered to, and data write performance may be improved compared to the case where only the write-through policy is adhered. In particular, when the specific function is set as a synchronization function, data safety at the application level can be guaranteed. In addition, the response time of the synchronization function can be shortened by reflecting only the target file of the synchronization function or the dirty data related to the specific task that called the synchronization function to the storage and not reflecting other dirty data to the storage, and the synchronization function is called It is possible to minimize the effect of write delay caused by .

So far, some embodiments of the present invention and effects thereof have been described with reference to FIGS. 3 to 12B. Effects of the present invention are not limited to the above-mentioned effects, and other effects not mentioned will be clearly understood by those skilled in the art from the following description.

The concept of the present invention described so far with reference to FIGS. 3 to 12B may be implemented as computer readable code on a computer readable medium. The computer-readable recording medium may be, for example, a removable recording medium (CD, DVD, Blu-ray disk, USB storage device, removable hard disk) or a fixed recording medium (ROM, RAM, computer-equipped hard disk). can The computer program recorded on the computer-readable recording medium may be transmitted to another computing device through a network such as the Internet and installed in the other computing device, thereby being used in the other computing device.

In the above, even though all the components constituting the embodiment of the present invention are described as being combined or operating in combination, the present invention is not necessarily limited to this embodiment. That is, within the scope of the object of the present invention, all the components may operate by selectively combining one or more.

Although acts are shown in a particular order in the drawings, it should not be understood that the acts must be performed in the specific order or sequential order shown, or that all depicted acts must be performed to obtain a desired result. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of the various components in the embodiments described above should not be construed as necessarily requiring such separation, and the described program components and systems may generally be integrated together into a single software product or packaged into multiple software products. It should be understood that there is

Although the embodiments of the present invention have been described above with reference to the accompanying drawings, those of ordinary skill in the art to which the present invention pertains can realize that the present invention can be embodied in other specific forms without changing the technical spirit or essential features. can understand Therefore, it should be understood that the embodiments described above are illustrative in all respects and not restrictive. The protection scope of the present invention should be construed by the following claims, and all technical ideas within the equivalent range should be construed as being included in the scope of the present invention.

Claims (15)

cache; and
a cache processing module;
The cache processing module,
In response to determining that the called write-related function does not correspond to a preset function, processing the write-related function according to a first processing routine,
In response to determining that the called write-related function corresponds to the preset function, processing the write-related function according to a second processing routine,
The first processing routine is a routine that writes the target data of the write-related function to the cache and processes so that dirty data is generated;
The second processing routine is a routine that processes dirty data existing in the cache to be reflected in storage,
caching device. According to claim 1,
The first processing routine is a routine for writing the target data of the write-related function to the cache so that dirty data associated with the first file is generated;
The second processing routine is a routine that processes dirty data associated with the first file existing in the cache to be reflected in storage, and does not reflect dirty data associated with the second file existing in the cache to the storage,
The first file is a target file of the called write-related function,
caching device. 3. The method of claim 2,
The first processing routine is
a routine for generating mapping information between an offset of the target data in the first file and a storage location in the cache;
caching device. 3. The method of claim 2,
The first processing routine is
in response to determining that a size of cache data associated with the first file present in the cache is greater than or equal to a threshold, store the target data in the storage;
in response to determining that a size of cache data associated with the first file present in the cache is less than the threshold, a routine for storing the target data in the cache;
caching device. 5. The method of claim 4,
The first processing routine is
a routine for updating the cache data using the target data in response to determining that cache data corresponding to the target data exists in the cache;
caching device. According to claim 1,
The first processing routine is a routine that writes target data of the write-related function to the cache so that dirty data related to a first task is generated;
The second processing routine is a routine that processes dirty data associated with the first task existing in the cache to be reflected in storage, and does not reflect dirty data associated with the second task existing in the cache to the storage,
The first task is a task that called the write-related function,
caching device. 7. The method of claim 6,
The first processing routine is
a routine for generating mapping information between an offset of the target data and a storage location in the cache;
caching device. 7. The method of claim 6,
The first processing routine is
in response to determining that a size of cache data associated with the first task present in the cache is greater than or equal to a threshold, store the target data in the storage;
in response to determining that a size of cache data associated with the first task present in the cache is less than the threshold, a routine for storing the target data in the cache;
caching device. 9. The method of claim 8,
The first processing routine is
a routine for updating the cache data using the target data in response to determining that cache data corresponding to the target data exists in the cache;
caching device. According to claim 1,
The preset function is a synchronization function,
caching device. According to claim 1,
The cache processing module flushes the dirty data of the cache to storage using a worker operating in the background,
caching device. 12. The method of claim 11,
The cache processing module,
flushing dirty data associated with the first file whose modification frequency is less than the threshold to storage;
do not flush dirty data associated with a second file whose modification frequency is equal to or greater than the threshold to storage;
caching device. According to claim 1,
The cache processing module is located in the application layer (application layer),
caching device. In the caching method performed in the caching device,
determining whether the called write-related function corresponds to a preset function;
processing the write-related function according to a first processing routine in response to determining that the function does not correspond to the preset function; and
In response to determining that the preset function corresponds to, processing the write-related function according to a second processing routine,
The first processing routine is a routine for writing the target data of the write-related function to a cache and processing so that dirty data is generated;
The second processing routine is a routine that processes dirty data existing in the cache to be reflected in storage,
caching method. As a computer program stored in a computer-readable recording medium,
In combination with a computing device,
determining whether the called write-related function corresponds to a preset function;
processing the write-related function according to a first processing routine in response to determining that the function does not correspond to the preset function; and
In response to determining that the function corresponds to the preset function, processing the write-related function according to a second processing routine,
The first processing routine is a routine for writing the target data of the write-related function to a cache and processing so that dirty data is generated;
The second processing routine is a routine that processes dirty data existing in the cache to be reflected in storage,
computer program.

Images