Fine-grained cache replacement algorithm for big data processing under limited computing resources

Abstract

The application discloses a fine-grained cache replacement algorithm for big data processing under limited computing resources, and comprises the following steps: analyzing the influence of computing resources on cache process and cache granularity; considering the cache replacement problem of data blocks contained in abstract data sets under the limited computing resource environment, establishing a mathematical model of the fine-grained cache replacement problem with the target of minimizing the overall execution time of big data processing application, and making a decision on the data block to be cached at each time t; converting the cache replacement problem based on the computing characteristics of big data processing operators and the data block-oriented greedy cache strategy; and solving the fine-grained cache replacement problem based on the dynamic programming idea. Through the analysis on the relationship between computing resources and cache granularity, the fine-grained cache replacement algorithm is proposed under the limited computing resource scene, the completion time of big data processing application is greatly reduced, and the cache hit rate of the cache process is improved.

Description

TECHNICAL FIELD

[0001] The present application relates to a big data processing system and memory optimization technology for large-scale data processing, in particular to a fine-grained cache replacement algorithm for big data processing under limited computing resources. BACKGROUND

[0002] The cache process of the big data processing system based on memory computing has cache requirements under limited memory. Specifically, the big data processing system writes all intermediate data of data processing into memory to accelerate data processing using memory resources, which makes the memory cache decision problem of large-scale data processing application particularly important in the scenario of limited memory resources. The cache mode based on memory directly writes the intermediate data generated by the application into memory, which can further reduce the completion time of large-scale data processing application due to the advantage of not needing to reload data from disk. Since memory resources are often the bottleneck of the big data processing system, the data processing framework cannot cache all intermediate data to memory during application execution, and needs to dynamically replace the data to be cached during application runtime. Efficient cache replacement decision can improve memory usage efficiency and greatly reduce the execution time of big data processing application, so it is attracting more and more research attention.

[0003] In a typical big data processing system, since both abstract data sets and memory data blocks can be cached, there is a multi-granularity cache requirement in the big data processing application. There is a correlation between computing resources and the granularity of cached data. When computing resources are sufficient, caching only part of the data blocks of the abstract data set will not speed up the overall operation of the data processing application, which means that in this scenario, the coarse-grained cache replacement problem at the operator level should be considered. In the scenario of limited computing resources, caching only part of the data blocks of the abstract data set can speed up the overall operation of the data processing application, so in this scenario, considering the fine-grained cache replacement algorithm at the data block level can further improve the cache performance.

[0004] The deficiencies of the existing research work on the cache replacement problem of big data processing application can be summarized as follows. First, the existing cache replacement strategies lack analysis of the parallel execution mode in big data processing application, regarding data processing stages and tasks as serial execution, which is not consistent with the real cache process of big data processing system. Second, the existing work only studies the coarse-grained cache replacement problem of data processing operators in the scenario of sufficient computing resources, and lacks related cache replacement research in the scenario of limited computing resources.

[0005] Based on such technical background, we propose a fine-grained cache replacement algorithm for computing resource-constrained big data processing, which considers the impact of computing resources on cache performance. For the data block-level cache replacement problem in multi-stage parallel big data processing applications under computing resource-constrained scenarios, the invention proposes a fine-grained cache replacement algorithm based on the dynamic programming idea. SUMMARY

[0006] For the cache replacement problem of big data processing applications, the purpose of the invention is to provide a fine-grained cache replacement algorithm for big data processing under computing resource constraints, which considers both the parallel execution mode in data processing and the impact of computing resources on the cache process, aiming to improve the efficiency of memory resource use in the cache process of big data processing applications and further improve cache performance, thereby greatly reducing the execution time of data processing applications.

[0007] To achieve the above purpose, the technical solution of the invention is as follows:

[0008] The invention first establishes a mathematical model for the parallel execution mode in multi-task parallel big data processing applications, and studies the cache replacement problem for multi-task parallel big data processing applications. Then, the invention considers the impact of computing resources on the cache process under computing resource-constrained scenarios, and proposes a fine-grained cache replacement algorithm at the data block level. The invention includes the following steps:

[0009] A fine-grained cache replacement algorithm for big data processing under computing resource constraints, characterized by: first, establishing a mathematical model for the parallel execution mode in multi-task parallel big data processing applications, and then considering the impact of computing resources on the cache process under computing resource-constrained scenarios, proposing a fine-grained cache replacement algorithm at the data block level. Including the following steps:

[0010] (1) Analyze the impact of computing resources on the cache process: in the cache replacement problem of big data processing systems, the relationship between computing resources and cache granularity is obtained, which can be summarized as follows: when computing resources are sufficient, caching only part of the data blocks of the abstract data set cannot accelerate the data processing process, at this time, the cache object is set to the abstract data set, and a coarse-grained cache replacement algorithm is considered; when computing resources are limited, caching only part of the data blocks of the abstract data set can speed up the execution of data processing applications, at this time, the cache object is set to the memory data block, and a fine-grained cache replacement algorithm is considered;

[0011] (2) Establish a mathematical model for the fine-grained cache replacement problem: First, the computing resources are modeled in the cache replacement problem in the form of task scheduling. Then, the execution delay of the application, job, stage, and task in typical big data processing and the data blocks to be cached are modeled by abstracting the data processing mode implied in the directed acyclic graph G = (V, E) of the application. On this basis, the fine-grained cache replacement problem is defined as follows: for each data block b t At the moment t when the calculation is completed, the set of data blocks to be cached at this moment is determined Thus, the overall execution delay of the data processing job in which the data block b t is located and all subsequent jobs is minimized.

[0012] (3) Convert the cache replacement problem based on the characteristics of big data processing: Since the fine-grained cache replacement problem for computing resource-constrained scenarios is an NP-hard problem, based on the computing characteristics of big data processing operators and the greedy cache strategy for data blocks, the modeled cache replacement problem is converted into a variant of the classic NP-complete problem. Considering that there are already a large number of research works on solving the classic NP-complete problem, we can choose the corresponding solving algorithm combined with the characteristics of the problem, thereby reducing the difficulty of problem solving.

[0013] (4) Design a fine-grained cache replacement algorithm based on dynamic programming: Based on the computing characteristics of the operator and the greedy cache strategy for data blocks, the problem is converted into a variant of the bounded knapsack problem. The algorithm includes two modules, namely the preprocessing module based on the characteristics of data processing and the fine-grained cache replacement module based on the dynamic programming idea. The former includes the problem conversion step based on the computing characteristics of the operator and the problem conversion step based on the greedy cache strategy for data blocks.

