# Information Freshness in Cache Updating Systems

We consider a cache updating system with a source, a cache and a user. There are n files. The source keeps the freshest version of the files which are updated with known rates λ_i. The cache downloads and keeps the freshest version of the files from the source with rates c_i. The user gets updates from the cache with rates u_i. When the user gets an update, it either gets a fresh update from the cache or the file at the cache becomes outdated by a file update at the source. We find an analytical expression for the average freshness of the files at the user. Next, we generalize our setting to the case where there are multiple caches in between the source and the user, and find the average freshness at the user. We provide an alternating maximization based method to find the update rates for the cache(s), c_i, and for the user, u_i, to maximize the freshness of the files at the user. We observe that for a given set of update rates for the user (resp. for the cache), the optimal rate allocation policy for the cache (resp. for the user) is a thresholdpolicy, where the optimal update rates for rapidly changing files at the source may be equal to zero. Finally, we consider a system where multiple users are connected to a single cache and find update rates for the cache and the users to maximize the total freshness over all users.

## Authors

• 16 publications
• 71 publications
• ### Information Freshness in Cache Updating Systems with Limited Cache Storage Capacity

We consider a cache updating system with a source, a cache with limited ...
05/20/2020 ∙ by Melih Bastopcu, et al. ∙ 0

• ### Freshness Based Cache Updating in Parallel Relay Networks

We consider a system consisting of a server, which receives updates for ...
05/11/2021 ∙ by Priyanka Kaswan, et al. ∙ 0

• ### Freshness-Optimal Caching for Information Updating Systems with Limited Cache Storage Capacity

In this paper, we investigate a cache updating system with a server cont...
12/28/2020 ∙ by Haibin Xie, et al. ∙ 0

• ### Age of Information Aware Cache Updating with File- and Age-Dependent Update Durations

We consider a system consisting of a library of time-varying files, a se...
09/12/2019 ∙ by Haoyue Tang, et al. ∙ 0

• ### Cache Updating Strategy Minimizing the Age of Information with Time-Varying Files' Popularities

10/09/2020 ∙ by Haoyue Tang, et al. ∙ 0

• ### MathPSfrag 2: Convenient LaTeX Labels in Mathematica

This article introduces the next version of MathPSfrag. MathPSfrag is a ...
01/15/2008 ∙ by Johannes Große, et al. ∙ 0

• ### Lightweight Container-based User Environment

Modern operating systems all support multi-users that users could share ...
12/09/2019 ∙ by Wenzhe Zhang, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## I Introduction

With emerging technologies such as autonomous driving, augmented reality, social networking, high-frequency automated trading, and online gaming, time sensitive information has become ever more critical. Age of information has been proposed as a performance metric to quantify the freshness of information in communication networks. Age of information has been studied in the context of web crawling [1, 2, 3, 4], social networks [5], queueing networks [6, 7, 8, 9, 10, 11, 12, 13, 14, 15], caching systems [16, 17, 18, 19, 20, 21, 22]

, remote estimation

[23, 24, 25, 26], energy harvesting systems [27, 28, 29, 30, 31, 32, 33, 34, 35], fading wireless channels [36, 37], scheduling in networks [38, 39, 40, 41, 42, 43, 44, 45, 46], multi-hop multicast networks [47, 48, 49, 50], lossless and lossy source coding [51, 52, 53, 54, 55], computation-intensive systems [56, 57, 58, 59, 60, 61], vehicular, IoT and UAV systems [62, 63, 64][65, 66, 67], and so on.

In this work, we consider a cache updating system that consists of a source, cache(s) and user(s). We start with the simplest system model shown in Fig. 2 with a source, a single cache and a single end-user; generalize it to the case where there are multiple caches in between the source and the user as shown in Fig. 4; and further extend it to the case where there are multiple end-users as shown in Fig. 6. The models we study are abstractions of a real-life setting shown in Fig. 1. Specifically, the two-hop serial cache system in Fig. 2 is an abstraction for the communication system between the cloud, macro base station and user in Fig. 1; the multi-hop serial cache system in Fig. 4 is an abstraction for the communication system between the cloud, macro base station, small-cell base station and user in Fig. 1 (for a three-hop system); and the multi-access caching system in Fig. 6 is an abstraction for the communication system between the cloud, macro base station, small-cell base station and users and in Fig. 1.

