Patent Application
20190370411
Applications use caching to deliver data more efficiently at the cost of using more memory. For example, if an application caches data from a database in local storage (e.g., cache memory), when the application receives a query for that data, the application can provide the data from the local storage instead of from the database. The advantage of providing the data from the local storage is that the application can most likely respond to the query much more quickly than accessing the data in the database. However, storing the data in both the database and the local storage uses more memory. To make memory use more efficient, the application may attempt to implement a caching solution that stores only items that are repeatedly requested in the local storage.
A Bloom filter is a probabilistic data stricture that helps determine if an item exists in a set. For example, a system can use a Bloom filter to determine whether or not a query has been received before. When a query is received, the system applies an algorithm, such as a hash function, to parameters for the query to generate a key, such as a hash value, for the Bloom filter. If the resulting key is found in the Bloom filter, the application determines that the query has been seen before. In some cases, the application may store the data from the database for the query in the local storage because the query is being repeated.
The algorithm used by the Bloom filter to generate the keys is probabilistic and false positives are possible and become more probable as the size of the item set grows. That is, because a hash value compresses the item set to a smaller set of keys, as more queries are received and keys are generated, the probability that a false positive results increases. A false positive is where the Bloom filter indicates that the query has been seen before, but in reality, the query has not been seen before. As different queries may produce the same key, the Bloom filter will eventually start producing more false positives as the item set increases, which will negate the effect of using the Bloom filter because the local storage will not be using storage as efficiently as possible.
Described herein are techniques for a storage system. In the following description, for purposes of explanation, numerous examples and specific details are set forth in order to provide a thorough understanding of particular embodiments. Particular embodiments as defined by the claims may include some or all of the features in these examples alone or in combination with other features described below, and may further include modifications and equivalents of the features and concepts described herein.
A system uses a probabilistic data structure, such as a Bloom filter, to determine whether or not a query has been previously received within a time period. To keep the state of the Bloom filter up to date, a query processor may periodically use a new instance of the Bloom filter. For example, a first Bloom filter may be used during a first time period and then a second Bloom filter will replace the first Bloom filter when the first time period ends, which starts a second time window.
Just replacing the first Bloom filter with the second Bloom filter where the second Bloom filter has no values that are set means the second Bloom filter has no record of any queries that have been previously received. That is, any queries received before the second time period starts will not be represented in the second Bloom filter. Thus, the efficiency of using local storage to service queries that were previously received is lost when the second Bloom filter replaces the first Bloom filter because the computing system considers all queries that are now received to be the first time those queries are encountered. To avoid this problem, some embodiments start training the second Bloom filter before the first time period ends. During training, when a query is received and a key is generated from the query for insertion in the first Bloom filter, the same key is inserted in the second Bloom filter. Thus, when it is time for the second Bloom filter to replace the first Bloom filter, the second Bloom filter includes keys for some of the most recent queries that were received during the training period. However, older queries that have not been recently received are not reflected in the second Bloom filter. Accordingly, using the training period improves the operation of the system because the Bloom filter does not continue to grow in size where more false positives result. Rather, the second Bloom filter reflects queries that have been most recently received and may be repeated, but other older queries that may not be repeated in the future are not reflected in the second Bloom filter. This may reduce false positives while still allowing the second Bloom filter to be used to determine when recent queries have been repeated.
System
Application 106 may be any application that is accessing data in database 112. Database 112 may store data in a structured format, such as in database tables that are accessed using database queries that include parameters to access the data. The process for accessing data in database 112 is performed through query server 104. For example, a query processor 108 receives a query from application 106, and processes parameters of the query to determine which data in database 112 to retrieve. Processing the query takes time to communicate with database 112 to retrieve the data because database 112 is typically connected to query server 104 via an external network. Typically, it would be faster for query processor 108 to retrieve the data for the query if the data was stored in local storage, such as cache 114. For example, cache 114 may be stored locally to query server 104, such as in memory. Although cache 114 may be in memory storage, cache 114 may also be other types of storage devices, such as locally connected storage, that are accessible faster than accessing data in database 112. Accordingly, retrieving the data in cache 114 takes less time than communicating via an external network to database 112.
Query processor 108 includes a Bloom filter 110. Query processor 108 receives a query and can use a function or algorithm for Bloom filter 110, such as a hash function, to generate a key, such as a hash value, from parameters of the query. Query processor 108 can then insert the key into Bloom filter 110. The function used to generate the key takes the parameters as input and generates a key based on the parameters. The key represents the query, such as the function will generate the same key for the same query with the same parameters.
Query processor 108 can use Bloom filter 110 to determine when queries are repeated. For example, query processor 108 receives a query, generates a key, and if the query was not received before, inserts the key into the Bloom filter 110. Then, if query processor 108 receives a query and the key for that query is in the Bloom filter 110, query processor 108 determines that this query has been repeated. Because this query is being repeated, it may be more likely that the query will be repeated in the future and response times will be quicker if data for the query from database 112 is stored in cache 114. The next time this query is received, query processor 108 determines the key for the query is in Bloom filter 110 and can retrieve the data from cache 114.
Bloom filter 110 is a probabilistic data structure that is used to test whether an element is a member of a set. A probabilistic data structure may use hash functions to randomize and compactly represent a set of items. Bloom filter 110 may include false positives, but false negatives are not possible. That is, Bloom filter 110 can return whether a query has not been seen before, but can return that a query has possibly been seen before. As discussed above, it is possible that the function will generate the same key for different queries. Thus, it is possible that the function may produce false positives, where different parameters are input into the function, but the function outputs the same key. When a query that has not been received before corresponds to the same key as a query that was received before, this is considered a false positive. The false positives negate the benefits of using Bloom filter 110 and as the number of queries being processed by query processor 108 increases and more keys are inserted into Bloom filter 110, the odds of a false positive happening increase. Accordingly, some embodiments improve the use of Bloom filter 110 by rotating Bloom filters where a first Bloom filter 110 is replaced by a second Bloom filter 110. The use of the new Bloom filter 110 decreases the number of false positives because the item size is limited by rotating in new Bloom filters 110. Although a Bloom filter is described, other probabilistic data structures may be used, such as Count-min sketch.
The use of rotating Bloom filters 110 may reduce the number of false positives; however, if a second Bloom filter 110 is started as an empty data structure, then query processor 108 is starting over in determining whether queries have been received before. That is, an empty Bloom filter means that query processor 108 cannot be used to determine if any queries have been received before. Thus, a query that was received when the first Bloom filter 110 was being used would not be represented in the second Bloom filter 110. To improve this process, some embodiments train the second Bloom filter 110 before the time period in which the second Bloom filter 110 is scheduled to be used by query processor 108.
When training the second Bloom filter 110, query processor 108 uses the first Bloom filter 110 to process queries. That is, query processor 108 receives a query, generates a key, and if the query was not received before, inserts the key into the first Bloom filter 110. Also, if query processor 108 receives a query and the key for that query is in the first Bloom filter 110, query processor 108 can check whether data for the query from database 112 in already stored in cache 114. If so, query processor 108 retrieves the data from cache 114 and provides the data to client 102. If the data is not already stored in cache 114 query processor 108 can store data for the query from database 112 in cache 114. Also, when training second Bloom filter 110, query processor 108 inserts any key generated by query processor 108 into second Bloom filter 110. For example, if the query was not received before, query processor 108 inserts the key into the first Bloom filter 110 and also the second Bloom filter 110 that is being trained. Also, if query processor 108 receives a query and the key for that query is in the first Bloom filter 110 query processor 108 still inserts the key into the second Bloom filter 110.
Using the above training, query processor 108 can rotate Bloom filters 110 while still maintaining recent records for queries that have been previously received. The rotating efficiently uses cache 114 by storing data in cache 114 for queries that have been repeated. Queries that were not repeated during the training of the new Bloom filter 110 would not be included in the new Bloom filter 110. However, since the query has not been repeated in a recent time period, it is possible that these queries will not be performed again or are queries that are no longer being repeated. Thus, the efficiency that may be lost by not including these queries from prior to the training period may not be great; however, the reduction of false positives may be significant.
Using the Bloom Filter
At 202, query processor 108 receives a first query for data in database 112. For example, application 106 may send a query for data in database 112. The query may include parameters that are used to retrieve data from database 112. The parameters may include any information identifying data in database 112.
At 204, query processor 108 generates a key using the parameters for the first query and inserts the key into Bloom filter 110. As discussed above, query processor 108 may use a function, such as a hash function, that receives the parameters for the query as input and generates a key based on the values of those parameters. This process is assuming that the query has not been seen before.
Because query processor 108 has not seen this query before, query processor 108 retrieves the data from database 112 at 206 using the parameters of the query and returns the data for the first query to application 106. The retrieving of the data may require query processor 108 to communicate with database 112 through a network. The communication through the network to retrieve the data takes a first amount of time.
At 208, query processor 108 receives a second query for data in the database. The second query may include the same parameters as the first query or different parameters. At 210, query processor 108 generates a key for the second query using the function. If the second query includes the same parameters as the first query, then query processor 108 would generate the same key as the first query. If the second query includes different parameters than the first query, then query processor 108 may generate a different key.
At 212, query processor 108 determines if the key is found in Bloom filter 110. If the key is not in Bloom filter 110, the process continues at 214 where query processor 108 retrieves the data from the database, stores the key, and returns the data for the second query to application 106. This is similar to the process described in the process at 202, 204, and 206.
However, if the key was in Bloom filter 110, at 216, query processor 108 determines if the data is stored in cache 114. Because the key is stored in cache 114, query processor 108 knows that the query has been received before. Two situations may result: either the second query have been received once before (e.g., the data is not in cache 114) or has been received more than once before (e.g., the data is in cache 114). When query processor 108 determines that a key is in Bloom filter 110, query processor 108 may first check cache 114 to determine whether data for the key has been already stored in cache 114.
If the data is not in cache 114, at 218, query processor 108 retrieves the data from database 112 and returns the data for the second query to application 106. Because this query has been repeated, query processor 108 may expect that this query may continue to be repeated and it may be efficient to store the data in cache 114 for faster access. At 220, query processor 108 stores the data in cache 114.
If the data was stored in cache 114, which may mean that the query has been received more than twice, at 222, query processor 108 retrieves the data from cache 114 and returns the data for the second query to application 106. Query processor 108 may determine whether or not the data is stored in cache 114 by using the key and determining if any data for the key has been stored in cache 114. The data in cache 114 may be indexed by keys that are generated for the queries. Thus, if data for a key has been stored in cache 114, query processor 108 can look up to see whether cache 114 includes the key.
Retrieving the data from cache 114 does not retrieve the data from database 112. That is, the time to retrieve data from cache 114 is shorter than the first time period to retrieve data from database 112. Because accessing cache 114 is quicker than accessing data in database 112, query processor 108 can process the query faster using the data from cache 114.
Training of the Bloom Filter
At 304, query processor 108 determines that a time occurs within the first time period to start training a second Bloom filter 110. The time is before the first time period ends and may be previously defined. For example, the time may be halfway through the first time period; however, it may be at other times within the first rime period. The time may be set to allow the training of the second Bloom filter 110 to capture some queries in the first time period, but not all the queries. Second Bloom filter 110 is not trained for the whole time of the first time period to limit the size of second Bloom filter 110. This reduces the item set in Bloom filter 110, which may reduce the number of false positives while keeping the efficiency of using second Bloom filter 110 by capturing the most recent repeated queries.
At 306, query processor 108 starts training second Bloom filter 110 by inserting keys into the second Bloom filter 110 that are being inserted into a first Bloom filter 110 when the first Bloom filter 110 is being used to answer queries. As discussed above, second Bloom filter 110 is not being used to answer queries; rather, first Bloom filter 110 is used to answer the queries. However, the training of second Bloom filter 110 inserts keys into second Bloom filter 110 for queries that are received during the training period.
At 308, when the first time period ends, query processor 108 starts using the trained second Bloom filter 110 to answer queries. The queries that have been received during the training period are now captured by second Bloom filter 110.
At 702-2, the second time period starts and query processor 108 stops using first Bloom filter 110-1, which may be discarded. Then, query processor 108 uses a second Bloom filter 110-2 to respond to queries. The use of second Bloom filter 110-2 continues for the second time period, which lasts until 702-3.
Similar to above, a training process for a third Bloom filter 110-3 starts at a time 704-2. The above process continues where at the end of the second time period at 702-3, query processor 108 stops using second Bloom filter 110-2 and starts using third Bloom filter 110-3. Query processor 108 uses third Bloom filter 110-3 until the third time period ends at 702-4. At 704-3, query processor 108 trains a fourth Bloom filter 110-4. The above process continues as Bloom filters are continually rotated to be used by query processor 108.
Conclusion
Accordingly, using rotating Bloom filters, query processor 108 can limit the size of the queries that are being recorded into the Bloom filters. Limiting the size reduces the number of false positives that may result. However, using the training process allows query processor 108 to capture the queries that have been most recently repeated. This allows query processor 108 to more efficiently respond to queries that have been recently repeated. Query server 104 can thus respond to queries more quickly while limiting false positives.
System
Computer system 810 may be coupled via bus 805 to a display 812, such as a cathode ray tube (CRT) or liquid crystal display (LCD), for displaying information to a computer user. An input device 811 such as a keyboard and/or mouse is coupled to bus 805 for communicating information and command selections from the user to processor 801. The combination of these components allows the user to communicate with the system. In some systems, bus 805 may be divided into multiple specialized buses.
Computer system 810 also includes a network interface 804 coupled with bus 805. Network interface 804 may provide two-way data communication between computer system 810 and the local network 820. The network interface 804 may be a digital subscriber line (DSL) or a modem to provide data communication connection over a telephone line, for example. Another example of the network interface is a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links are another example. In any such implementation, network interface 804 sends and receives electrical, electromagnetic, or optical signals that carry digital data streams representing various types of information.
Computer system 810 can send and receive information through the network interface 804 across a local network 820, an Intranet, or the Internet 830. In the Internet example, software components or services may reside on multiple different computer systems 810 or servers 831-835 across the network. The processes described above may be implemented on one or more servers, for example. A server 831 may transmit actions or messages from one component, through Internet 830, local network 820, and network interface 804 to a component on computer system 810. The software components and processes described above may be implemented on any computer system and send and/or receive information across a network, for example.
Particular embodiments may be implemented in a non-transitory computer-readable storage medium for use by or in connection with the instruction execution system, apparatus, system, or machine. The computer-readable storage medium contains instructions for controlling a computer system to perform a method described by particular embodiments. The computer system may include one or more computing devices. The instructions, when executed by one or more computer processors, may be configured to perform that which is described in particular embodiments.
As used in the description herein and throughout the claims that follow, “a”, “an”, and “the” includes plural references unless the context clearly dictates otherwise. Also, as used in the description herein and throughout the claims that follow, the meaning of “in” includes “in” and “on” unless the context clearly dictates otherwise.
The above description illustrates various embodiments along with examples of how aspects of particular embodiments may be implemented. The above examples and embodiments should not be deemed to be the only embodiments, and are presented to illustrate the flexibility and advantages of particular embodiments as defined by the following claims. Based on the above disclosure and the following claims, other arrangements, embodiments, implementations and equivalents may be employed without departing from the scope hereof as defined by the claims.