[0014] (5) Analyze the computational complexity of the fine-grained cache replacement algorithm: The computational complexity of the data block-level cache replacement algorithm based on the dynamic programming idea is determined by the three modules it contains, and is related to the total number of data blocks |B| and the memory upper limit L of the cache space in big data processing applications. The computational complexity of the fine-grained cache replacement algorithm is O(|B| 2 × L).

[0015] Further, in step (1), the influence of computing resources on the caching process includes the following characteristics:

[0016] (11) When computing resources are sufficient, consider the operator-level cache replacement algorithm: in the scenario where computing resources are sufficient, the starting execution time and the ending time of multiple data processing tasks in the same data processing stage are the same; at this time, only caching part of the data blocks of the abstract data set can only reduce the execution time of part of the tasks in the stage, and cannot reduce the overall execution time of the stage, so it cannot speed up the execution of the data processing application; in this scenario, when caching data, either do not cache a certain abstract data set or cache all data blocks of the abstract data set; since the abstract data set corresponds to the calculation result of the data processing operator, the operator-level cache replacement algorithm is considered when computing resources are sufficient;

[0017] (12) When computing resources are limited, the data block-level cache replacement algorithm should be considered: in the scenario where computing resources are limited, the system will schedule tasks according to the computing resource requirements of the tasks; the starting execution time of multiple tasks in the same stage is different, resulting in different ending times; at this time, only caching part of the data blocks of the abstract data set can speed up the execution of the data processing application; in this scenario, due to the influence of task scheduling, the data block-level cache replacement algorithm should be considered, because the algorithm has a finer granularity than the operator-level cache replacement algorithm and has a larger optimization space;

[0018] In step (2), the mathematical form model of the fine-grained cache replacement problem for multi-task parallel big data processing applications has the following characteristics:

[0019] (21) Problem description: in a certain determined big data processing application, there are a large number of data block calculation processes, and the data block is defined as b i,j,k,q ; at time t, when the data block b t is calculated, the big data processing system decides whether to cache the data block according to the current cache state, and replaces the cached data block when the cache space is about to overflow; in the execution process of the big data processing application, each replacement of the cached data block is equivalent to the decision of the data block that needs to be cached at the current time The decision problem is defined as the fine-grained cache replacement problem for multi-task parallel big data processing applications;

[0020] (22) Problem input: the directed acyclic graph G=(V, E) abstracted from the big data processing application, the starting execution time set {t i,j,k} of the big data processing task, the current cached data block set at time t, the data block b t to be added to the cache space at time t, and the upper limit L of the memory of the cache space;

[0021] (24) Decision variable: the data block set

[0022] (24) Optimization goal: Minimize the overall completion time of the job executed at time t, that is, all subsequent unexecuted jobs, formally expressed as The variable p t represents the subscript of the job executed at time t, the variable |J| is the job set of the big data processing application, and the variable S i,j represents the i-th executed job J in the application i The jth executed data processing stage, variable M i The i-th executed job J in the application i The number of stages included, function Z(S i,j ,CS) means that in the case of cache data block set CS, job J i Middle stage S i,j Calculate the time and job J to complete i The difference between the execution start time and the input data G = (V, E) and {t i,j,k}Calculated;

[0023] (25) Constraints: The fine-grained cache replacement problem for big data processing applications has constraints on the decision variables, the set of jobs considered in the optimization objective, and the upper limit of the memory for the data to be cached, and has the following characteristics:

[0024] d) In any data block b t At the moment t when the calculation is completed, the present invention uses the decision variable Indicates the data block that should be cached in the cache space at time t; assuming Indicates that data block b is not considered at time t t When the cached data in the cache space, the variable T * The set of times when all data blocks in a data processing application have been calculated; decision variables There are the following constraints:

[0025]

[0026] e) The optimization goal is to only consider minimizing the pth application t The overall completion time of the job and subsequent unexecuted jobs, variable p t The value range of does not exceed the total number of data processing jobs in the application. The constraints are as follows:

[0027]

[0028] f) Ensure that the cached data set in the cache decision does not exceed the memory limit of the cache space; among them, the function

[0029] s *(b) represents the memory space occupied by data block b, provided by a directed acyclic graph G = (V, E) abstracted by a big data processing application, and the variable L represents the upper limit of the memory space of the cache, and the constraint related to the upper limit of the memory of the data to be cached is as follows:

[0030]

[0031] In step (3), the conversion process of the cache replacement problem based on the characteristics of big data processing has the following characteristics: the fine-grained cache replacement problem of a multi-task parallel big data processing application is defined as C1, it is assumed that the number of stages contained in each job, the number of abstract data sets contained in each stage, and the number of tasks contained in each stage in the big data processing application are all 1, and the special case of problem C1 under this assumption is defined as problem Problem Equivalent to the 0-1 knapsack problem, the 0-1 knapsack problem is reduced to problem C1, and it is proved that the fine-grained cache replacement problem of a big data processing application is an NP-hard problem; due to the complexity of the problem, based on the calculation characteristics of the data processing operator and the greedy cache strategy for data blocks, problem C1 is converted to make it easier to solve, and the problem conversion steps are as follows:

[0032] (31) In the calculation characteristics of the data processing operator, since the time delay of the "job critical path" can be approximately replaced by the overall time delay of the job, and the stages in the "job critical path" are all serially executed; therefore, after replacing all stages of each job in the application with the "job critical path", the execution mode of the data processing stage changes from parallel to serial, and problem C1 can be converted to problem C2;

[0033] (32) In the calculation characteristics of the data processing operator, since the cache benefit of "hot access data" can be approximately replaced by the cache benefit of all data, and "hot access data" can be approximately considered as serial computation; therefore, after replacing the abstract data set calculated in each stage with "hot access data", the data computation mode in the data processing stage changes from parallel to serial, and problem C2 is converted to problem C3;

[0034] (33) In the calculation characteristics of the data processing operator, the operator representing the final calculation data in the data processing stage is called "stage representative calculation"; "stage representative calculation" can approximately replace the overall calculation of the stage; therefore, after replacing the "hot access data" in each data processing stage with the execution result of "stage representative calculation", i.e. "stage representative data", problem C3 is converted to problem C4;