In all these system models, the source keeps the freshest version of all the files which are updated with known rates . The cache downloads the files from the source and stores the latest downloaded versions of these files. When the cache downloads a file from the source, the file at the cache becomes fresh. After that, either the user gets the fresh file from the cache or the file at the cache becomes outdated due to a file update at the source. Thus, depending on the file status at the cache, the user may get a fresh or an outdated file. For all these system models, we derive analytical expressions for the information freshness at the end-users, and determine the updating frequencies for the intermediate caches and the end-users for maximum freshness.

References that are most closely related to our work are [4, 17]. Reference [4] studies the problem of finding optimal crawl rates to keep the information in a search engine fresh while maintaining the constraints on crawling rates imposed by the websites and also the total crawl rate constraint of the search engine. Even though the freshness metric used in [4] is similar to ours, the problem settings are different where we develop a general freshness expression for a multi-hop multi-user caching system, which differentiates our overall work from [4]. Reference [17] considers a similar model to ours where a resource constrained remote server wants to keep the items at a local cache as fresh as possible. Reference [17] shows that the update rates of the files should be chosen proportional to the square roots of their popularity indices. Different from [17] where the freshness of the local cache is considered, we consider the freshness at the user which is connected to the source via a single cache or multiple caches. Thus, our system model can be thought of as an extended version of the one-hop model in [17]. However, our freshness metric is different than the traditional age metric used in [17], and hence, the overall work in this paper is distinct compared to [17].

In this paper, we first consider a system where there is a source, a cache and a user (Fig. 2). We find an analytical expression for the average freshness of the files at the user. We then generalize our result to find the average freshness for the end-user when multiple caches are placed in between the source and the user (Fig. 4). We impose total update rate constraints for the caches and also for the user due to limited nature of resources. Our aim is to find the update rates for the cache(s) and also for the user such that the total freshness of the files at the user is maximized. We find that the average freshness of the user is a concave function of the update rates of the caches and of the user individually, but not jointly. We provide an alternating maximization based solution where the update rates of the user (resp. of the cache) are optimized for a given set of update rates of the cache (resp. of the user). We observe that for a given set of parameters, such as update rates of the user, the optimal rate allocation policy for the other set of parameters, such as update rates at the caches, is a threshold policy, where the files that are updated frequently at the source may not be updated by the corresponding entity. Finally, we consider a system where multiple users are connected to a single cache (Fig. 6) and find update rates for the cache and for the users to maximize the total freshness over all users.

## Ii System Model, Freshness Function and Problem Formulation

We consider a cache updating system where there is an information source, a cache and a user as shown in Fig. 2. The information source keeps the freshest version of files where the th file is updated with exponential inter-arrival times with rate . The file updates at the source are independent of each other. A cache which is capable of storing the latest downloaded versions of all files gets the fresh files from the source. The channel between the source and the cache is assumed to be perfect and the transmission times are negligible. Thus, if the cache requests an update for the th file, it receives the file from the source right away. The inter-update request times of the cache for the th file are exponential with rate . The cache is subject to a total update rate constraint as in [17] as it is resource-constrained, i.e., . The user requests the latest versions of the files stored in the cache. The inter-update request times of the user for the th file are exponential with rate . The channel between the user and the cache is also assumed to be perfect and the transmission times are negligible. Similarly, there is a total update rate constraint for the user, i.e., .

We note that each file at the source is always fresh. However, when a file is updated at the source, the stored versions of the same file at the cache and at the user become outdated. When the cache gets an update for an outdated file, the updated file in the cache becomes fresh again until the next update arrival at the source. When the user requests an update for an outdated file, it might still receive an outdated version if the file at the cache is not fresh. We note that since the cache and the user are unaware of the file updates at the source, they do not know whether they have the freshest versions of the files or not. Thus, they may still request an update even though they have the freshest version of a file.