[0035] (34) In the computational characteristics of data blocks, the tasks defined first in the same stage will be scheduled first, so the data blocks defined first in the same abstract data set will be computed first. Based on this characteristic, given the number of optional data blocks of a certain abstract data set, since the execution delay of the stage is determined by the tasks defined later, greedily selecting the data blocks defined later in the abstract data set can maximize the time saved by caching the data. Based on the above data block-oriented greedy caching strategy, the computational complexity of the cache benefit changes from the exponential level to the linear level, and Problem C4 can be converted into Problem C5. Furthermore,

[0036] It is proved that problem C5 is a variant of the bounded knapsack problem.

[0037] In step (4), the fine-grained cache algorithm based on dynamic programming has the following characteristics: the fine-grained cache replacement problem C5 after the data processing feature conversion is a variant of the bounded knapsack problem. Since problem C5 has an optimal substructure, the algorithm consists of a preprocessing module based on data processing features and a fine-grained cache replacement module based on dynamic programming. The specific contents are as follows:

[0038] (41) Preprocessing module based on data processing characteristics: This module accepts the parameter job set J, the data blocks already in the cache space at time t and data block b to be added to the cache space at time t t Through the computational features of data processing operators and the problem transformation steps based on the greedy caching strategy of data blocks, the module returns the grouped set of data blocks to be cached x t and its cache benefit V; then, the module uses the above return value as the input of the fine-grained cache replacement module based on dynamic programming ideas;

[0039] (42) Fine-grained cache replacement module based on dynamic programming: This module accepts the output of the preprocessing module based on data processing characteristics, that is, the grouped set of cached data blocks x t and its cache benefit V, and combined with the memory upper limit L of the cache space as its input; with each integer in the interval [0, L] and the grouped set of cached data blocks x t The module decomposes problem C5 into multiple sub-problems through dynamic programming to obtain the optimal cache decision.

[0040] In step (5), the calculation complexity of the fine-grained cache replacement algorithm has the following characteristics: the calculation complexity of the algorithm is jointly determined by a pre-processing module based on data processing features and a fine-grained cache replacement module based on the dynamic programming idea; wherein, the former includes two steps, which are respectively based on data processing operator calculation features and based on data block greedy cache strategy problem conversion steps; in the problem conversion step based on data processing operator calculation features, the two contents of calculating the "job critical path" and analyzing the "hot access data" have little influence because they only need to be executed once before the start of the big data processing application; therefore, the key point of this step is to count the "stage representative data"; in addition, the problem conversion step based on the data block greedy cache strategy is similar to the function of counting the "stage representative data" and is also critical; finally, the calculation complexity of the fine-grained cache replacement module based on the dynamic programming idea is determined by the search space of the dynamic programming algorithm, which is directly related to the size of the data block to be cached and the upper limit of the memory of the cache space.

[0041] Due to the limited memory resources, there is a trade-off problem in using memory resources for cache acceleration in big data processing applications. The existing related researches do not consider the influence of computing resources on the cache process, so they only study the operator-level cache replacement problem. In order to fill the gap in the research of cache replacement in the computing resource limited scenario, the present application considers the influence of computing resources on the cache process in big data processing applications in this scenario. It is found that in the scenario of limited computing resources, the big data processing framework will schedule the tasks in the application, and under the influence of the scheduling strategy, only caching part of the data block of an abstract data set can reduce the execution time of the stage where the data is located, thereby speeding up the execution of the data processing application. Therefore, the present application studies the fine-grained cache replacement problem in the computing resource limited scenario, which sets the cache object as a data block and dynamically decides to cache the data during the execution of the data processing application. Compared with the coarse-grained operator-level cache replacement problem, the fine-grained data block-level cache problem is more difficult. Therefore, the present application uses the calculation features based on data processing operators and the greedy cache strategy for data blocks to convert the modeled cache replacement problem into a variant of the classic NP-complete problem. Since the simplified problem has optimal substructure, the present application designs a fine-grained cache replacement algorithm based on the dynamic programming idea to solve the problem.

[0042] The present application has the beneficial effects that: by analyzing the relationship between computing resources and cache granularity, a fine-grained cache replacement algorithm is proposed in the computing resource limited scenario, which greatly reduces the completion time of big data processing applications and improves the cache hit rate of the cache process. BRIEF DESCRIPTION OF DRAWINGS

[0043] Figure 1 is the algorithm flowchart of the present application.

[0044] Figure 2is a fine-grained cache replacement problem example graph in the specific implementation;

[0045] Figure 3 is a problem conversion schematic diagram based on data processing operator calculation features in the specific implementation;

[0046] Figure 4 is a problem conversion schematic diagram based on data block greedy cache strategy in the specific implementation;

[0047] Figure 5 is a fine-grained algorithm flow chart based on the dynamic programming idea in the specific implementation. DETAILED DESCRIPTION

[0048] A fine-grained cache replacement algorithm for big data processing under the condition of limited computing resources, first establishes a mathematical model for the parallel execution mode in the multi-task parallel big data processing application, and then considers the influence of computing resources on the cache process under the condition of limited computing resources, and proposes a data block level fine-grained cache replacement algorithm. Figure 1 is the algorithm flow chart of the present application.

[0049] 1. Analyze the influence of computing resources on the cache process.

[0050] (1) When the computing resources are sufficient, the starting execution time and the ending time of multiple tasks in the same big data processing stage are the same. At this time, only caching part of the data blocks of the abstract data set can only reduce the execution time of part of the tasks in the stage, and cannot reduce the overall execution time delay of the stage, so it cannot speed up the execution of the data processing application. In this scenario, when caching data, either do not cache a certain abstract data set, or cache all data blocks of the abstract data set. Since the abstract data set corresponds to the calculation result of the data processing operator, we should consider the operator-level cache replacement algorithm when the computing resources are sufficient.

[0051] (2) When the computing resources are limited, the data block level cache replacement algorithm should be considered: in the computing resource limited scenario, the system will schedule the tasks according to the computing resource requirements of the tasks. The starting execution time of multiple tasks in the same stage is different, which leads to the difference in the ending time. At this time, only caching part of the data blocks of the abstract data set can also speed up the execution of the data processing application. In this scenario, due to the influence of task scheduling, the data block level cache replacement algorithm should be considered, because the algorithm has a finer granularity than the operator level cache replacement algorithm, and has a larger optimization space.