In order to keep track of the freshness, we define the freshness function of the th file at the cache shown in Fig. 3(a) as,

 fc(i,t)={1,if the ith file is fresh at % time t,0,otherwise. (1)

i.e., the instantaneous freshness function is a binary function taking values of fresh, “”, or not fresh, “”, at any time .

We denote file updates which replace an outdated file with the freshest version of the file as successful updates. We define the time interval between the th and the th successful updates for the th file at the cache as the th update cycle and denote it by . We denote the time duration when the th file at the cache is fresh during the th update cycle as . Then, we define the long term average freshness of the th file at the cache as

 Fc(i)=limT→∞1T∫T0fc(i,t)dt. (2)

Similar to [1], is equal to

 Fc(i)=limT→∞NT(1NN∑j=1Tc(i,j))=E[Tc(i)]E[Ic(i)], (3)

where is the number of update cycles in the time duration .

Similarly, we define as the freshness function of the th file at the user shown in Fig. 3(b). Then, the long term average freshness of the th file at the user is equal to

 Fu(i)=E[Tu(i)]E[Iu(i)]. (4)

Finally, we define as the total freshness over all files at the user as

 Fu=n∑i=1Fu(i). (5)

Our aim is to find the optimal update rates for the cache, , and for the user, , for , such that the total average freshness of the user is maximized while satisfying the constraints on the total update rate for the cache, , and for the user, . Thus, our optimization problem is,

 max{ci,ui} Fu s.t. n∑i=1ci≤C n∑i=1ui≤U ci≥0,ui≥0,i=1,…,n. (6)

In the following section, we find analytical expressions for the long term average freshness of the th file at the cache, , and at the user, , as a function of the update rate at the source , the update rate at the cache , and the update rate at the user . Once we find , this will determine the objective function of (II) via (5).

## Iii Average Freshness Analysis for a Single Cache

In this section, we consider the system model in Fig. 2, where there is a source, a single cache and a user. First, we find an analytical expression for the long term average freshness of the th file at the cache, i.e., in (3

). We note that due to the memoryless property of the exponential distribution,

which is the time duration when the th file at the cache is fresh during the th update cycle is exponentially distributed with parameter . Since are independent and identically distributed (i.i.d.) over , we drop index , and denote a typical as . Thus, we have . Let be the total duration when the th file at the cache is outdated during the th update cycle, i.e., . Note that is also equal to the time passed until the fresh version of the

th file is obtained from the source after the file is outdated at the cache. We denote typical random variables for

and by and , respectively. As the update request times for the cache are exponentially distributed with rate , we have . Thus, we find

 E[Ic(i)]=E[Tc(i)]+E[Wc(i)]=1λi+1ci. (7)

By using (3), we find as

 Fc(i)=cici+λi. (8)

We note that the freshness of the th file at the cache in (8) is an increasing function of the cache update rate , but a decreasing function of the source update rate .

Next, we find an analytical expression for the average freshness of the th file at the user . Similar to , we have due to the memoryless property of the exponential distribution, i.e., after the user gets the fresh file, the remaining time for the next file update at the source is still exponentially distributed with rate . Similarly, we denote the time duration when the th file at the user is outdated during the th update cycle as which is equal to . In order for the user to get fresh updates from the cache, the cache needs to get the fresh update from the source which takes time as discussed earlier. After the file at the cache becomes fresh, either the user gets the fresh update from the cache or the file at the source is updated, and thus the file at the cache becomes outdated again. We denote the earliest time that one of these two cases happens as , i.e., where is the time for the user to obtain a new update from the cache which is exponentially distributed with rate . Thus, is also exponentially distributed with rate . We note that and .

Note that if the user gets the fresh update before the file at the cache becomes outdated which happens with probability

, an update cycle of the th file at the user is completed and thus, is equal to again. However, if the file at the source is updated before the user gets the fresh update from the cache, then this process repeats itself, i.e., the cache initially needs to receive the fresh update which takes another time and so on, until the user receives the fresh update from the cache. Thus, we write as

 Wu(i,j)=K∑k=1Wc(i,k)+Tm(i,k), (9)

where is a geometric random variable with rate . Due to [68, Prob. 9.4.1], and are exponentially distributed with rates and , respectively. We use and to denote the typical random variables for and , respectively. Thus, we have . Since , we get

 E[Iu(i)]=1λi+1ui+ui+λiuici. (10)

Finally, we find as

 Fu(i)=E[Tu(i)]E[Iu(i)]=uiui+λicici+λi. (11)

We note that the freshness of the th file at the user in (11) depends not only on the update rate of the user and file update rate at the source but also the update rate of the cache as the user obtains the fresh update from the cache. We note that is an increasing function of and , but a decreasing function of . We observe that is an individually concave function of and but not jointly concave in and , as and terms appear as a multiplication in (11). If the user was directly connected to the source, its freshness would be equal to , i.e., the first term in (11). However, as the user is connected to the source via the cache, the freshness experienced by the user is equal to the multiplication of the freshness of the cache and the freshness of the user if the user was directly connected to the source. Note that, since the freshness of the user when connected to the source via a cache is smaller than the freshness it would achieve if it was directly connected to the source.

In the following section, we find the average freshness of the caches and of the user for the general case when there are caches connected serially in between the source and the user.

## Iv Average Freshness Analysis for M Caches

In this section, we consider a system where there are caches placed in between the source and the user, as shown in Fig. 4. We denote the th cache’s update rate for the th file as . We define as the th update cycle for the th file at cache for . Similarly, we define (and ) as the time duration when the th file at cache is fresh (and outdated) during the th update cycle, i.e., we have .

Next, we find an analytical expression for the average freshness of the th file at the th cache and at the user . In order to obtain a fresh file at cache , the file at cache needs to be fresh for . Similar to the derivation of in (11), after cache obtains the fresh file, either cache gets the fresh file from cache or the file at the source is updated and the file in all the caches becomes outdated. Thus, we write as

 Wc(r,i,j)=Kr∑ℓ=1Wc(r−1,i,ℓ)+Tm(r,i,ℓ), (12)

where is a geometric random variable with rate and where and are exponentially distributed with rates and , respectively. We note that is also exponentially distributed with rate . Then, given that , we write as

 E[Wc(r,i)|Kr=k]=k(E[Wc(r−1,i)]+1cri+λi). (13)

Then, we find as

 E[Wc(r,i)]=cri+λicriE[Wc(r−1,i)]+1cri, (14)

which is equal to if , and to

 E[Wc(r,i)]=1cri+r−1∑ℓ=11cℓir∏p=ℓ+1cpi+λicpi,r=2,…,m. (15)

Then, by using , we have

 E[Ic(r,i)]=⎧⎨⎩1λi+1c1i,r=1,(1λi+1c1i)∏rℓ=2cℓi+λicℓi,r=2,…,m. (16)

Finally, we find the average freshness for the th file at cache as

 Fc(r,i)=E[Tc(r,i)]E[Ic(r,i)]=r∏ℓ=1cℓicℓi+λi,r=1,…,m. (17)

Similarly, we find as

 E[Iu(i)]=(1λi+1c1i)ui+λiuim∏r=2cri+λicri. (18)

Then, the average freshness of the th file at the user is

 Fu(i)=E[Tu(i)]E[Iu(i)]=uiui+λim∏r=1cricri+λi. (19)

Thus, we observe from (17) that, for the general system, the average freshness experienced by cache for is equal to the multiplication of the freshness of cache with the freshness of cache when cache is directly connected to the source. We observe from (19) that the same structure is valid for the freshness of the user as well. We also note that the average freshness expression in (19) reduces to the expression in (11) found in Section III, when . Finally, as an explicit example of the expression in (19), if we have caches between the source and the user, the freshness at the user is

 Fu(i)=uiui+λic1ic1i+λic2ic2i+λi. (20)

In the following section, we solve the optimization problem in (II) for the system with a single cache by using the freshness expression found in (11) in Section III.

## V Freshness Maximization for a System with a Single Cache

In this section, we consider the optimization problem in (II) for a system with a single cache. Using in (11) and in (5), we rewrite the freshness maximization problem as

 max{ci,ui} n∑i=1uiui+λicici+λi s.t. n∑i=1ci≤C n∑i=1ui≤U ci≥0,ui≥0,i=1,…,n. (21)

We introduce the Lagrangian function [69] for (V) as

 L=−n∑i=1uiui+λicici+λi+β(n∑i=1ci−C)+θ(n∑i=1ui−U)−n∑i=1νici−n∑i=1ηiui, (22)

where , , and . Then, we write the KKT conditions as

 ∂L∂ci =−uiui+λiλi(ci+λi)2+β−νi=0, (23) ∂L∂ui =−cici+λiλi(ui+λi)2+θ−ηi=0, (24)

for all . The complementary slackness conditions are

 β(n∑i=1ci−C) =0, (25) θ(n∑i=1ui−U) =0, (26) νici =0, (27) ηiui =0. (28)

The objective function in (V) is not jointly concave in and since s and s appear as multiplicative terms in the objective function. However, for given s, the objective function in (V) is concave in . Similarly, for given s, the objective function in (V) is concave in . Thus, we apply an alternating maximization based method [70, 71, 72, 73] to find pairs such that (23) and (24) are satisfied for all .

Starting with initial s, we find the optimum update rates for the cache, s, such that the total update rate constraint for the cache, i.e., , and the feasibility of the update rates, i.e., for all , are satisfied. Then, for given s, we find the optimum update rates for the user, s, such that the total update rate constraint for the user, i.e., , and the feasibility of the update rates, i.e., for all , are satisfied. We repeat these steps until the KKT conditions in (23) and (24) are satisfied.

For given s with , we rewrite (23) as

 (ci+λi)2=1β−νiuiλiui+λi (29)

Then, we find as

 ci=1√β−νi√uiλiui+λi−λi, (30)

for all with . If , we have from (27). Thus, we have

 ci=(1√β√uiλiui+λi−λi)+, (31)

for all with , where . Note that requires which also implies that if , then we must have . Thus, for given s, we see that the optimal rate allocation policy for the cache is a threshold policy in which the optimal update rates are equal to zero when the files are updated too frequently at the source, i.e., when the corresponding s are too large.

Next, we solve for s for given s with . We rewrite (24) as

 (ui+λi)2=1θ−ηiciλici+λi. (32)

Then, we find as

 ui=1√θ−ηi√ciλici+λi−λi, (33)

for all with . If , we have from (28). Thus, we have

 ui=(1√θ√ciλici+λi−λi)+. (34)

Similarly, requires which implies that if , then we must have . Thus, for given s, we see that the optimal rate allocation policy for the user is also a threshold policy in which the optimal update rates are equal to zero when the files are updated too frequently at the source, i.e., when the corresponding s are too large.

In the following lemma, we show that if the update rate of the cache (resp. of the user ) is equal to zero for the th file, then the update rate of the user (resp. of the cache ) for the same file must also be equal to zero.

###### Lemma 1

In the optimal policy, if , then we must have ; and vice versa.

Proof:  Assume for contradiction that in the optimal policy, there exist update rates with and . We note that average freshness of this file at the user is equal to zero, i.e., as . We can increase the total freshness of the user by decreasing to zero and increasing one of s with . Thus, we reach a contradiction and in the optimal policy, if , we must have . For the update rates with and , one can similarly show that if , then we must have .

In the following lemma, we show that the total update rate constraints for the cache, i.e., , and for the user, i.e., , must be satisfied with equality.

###### Lemma 2

In the optimal policy, we must have and .

Proof:  Assume for contradiction that in the optimal policy, we have . As the objective function in (V) is an increasing function of , we can increase the total freshness of the user by increasing one of with until the total update rate constraint for the cache is satisfied with equality, i.e., . Thus, we reach a contradiction and in the optimal policy, we must have . By using a similar argument, we can also show that in the optimal policy, we must have .

In the following lemma, we identify a property of the optimal cache update rates for given user update rates . To that end, for given s, let us define s as

 ϕi=1λiuiui+λi. (35)

This lemma will be useful for solving for given using (31).

###### Lemma 3

For given s, if for some , then we have for all with .

Proof:  As we noted earlier, from (31), implies . Thus, if , then we have , which further implies .

Next, we describe the overall solution for the single cache setting. We start with a set of initial s. We obtain from using (35). We will utilize Fig. 5 to describe the steps of the solution visually. We plot in Fig. 5. Note that if then , and vice versa. First, we choose for the files with due to Lemma 1, i.e., in Fig. 5, we choose and as zero. Next, we find the remaining s with . For that, we rewrite (31) as

 ci=λi√β(√ϕi−√β)+ (36)

Due to Lemma 2, in the optimal policy, we must have . Assuming that for all , i.e., by ignoring in (31) and (36), we solve for . Then, we compare the smallest with . If the smallest is larger than or equal to , it implies that for all due to Lemma 3, and we have obtained the optimal values for given s. If the smallest is smaller than , it implies that the corresponding was negative and it must be chosen as zero. In this case, we choose for the smallest . In the example in Fig. 5, if the we found is , then since we choose as zero. Then, we repeat this process again until the smallest among the remaining s satisfies . For example, in Fig. 5, the next found by using only indices may be . Since , we choose . In the next iteration, the found by using indices may be . Since , we stop the process and find for from (31) or (36) by using in Fig. 5. This concludes finding s for given s. Next, for given s, we find s by following a similar procedure. We keep solving for s for given s, and s for given s, until pairs converge.

In the following section, we provide a solution for the general system with multiple caches.

## Vi Freshness Maximization for the General System

In this section, we provide a solution for the general system shown in Fig. 4, where there are caches in between the source and the user. We define as the total update rate of cache , i.e., . Using in (19), we rewrite the optimization problem in (II) as

 max{cri,ui} n∑i=1uiui+λim∏r=1cricri+λi s.t. n∑i=1cri≤Cr,r=1,…,m n∑i=1ui≤U cri≥0,ui≥0,r=1,…,m,i=1,…,n. (37)

We introduce the Lagrangian function for (VI) as

 L= −n∑i=1uiui+λim∏r=1cricri+λi+m∑r=1βr(n∑i=1cri−Cr)+θ(n∑i=1ui−U) −m∑r=1n∑i=1νricri−n∑i=1ηiui, (38)

where , , and . Then, we write the KKT conditions as

 ∂L∂cri =−uiui+λi∏ℓ≠rcℓicℓi+λiλi(cri+λi)2+βr−νri=0, (39) ∂L∂ui =−λi(ui+λi)2m∏r=1cricri+λi+θ−ηi=0, (40)

for all and . The complementary slackness conditions are

 βr(n∑i=1cri−Cr) =0, (41) θ(n∑i=1ui−U) =0, (42) νricri =0, (43) ηiui =0. (44)

The objective function in (VI) is not jointly concave in and . However, for given s, the objective function in (VI) is concave in , and for a given and s for all , the objective function in (VI) is concave in . Thus, similar to the solution approach in Section V, we apply an alternating maximization based method to find tuples such that (39) and (40) are satisfied for all and .

Starting with initial and s for , we find the optimum update rates for cache , s, such that the total update rate constraint for the cache, i.e., , and the feasibility of the update rates, i.e., for all , are satisfied. We repeat this step for all . Then, for given s, we find the optimum update rates for the user, s, such that the total update rate constraint for the user, i.e., , and the feasibility of the update rates, i.e., for all , are satisfied. We repeat these steps until the KKT conditions in (39) and (40) are satisfied.

For given s with , and with for , we rewrite (39) as

 (cri+λi)2=σiλiβr−νri, (45)

where . Then, we find as

 cri=√σiλiβr−νri−λi, (46)

for all with and for . If , we have from (43). Thus, we have

 cri=(√σiλiβr−λi)+. (47)

Note that requires , i.e., which also implies that if , then we must have . We repeat this step for .

Next, we solve for s for given s for all with . We rewrite (40) as

 (ui+λi)2=ρiλiθ−ηi, (48)

where . Then, we find as

 ui=√ρiλiθ−ηi−λi, (49)

for all with for all . If , we have from (44). Thus, we have

 ui=⎛⎝√ρiλiθ−λi⎞⎠+. (50)

Similarly, requires , i.e., which implies that if