[0052] Based on the connection between computing resources and cache granularity, this paper summarizes the impact of computing resources on the caching process as requiring fine-grained cache replacement in scenarios with limited computing resources. Since prior work has considered the coarse-grained cache replacement problem for operators in scenarios with abundant computing resources, this paper addresses the gap in cache replacement research in resource-constrained scenarios by considering the impact of computing resources on the caching process in big data processing applications and proposing a fine-grained cache replacement algorithm at the data block level.

[0053] 2. Establish a mathematical model for the fine-grained cache replacement problem.

[0054] The mathematical model for the fine-grained cache replacement problem includes a formal description of computing resources, data blocks to be cached, task execution latency, stage execution latency, job execution latency, and the cache replacement problem. The main steps are as follows:

[0055] (1) Computing resource modeling: This paper observes that the impact of computing resources on cache issues comes from the task start time determined by the scheduling algorithm. This paper abstracts the scheduling algorithm and only focuses on the scheduling results in the scenario of limited computing resources - the task start time {t i,j,k}, in order to consider the impact of computing resources on the caching process. The relevant symbols are shown in Table 1.

[0056] Symbol Definition [CAT i,j,k ]]> Task T i,j,k the start time (provided by the task scheduling algorithm) of the task T [CAT i,j,k ]]> Application mid-phase S i,j kth task of the application [SA i,j ]] Application job J i jth stage of the application J i ]]> Job executed in the application i

[0057] Table 1. Symbols related to computing resource modeling

[0058] (2) Modeling of data blocks to be cached: Tables 1 and 2 show the relevant symbol tables, which are used to formalize the description of the cache option range and cache benefit of the data blocks to be cached.

[0059] a) For a certain big data processing application, the present invention assumes that at each time t, data block b t When the calculation is completed, we need to decide the cache space to consider data block b t After that, the data block collection should be put This set does not consider b in the cache space at time t t The set of previously cached data blocks

[0060] The relationship should satisfy the following formula:

[0061]

[0062] b) For each task T i,j,k The present invention defines the calculation time of the data block b in the embodiment of the present invention as follows:

[0063] λ(b,T i,j,k) and cache benefit (the time saved by caching the data block) - δ(b, T i,j,k ). To describe the task execution latency under different data block caching conditions, and to provide guidance information for cache decision. The relationship between the computation time of data block and the cache benefit is shown as follows:

[0064]

[0065]

[0066] Table 2. Symbol table related to the modeling of data blocks to be cached

[0067] (3) Task execution latency modeling: In each task of the application, there is a data block that is not dependent on any other data block in the task, which is called the final computation data block of the task. On this basis, the execution latency of the task can be associated with the final computation data block of the task. The execution latency of task T i,j,k under the cache data block set CS is equal to the time difference between the end time of the final computation data block i,j,k in task T and the start time of task T i,j,k , which is formally expressed as The related symbols are shown in Tables 1-3, and the recursive function k(T i,j,k , b i,j,k,q , CS) is used to model the multi-data block parallel computation phenomenon within the task, which is formally described as shown below:

[0068]

[0069]

[0070]

[0071] Table 3. Symbol table related to the modeling of task execution latency

[0072] (4) Stage execution latency modeling: The present application models the stage execution latency through the related symbols in Tables 1-4. The stage execution latency can be associated with the start time and execution time of the tasks within the stage. The execution latency of stage S i,j under the cache data block set CS is equal to the time difference between the end execution time of the largest task in the stage and the start time of the smallest task in the stage, which is formally expressed as Γ(S i,j , CS), as shown below:

[0073]

[0074] Symbol Definition [R i,j ]]> Application mid-phase S i,j Number of tasks included [["Γ(S i,j , CS)"]] i,j time required for execution ​

[0075] Table 4. Symbol table related to stage execution latency modeling

[0076] (5) Job execution latency modeling: In the case of caching different data blocks, the present application models the job execution latency by the related symbols in Table 1-Table 5. First, we associate the job execution latency with the final execution stage of the job, and the job J i execution latency under the caching data block set CS is equal to the difference between the completion time of the stage and the start execution time of the job J i , which is formally expressed as where the recursive function Z(S i,j , CS) is used to model the multi-stage parallel execution phenomenon within the job, which is formally described as

[0077] as follows:

[0078]

[0079]

[0080] Table 5. Symbol table related to job execution latency modeling

[0081] (6) Modeling of fine-grained cache replacement problem

[0082] Problem description: In the scenario of limited computing resources, based on the modeling of computing resources, data blocks, tasks, stages, and jobs in the caching process of big data processing applications, the present application models the fine-grained cache replacement problem at the data block level by the related symbols in Table 1-Table 6. For a certain big data processing application, assume that the data block b t is computed at time t, and the job using the data block b t at time t is the p t th job of the big data processing application. Then, under the scenario of limited computing resources, the data block level cache replacement problem C1 facing the data processing application can be expressed as deciding the data block set to be stored in the cache space at the time t when each data block is computed to minimize the total completion time of the subsequent jobs (including the p t th job) of the application since the p t th job. The formal description of problem C1 is as follows:

[0083]

[0084] Symbol Definition s * (b)]]> Memory size occupied by the data block b L Total memory upper limit of the cache space p t ]]> Index of the job executed at time t

[0085] Table 6. Symbol table related to fine-grained cache replacement problem C1

[0086] Problem input: a directed acyclic graph G=(V, E) abstracted from a big data processing application, a set of start execution time of big data processing tasks {t i,j,k}(the two inputs are used to calculate the job delay), a set of data blocks currently cached in the system at time t Data blocks b to be added to the cache space at time t t The upper limit of the memory of the cache space L.

[0087] Decision variable: the set of data blocks to be cached at time t

[0088] Optimization goal: minimize the overall completion time of the job executed at time t and all subsequent unexecuted jobs, which is formally expressed as The function Z(S i,j , CS) represents the difference between the time when the stage S i of the job J i,j is completed and the start execution time of the job J i , which is calculated from the input data G=(V, E) and {t i,j,k}.

[0089] Problem constraint: the fine-grained cache replacement problem of multi-task parallel big data processing tasks considers the job set and the memory upper limit of the data to be cached in the decision variable and optimization goal, which has the following characteristics:

[0090] 1) At the time t when any data block b t is completed, the decision variable is used to represent the data blocks that should be cached in the cache space at time t. The decision variable has the following constraint relationship:

[0091]

[0092] 2) The optimization goal only considers minimizing the overall completion time of the p t th job of the application and the subsequent unexecuted jobs. The value range of the variable p t does not exceed the total number of data processing jobs in the application, and the variable p t has the following constraint relationship:

[0093]

[0094] It is necessary to ensure that the cached data set in the cache decision does not exceed the memory upper limit of the cache space. The constraint related to the memory upper limit of the data to be cached is as follows:

[0095]

[0096] 3. Transform the cache replacement problem based on data processing characteristics.

[0097] Assuming that the number of stages contained in each job, the number of abstract data sets contained in each stage, and the number of tasks contained in each stage in a big data processing application are all 1, under this assumption, the present invention observes a special case problem of Problem C1: The 0-1 knapsack problem is equivalent to the 0-1 knapsack problem, so it can be reduced to problem C1, which is then proven to be NP-hard. Due to the complexity of the problem, we transform problem C1 based on the computational characteristics of data processing operators and a greedy cache strategy for data blocks to make it easier to solve. The problem transformation steps are as follows:

[0098] (1) In the computational characteristics of data processing operators, the “job critical path” is defined as the computational chain of the longest execution time in the job. Since the latency of the “job critical path” can approximately replace the overall latency of the job, and the stages in the “job critical path” are all executed serially, we define each job J in the application as i Stage collection Replaced with "Activity Critical Path" After that, the stage execution mode changes from parallel to serial, and problem C1 can be transformed into problem C2 as shown below:

[0099]

[0100] (2) In the computational characteristics of the data processing operator, "hotspot access data" is defined as an abstract data set represented by nodes with an out-degree greater than 1 in a directed acyclic graph formed by applying abstraction. Since the cache benefit of "hotspot access data" can approximately replace the cache benefit of all data, and "hotspot access data" can be approximately regarded as serial calculations. Therefore, after replacing the abstract data set calculated in each stage with "hotspot access data", the data calculation mode in the data processing stage changes from parallel to serial. In order to facilitate the formalization of the problem, we replace the "minimizing the overall completion time of the job" in the optimization objective with "maximizing the time saved by caching data". On this basis, problem C2 is converted to problem C3 as shown below:

[0101]

[0102] In Problem C3, the relevant symbols are defined as shown in Table 7. The expression Can be equivalently converted to variable Define the task T′ i,j,k The end time of function and Define the task T′ i,j,kThe set of subscripts of the "hotspot access data block" is as follows:

[0103]

[0104]

[0105]

[0106] Table 7. Fine-grained cache replacement problem C3 related symbol table

[0107] (3) In the computational characteristics of data processing operators, the computational characteristics represented by the final computed data in the data processing stage are

[0108] The present invention observes that the “stage representative calculation” can be used to approximately replace the stage overall calculation. The present invention converts the variable Defined as stage S′ i,j The end execution time of stage S′ i,j The maximum value of the execution time of all tasks in the task list. The function η * (b, CS) is defined as whether the data block b is one of the elements of the data block set CS (1 for yes, 0 for no), and the variable R′ i,j Indicates stage S′ i,j The number of tasks included. Based on this, the present invention replaces the "hotspot access data" in the data processing stage with the execution result of the "stage representative calculation", that is, the "stage representative data", and problem C3 is converted into problem C4, as shown below:

[0109]

[0110] (4) In the computational characteristics of data blocks, tasks defined first in the same stage will be scheduled first, so data blocks defined first in the same abstract dataset will be computed first. Based on this characteristic, given the number of optional data blocks in a certain abstract dataset, since the execution delay of a stage is determined by tasks defined later, greedily selecting data blocks defined later in the abstract dataset can maximize the time saved by caching the data. Based on the above data block-oriented greedy caching strategy, the computational complexity of the caching benefit changes from the exponential level to the linear level, and Problem C4 can be converted to Problem C5 as shown below:

[0111]

[0112] in, It is the function in question C5 Detailed definition, given the variable and z i back, The value is determined. The related symbols are shown in Table 8:

[0113]

[0114] Table 8. Fine-grained cache replacement problem C5 related symbol table In the bounded knapsack problem, it is assumed that there are N kinds of goods and a knapsack with a bearable weight W, the weight, value and maximum number of selected pieces of each kind of goods j are w j , p j and Y j . We use the decision variable y j to represent the number of pieces of each kind of goods j put into the knapsack. Based on this, the objective of the problem is to maximize the total value of the goods put into the knapsack within the range of the knapsack's carrying capacity, which is formally expressed as follows:

[0115]

[0116] We find that the optimization objective of the bounded knapsack problem can be converted into the form of the optimization objective of problem C5

[0117] , that is where the function V'(p j , y j ) = p j x y j . In addition, the constraint conditions of the bounded knapsack problem correspond to the constraint conditions of problem C5, and each kind of goods j corresponds to the i-th abstract data set of the data set of problem C5. Therefore, problem is a variant of the bounded knapsack problem, which is different from the bounded knapsack problem in that the function

[0118] 4. Design a fine-grained cache replacement algorithm based on the dynamic programming idea.

[0119] Based on the data processing feature conversion, the fine-grained cache replacement problem C5 is a variant of the bounded knapsack problem. Since problem C5 has an optimal substructure, the present application designs a fine-grained cache replacement algorithm based on the dynamic programming idea. The algorithm consists of a pre-processing module based on data processing features and a fine-grained cache replacement module based on the dynamic programming idea, and the specific content is as follows:

[0120] (1) Pre-processing module based on data processing features: This module accepts parameters job set J, data block set already in the cache space at time t and data block b tThrough the problem transformation steps based on data processing operator calculation features and data block greedy caching strategy, the module returns the grouped data block set x to be cached t and its cache benefit V. Then, this module uses the above return value as the input of the fine-grained cache replacement module based on dynamic programming ideas. The specific steps are as follows:

[0121] A. Accept input J, and b t

[0122] B. Initialize the "stage representative data block" x' and the cache benefit V of the data block to be cached

[0123] C. According to the collection The data blocks are classified according to the category of the abstract data set to which the data blocks belong, and the grouped data blocks to be cached are obtained. t

[0124] D. Calculate J's "critical path" CP using the longest path algorithm

[0125] E. Statistics of "hotspot access data" HD based on the directed acyclic graph represented by J

[0126] F. Count the unfinished jobs J in the job set J at time t t

[0127] G. vs. J t Each job J i The unfinished phase S' that belongs to CP i,j Do the following

[0128] a) Statistical stage S' i,j The topological sequence TP of all data in

[0129] b) Get the sequence TP∩(CS old,t ∪{x t})∩The last element x of HD u

[0130] c) Update x': x'←x'∪{x u}

[0131] H. to x t Each abstract dataset contains a set of data blocks Do the following

[0132] a) Get J t Each job J i Each stage S' that has not been completed and belongs to CP i,j

[0133] b) From k = 1 to The cache benefit V of the data block to be cached is updated cyclically: V i,k ← V i,k + In stage S i ' ,j The cache benefit V of the data block to be cached is updated cyclically: V The cache benefit V of the data block to be cached is updated cyclically: V

[0134] I. Output the grouped data block set x t and its cache benefit V

[0135] (2) Fine-grained cache replacement module based on dynamic programming idea: This module accepts the output of the preprocessing module, that is, the grouped data block set x t and its cache benefit V, and combines the memory upper limit L of the cache space as its input. With the traversal of each integer in the interval [0, L] and each element in the grouped data block set x t , this module decomposes the problem C5 into multiple sub-problems through dynamic programming, and obtains the optimal cache decision

[0136] from The specific steps are as follows:

[0137] A. Accept input: grouped data block set x t , cache benefit V of data block to be cached, and memory upper limit L of cache space

[0138] B. Initialize dynamic programming array dp, sub-problem optimal result set C, and the number N of abstract data set categories in x t

[0139] C. From i = 1 to N, j = 1 to L, cyclically execute the following operations

[0140] a) Initialize the number of data blocks cached in each category of abstract data set c to 0, and variable dp i,j to 1

[0141] b) From k = 1 to , cyclically execute the following operations

[0142] i. k ← k + 1

[0143] ii. If , execute the following operations:

[0144] c ← k

[0145] c) If c == 0, execute the following operations:

[0146] C i,j ← C i-1,j

[0147] d) Otherwise, perform the following operations:

[0148]

[0149] D. Output the optimal cache decision: C N,L

[0150] 5. Analyze the computational complexity of the fine-grained cache replacement algorithm.

[0151] The computational complexity of the data block-level cache replacement algorithm based on the dynamic programming idea is jointly determined by the pre-processing module based on data processing characteristics and the fine-grained cache replacement module based on the dynamic programming idea. Assuming that the number of "hot access data" in a large data processing application is |V|, the total number of data blocks it contains is |B|, and the upper limit of the cache space memory is L. It is easy to know that the pre-processing module based on data processing characteristics contains two steps, namely the data processing operator calculation characteristic based step and the problem conversion step based on the data block greedy cache strategy. The computational complexity of the former is O(|V| 2 ), and the latter is O(|B| 2 ). The computational complexity of the fine-grained cache replacement module based on the dynamic programming idea is determined by the search space of the dynamic programming algorithm, which is O(|B| 2 ×L). Therefore, the computational complexity of the data block-level fine-grained cache replacement algorithm in the computing resource limited scenario is O(|B| 2 ×L).

[0152] The application will be further described below in conjunction with examples and drawings. The application is a fine-grained cache replacement problem research for a large data processing framework in a computing resource limited scenario. As shown in Figure 2 the left side of the figure, the directed acyclic graph abstracted from the large data processing application contains hierarchical information composed of applications, jobs, stages, tasks, data, and data blocks, and the computing resource requirements of the tasks. When the computing resources are limited, the system will schedule the tasks according to the computing resource requirements of the tasks, and output the task scheduling result on the right side. In Figure 2 the example, the total number of CPU cores of the system is 11, and the CPU core number and execution time required by the task are marked in the directed acyclic graph. Through the Dagon scheduling algorithm, Figure 2 the task scheduling result of the large data processing job is shown on the right side. In the figure, the horizontal axis is the time line, and the vertical axis is the computing resource. The rectangle with a label like "SAB" represents the Bth task of stage A of the data processing stage, and the length of the rectangle represents the duration and the width represents the CPU core number required by the task. For example, the starting execution time of the first task "S531" of stage 53 is 0, and the starting execution time of the other tasks is calculated in the same way.

[0153] Figure 2The mathematical modeling of the fine-grained cache replacement problem is also demonstrated. We find that when an application is executed, the big data processing framework stores the intermediate data blocks generated at runtime into the cache space to accelerate the execution of the application. There is a trade-off problem in using limited memory to perform cache acceleration. For example, in Figure 2 the third task of stage 56 is executed, the third data block (F3) of abstract data set F is calculated and needs to be cached, if the cache space is about to be exhausted at this time, the data that should be stored in the cache space needs to be decided. In Figure 2 the present application first introduces the task start execution time in the form of task scheduling, and models the computing resources in the cache replacement problem. Then, through the data processing mode contained in the directed acyclic graph G=(V, E) abstracted from the big data processing application, the execution delay of the big data processing application, job, stage and task, and the data block to be cached are modeled. On this basis, the fine-grained cache replacement problem is defined as: at the moment t when each data block b t is calculated, the decision of the data block set to be cached at this moment is made so as to minimize the overall execution delay of the data processing job in which the data block b t is located and all subsequent jobs.

[0154] Since the modeled cache replacement problem C1 is an NP difficult problem, based on the above directed acyclic graph, the present application converts the problem based on the computing characteristics of the data processing operator: "job critical path", "hot access data" and "stage representative calculation". Figure 3 The specific content of "job critical path", "hot access data" and "stage representative calculation" is demonstrated. On this basis, Figure 4 the details of the problem conversion based on the data block greedy caching strategy are demonstrated. Given the number of optional data blocks in a certain abstract data set, since the execution delay of the stage is determined by the later defined task, the greedy selection of the later defined data block in the abstract data set can maximize the time saved by caching the data. Based on the above problem conversion idea related to the data processing characteristics, the original problem is converted into a variant of the bounded knapsack problem.

[0155] The simplified problem has an optimal substructure, Figure 5 The fine-grained cache replacement algorithm based on the dynamic programming idea is demonstrated. After the preprocessing step based on the data processing characteristics, the algorithm accepts the grouped data block set to be cached x t and its cache benefit V, while combining the memory upper limit L of the cache space as its input. With each value of the memory upper limit L of the cache space and the grouped data block set to be cached x tDuring the traversal of each data block, the module decomposes the cache replacement problem into multiple sub-problems by dynamic programming, thereby obtaining the optimal cache decision CS of the problem C5 new,t .

[0156] Due to limited memory resources, there is a trade-off problem in using memory resources for cache acceleration in big data processing applications. Existing related researches do not consider the influence of computing resources on the cache process, so they only study the operator-level cache replacement problem. In order to fill the gap in the research of cache replacement in the scenario of limited computing resources, the present application considers the influence of computing resources on the cache process in big data processing applications in this scenario. The present application finds that in the scenario of limited computing resources, the big data processing framework will schedule the tasks in the application, and under the influence of the scheduling strategy, only caching part of the data blocks of an abstract data set can reduce the execution time of the stage where the data is located, thereby accelerating the execution of the data processing application. Therefore, the present application studies the fine-grained cache replacement problem in the scenario of limited computing resources, which sets the cache object as a data block and dynamically decides the data to be cached during the execution of the data processing application. Compared with the coarse-grained operator-level cache replacement problem, the fine-grained data block-level cache problem is more difficult. Therefore, the present application uses the computing characteristics based on data processing operators and the data block-oriented greedy cache strategy to convert the modeled cache replacement problem into a variant of the classic NP-complete problem. Since the simplified problem has optimal substructure, the present application designs a fine-grained cache replacement algorithm based on the dynamic programming idea to solve the problem.

[0157] The above detailed the embodiments of the present application, but the present application is not limited to the specific details in the above embodiments, and various equivalent transformations can be made to the technical solutions of the present application within the technical concept range of the present application, and these equivalent transformations all belong to the protection range of the present application.

Claims

1. A fine-grained cache replacement algorithm for big data processing under limited computing resources, characterized by: First, a mathematical model is established for the parallel execution mode in multi-task parallel big data processing applications. Then, considering the impact of computing resources on the caching process in computing resource-constrained scenarios, a fine-grained cache replacement algorithm at the data block level is proposed, which includes the following steps: (1) Analyze the impact of computing resources on the caching process: In the cache replacement problem for big data processing systems, the relationship between computing resources and cache granularity is obtained. The specific summary is: when computing resources are sufficient, caching only part of the data blocks of the abstract dataset cannot accelerate the data processing process. In this case, the cache object is set to the abstract dataset and a coarse-grained cache replacement algorithm is considered; when computing resources are limited, caching only part of the data blocks of the abstract dataset can speed up the execution of the data processing application. In this case, the cache object is set to the memory data block and a fine-grained cache replacement algorithm is considered; (2) Establish a mathematical model for the fine-grained cache replacement problem: First, we model the computing resources in the cache replacement problem in the form of task scheduling. Then, we use the data processing pattern implied by the directed acyclic graph G = (V, E) abstracted from the big data processing application to model the execution delay and cached data blocks of the application, job, stage, and task in typical big data processing. On this basis, the fine-grained cache replacement problem is defined as: at each data block b t The time t at which the calculation is completed is used to determine the set of data blocks to be cached at that time. Thus minimizing the data block b t The overall execution latency of the data processing job and all subsequent jobs; (3) Transforming the cache replacement problem based on big data processing characteristics: Since the fine-grained cache replacement problem in scenarios with limited computing resources is an NP-hard problem, the modeled cache replacement problem is transformed into a variant of the classic NP-complete problem based on the computational characteristics of big data processing operators and a greedy caching strategy for data blocks. (4) Design a fine-grained cache replacement algorithm based on dynamic programming: Based on the computational characteristics of operators and a greedy cache strategy for data blocks, the problem is transformed into a variant of the bounded knapsack problem; The algorithm consists of two modules: a preprocessing module based on data processing characteristics and a fine-grained cache replacement module based on dynamic programming. The former includes a problem transformation step based on operator computation characteristics and a problem transformation step based on a data block greedy cache strategy. (5) Analysis of the computational complexity of the fine-grained cache replacement algorithm: The computational complexity of the data block-level cache replacement algorithm based on dynamic programming is determined by the three modules it contains, which is related to the total number of data blocks |B| and the memory upper limit L of the cache space in big data processing applications. The computational complexity of the fine-grained cache replacement algorithm is O(|B| 2 ×L).

2. The fine-grained cache replacement algorithm for big data processing under limited computing resources according to claim 1 is characterized by: In step (1), the impact of computing resources on the caching process includes the following characteristics: (11) When computing resources are sufficient, consider the operator-level cache replacement algorithm: In the scenario of sufficient computing resources, the start and end times of multiple data processing tasks in the same data processing stage are the same; in this case, caching only some data blocks of the abstract data set can only reduce the execution time of some tasks in the stage, but cannot reduce the overall execution latency of the stage, and therefore cannot accelerate the execution of data processing applications; In this scenario, when caching data, either no abstract dataset is cached, or all data blocks of the abstract dataset are cached. Since the abstract dataset corresponds to the calculation results of the data processing operator, an operator-level cache replacement algorithm is considered when computing resources are sufficient. (12) When computing resources are limited, a data block-level cache replacement algorithm should be considered: In a scenario where computing resources are limited, the system will schedule tasks based on their computing resource requirements; the start execution times of multiple tasks in the same stage are different, resulting in different end times; at this time, caching only part of the data blocks of the abstract data set can also speed up the execution of data processing applications; in this scenario, due to the influence of task scheduling, a data block-level cache replacement algorithm should be considered, because this algorithm has a finer granularity than the operator-level cache replacement algorithm and has greater room for optimization.

3. The fine-grained cache replacement algorithm for large data processing under limited computing resources according to claim 1, characterized in that: In step (2), the mathematical model of the fine-grained cache replacement problem for multi-task parallel big data processing applications has the following characteristics: (21) Problem description: In a certain big data processing application, there are a large number of data blocks in the calculation process, and the data blocks are defined as b i,j,k,q ; At time t, when data block b t When the calculation is completed, the big data processing system decides whether to cache the data block based on the current cache status, and replaces the cached data block when the cache space is about to overflow; during the execution of the big data processing application, each replacement of the cached data block is equivalent to deciding the current cached data block. This decision problem is defined as a fine-grained cache replacement problem for multi-task parallel big data processing applications; (22) Problem input: Directed acyclic graph G = (V, E) abstracted from big data processing applications, the set of starting execution times of big data processing tasks {t i,j,k }, at time t the system currently has a cached set of data blocks Data block b to be added to the cache space at time t t , the memory upper limit L of the cache space; (23) Decision variable: the set of data blocks to be cached at time t (24) Optimization goal: Minimize the overall completion time of the job executed at time t, that is, all subsequent unexecuted jobs, formally expressed as The variable p t represents the subscript of the job executed at time t, the variable |J| is the job set of the big data processing application, and the variable S i,j represents the i-th executed job J in the application i The jth executed data processing stage, variable M i The i-th executed job J in the application i The number of stages included, function Z(S i,j ,CS) means that in the case of cache data block set CS, job J i Middle stage S i,j Calculate the time and job J to complete i The difference between the execution start time and the input data G = (V, E) and {t i,j,k }Calculated; (25) Constraints: The fine-grained cache replacement problem for big data processing applications has constraints on the decision variables, the set of jobs considered in the optimization objective, and the upper limit of the memory for the data to be cached, and has the following characteristics: a) In any data block b t At the time t when the calculation is completed, use the decision variable Indicates the data block that should be cached in the cache space at time t; assuming Indicates that data block b is not considered at time t t When the cached data in the cache space, the variable T * The set of times when all data blocks in a data processing application have been calculated; decision variables There are the following constraints: b) The optimization goal is to only consider minimizing the pth application t The overall completion time of the job and subsequent unexecuted jobs, variable p t The value range of does not exceed the total number of data processing jobs in the application. The constraints are as follows: c) Ensure that the cached data set in the cache decision does not exceed the memory limit of the cache space; among them, function s * (b) represents the memory space occupied by data block b, which is provided by the directed acyclic graph G = (V, E) abstracted from the big data processing application. The variable L represents the memory upper limit of the cache space. The constraints related to the memory upper limit of the data to be cached are as follows:

4. The fine-grained cache replacement algorithm for large data processing under limited computing resources according to claim 1, characterized in that: In step (3), the conversion process of the cache replacement problem based on the characteristics of big data processing has the following characteristics: the fine-grained cache replacement problem for multi-task parallel big data processing applications is defined as C1. Assuming that the number of stages contained in each job in the big data processing application, the number of abstract data sets contained in each stage, and the number of tasks contained in each stage are all 1, the special case of problem C1 under this assumption is defined as problem question Equivalent to the 0-1 knapsack problem, the 0-1 knapsack problem is reduced to problem C1, which further proves that the fine-grained cache replacement problem for big data processing applications is NP-hard. Due to the complexity of the problem, problem C1 is transformed based on the computational characteristics of data processing operators and a greedy cache strategy for data blocks to make it easier to solve. The problem transformation steps are as follows: (31) In the computational characteristics of data processing operators, since the latency of the “job critical path” can approximately replace the overall latency of the job, and the stages in the “job critical path” are all executed serially, after replacing all stages of each job in the application with the “job critical path”, the execution mode of the data processing stage changes from parallel to serial, and problem C1 can be converted to problem C2. (32) In the computational characteristics of data processing operators, since the cache benefits of “hotspot access data” can approximately replace the cache benefits of all data, and “hotspot access data” can be approximately regarded as serial computations, after replacing the abstract data set computed in each stage with “hotspot access data”, the data computation mode in the data processing stage changes from parallel to serial, and problem C2 is converted to problem C3. (33) In the computational characteristics of data processing operators, the operator represented by the data finally computed in the data processing stage is called "stage representative computation"; "stage representative computation" can approximately replace the overall computation of the stage; therefore, after replacing the "hotspot access data" in each data processing stage with the execution result of the "stage representative computation", i.e., "stage representative data", problem C3 is transformed into problem C4; (34) In the computational characteristics of data blocks, the tasks that are defined first in the same stage will be scheduled first, so the data blocks that are defined first in the same abstract data set will be computed first. Based on this characteristic, given the number of optional data blocks of a certain abstract data set, since the execution delay of the stage is determined by the tasks that are defined later, greedily selecting the data blocks that are defined later in the abstract data set can maximize the time saved by caching the data. Based on the above data block-oriented greedy caching strategy, the computational complexity of the cache benefit changes from the exponential level to the linear level, and Problem C4 can be converted into Problem C5. Furthermore, it is proved that Problem C5 is a variant of the bounded knapsack problem.

5. The fine-grained cache replacement algorithm for large data processing under limited computing resources according to claim 1, characterized in that: In step (4), the fine-grained cache algorithm based on dynamic programming has the following characteristics: the fine-grained cache replacement problem C5 after the data processing feature conversion is a variant of the bounded knapsack problem. Since problem C5 has an optimal substructure, the algorithm consists of a preprocessing module based on data processing features and a fine-grained cache replacement module based on dynamic programming. The specific contents are as follows: (41) Preprocessing module based on data processing characteristics: This module accepts the parameter job set J, the data blocks already in the cache space at time t and data block b to be added to the cache space at time t t Through the computational features of data processing operators and the problem transformation steps based on the greedy caching strategy of data blocks, the module returns the grouped set of data blocks to be cached x t and its cache benefit V; then, the module uses the above return value as the input of the fine-grained cache replacement module based on dynamic programming ideas; (42) Fine-grained cache replacement module based on dynamic programming: This module accepts the output of the preprocessing module based on data processing characteristics, that is, the grouped set of cached data blocks x t and its cache benefit V, combined with the memory upper limit L of the cache space as its input; With each integer in the interval [0, L] and the grouped set of cached data blocks x t The module decomposes problem C5 into multiple sub-problems through dynamic programming to obtain the optimal cache decision.

6. The fine-grained cache replacement algorithm for large data processing under limited computing resources according to claim 1, characterized in that: In step (5), the computational complexity of the fine-grained cache replacement algorithm has the following characteristics: the computational complexity of the algorithm is jointly determined by the preprocessing module based on data processing characteristics and the fine-grained cache replacement module based on dynamic programming ideas; the former includes two steps, namely, the problem conversion step based on the computational characteristics of the data processing operator and the problem conversion step based on the data block greedy caching strategy; in the problem conversion step based on the computational characteristics of the data processing operator, the two contents of calculating the "job critical path" and analyzing the "hotspot access data" have little impact because they only need to be executed once before the start of the big data processing application; therefore, the key point of this step is to count the "stage representative data"; in addition, the problem conversion step based on the data block greedy caching strategy has a similar function to the counting of the "stage representative data" and is also more critical; finally, the computational complexity of the fine-grained cache replacement module based on dynamic programming ideas is determined by the search space of the dynamic programming algorithm, and is directly related to the size of the data blocks to be cached and the memory upper limit of the cache space.

Images