Anti-Aging Scheduling in Single-Server Queues: A Systematic And Comparative Study Part 1

Abstract: The age of information (AoI) is a new performance metric recently proposed for measuring the freshness of information in information-update systems. In this work, we conduct a systematic and comparative study to investigate the impact of scheduling policies on the AoI performance in single-server queues and provide useful guidelines for the design of AoI-efficient scheduling policies. Specifically, we first perform extensive simulations to demonstrate that the update-size information can be leveraged for achieving a substantially improved AoI compared to non-size-based (or arrival-time-based) policies. Then, by utilizing both the update size and arrival time information, we propose three AoI-based policies. Observing improved AoI performance of policies that allow service preemption and that prioritize informative updates, we further propose preemptive, informative, AoI-based scheduling policies. Our simulation results show that such policies empirically achieve the best AoI performance among all the considered policies. However, compared to the best delay-efficient policies (such as shortest remaining processing time (SRPT)), the AoI improvement is rather marginal in the settings with exogenous arrivals. Interestingly, we also prove the sample-path equivalence between some size-based policies and AoI-based policies. This provides an intuitive explanation for why some size-based policies (such as SRPT)  achieve a very good AoI performance.

Glycoside of cistanche can also increase the activity of SOD in heart and liver tissues, and significantly reduce the content of lipofuscin and MDA in each tissue, effectively scavenging various reactive oxygen radicals (OH-, H₂O₂, etc.) and protecting against DNA damage caused by OH-radicals. Cistanche phenylethanoid glycosides have a strong scavenging ability of free radicals, a higher reducing ability than vitamin C, improve the activity of SOD in sperm suspension, reduce the content of MDA, and have a certain protective effect on sperm membrane function. Cistanche polysaccharides can enhance the activity of SOD and GSH-Px in erythrocytes and lung tissues of experimentally senescent mice caused by D-galactose, as well as reduce the content of MDA and collagen in lung and plasma, and increase the content of elastin, have a good scavenging effect on DPPH, prolong the time of hypoxia in senescent mice, improve the activity of SOD in serum, and delay the physiological degeneration of lung in experimentally senescent mice With cellular morphological degeneration, experiments have shown that Cistanche has the good antioxidant ability and has the potential to be a drug to prevent and treat skin aging diseases. At the same time, echinacoside in Cistanche has a significant ability to scavenge DPPH free radicals and has the ability to scavenge reactive oxygen species and prevent free radical-induced collagen degradation, and also has a good repair effect on thymine free radical anion damage.

Click on Cistanche Tubulosa Supplement

【For more info:george.deng@wecistanche.com / WhatApp:86 13632399501】

Index Terms: Age of information, G/G/1 Queues, scheduling policies, update-size information.

I. INTRODUCTION

RECENTLY, the study of information freshness has received increasing attention, especially for time-sensitive applications that require real-time information/status updates, such as road congestion alerts, stock quotes, and weather forecasts. To measure the freshness of information, a new metric, called the age of information (AoI) is proposed. The AoI is defined as the time elapsed since the generation of the freshest update among those that have been received by the destination [2]. Prior studies reveal that the AoI depends on both the inter-arrival time and the delay of the updates. Due to the dependency between the inter-arrival time and the delay, this new AoI metric exhibits very different characteristics than the traditional delay metric and is generally much harder to analyze (see, e.g., [2]).

Although it is well-known that scheduling policies play an important role in reducing the delay in single-sever queues, it remains largely unknown how exactly scheduling policies impact the AoI performance. To that end, we aim to holistically study the impact of various aspects of scheduling policies on the AoI performance in single-server queues and provide useful guidelines for the design of scheduling policies that can achieve a small AoI.

While much research effort has already been exerted on the design and analysis of scheduling policies aiming to reduce the AoI, almost all of these policies are only based on the arrival time of updates, such as first come first served (FCFS) and last come first served (LCFS), assuming that the update-size information is unavailable. Here, the size of an update is the amount of time required to serve the update if there were no other updates around. In some applications, such as smart grid and traffic monitoring, the update-size information can be obtained or fairly well estimated [3]. It has been shown that scheduling policies that leverage the size information can substantially reduce the delay, especially when the system load is high or when the size variability is large [4]. This motivates us to investigate the AoI performance of size-based policies in a G/G/1 queue. Note that the update-size information is “orthogonal” to the arrival-time information, both of which could significantly impact the AoI performance. Therefore, it is quite natural to further consider AoI-based policies that use both the update size and arrival-time information of updates.

In addition, prior work has revealed that scheduling policies that allow service preemption and that prioritize informative updates (also called effective updates, which are those that lead to a reduced AoI once delivered; see Section VI.A for a formal definition) yield a good AoI performance [5]–[7]. Intuitively, preemption prevents fresh updates from being blocked by a large and/or stale update in service; informative policies discard stale updates, which do not bring new information but may block fresh updates. To that end, we also consider AoI-based scheduling designs that both allow service preemption and prioritize informative updates.

In Fig. 1, we position our work in the literature by summarizing various design aspects of scheduling policies for a G/G/1 queue. Existing work mostly explores the design based on the arrival-time information along with considering service preemption and informative updates. We point out that the size-based design is an orthogonal dimension of great importance, which somehow has not received sufficient attention yet. Unsurprisingly, designing AoI-efficient policies requires the consideration of all these dimensions. In Table 1, we summarize several useful guidelines for the design of AoI-efficient policies, which are also labeled in Fig. 1. To the best of our knowledge, this is the first work that conducts a systematic and comparative study to investigate the design of AoI-efficient scheduling policies for a G/G/1 queue. In the following, we summarize our key contributions along with an explanation of Fig. 1 and Table 1.

First, we investigate the AoI performance of size-based scheduling policies (i.e., the green arrow in Fig. 1), which is an orthogonal approach to the arrival-time-based design studied in most existing work. We conduct extensive simulations to show that size-based policies that prioritize small updates significantly improve AoI performance. We also explain interesting observations from the simulation results and summarize useful guidelines (i.e., Guidelines 1, 2, and 3 in Table 1) for the design of AoI-efficient policies.

Second, leveraging both the update-size and arrival-time information, we introduce Guideline 4 and propose AoI-based scheduling policies (i.e., the blue arrow in Fig. 1). These AoIbased policies attempt to optimize the AoI at a specific future time instant from three different perspectives: The AoI drop earliest (ADE) policy, which makes the AoI drop the earliest; the AoI drop to smallest (ADS) policy, which makes the AoI drop to the smallest; the AoI drop most (ADM) policy, which makes the AoI drop the most. The simulation results show that such AoI-based policies indeed have a good AoI performance.

Third, we observe that informative policies can significantly improve the AoI performance compared to their noninformative counterparts, which leads to Guideline 5. Integrating all the guidelines, we propose preemptive, informative, AoIbased policies (i.e., the red arrow in Fig. 1). The simulation results show that such policies empirically achieve the best AoI performance among all the considered policies.

Finally, we prove the sample-path equivalence between some size-based policies and AoI-based policies. These results provide an intuitive explanation for why some size-based policies,  such as the shortest remaining processing time (SRPT), achieve a  very good AoI performance.

To summarize, our study reveals that among various aspects of scheduling policies, we investigated, prioritizing small updates, allowing service preemption, and prioritizing informative updates play the most important role in the design of AoIefficient scheduling policies. However, compared to the best delay-efficient policies (such as SRPT), the AoI improvement of the preemptive, informative, and AoI-based policies is rather marginal in the settings with exogenous arrivals. Moreover,  when the AoI requirement is not stringent or the update-size information is not available, some simple delay-efficient policies (such as LCFS with preemption (LCFS_P)) are also good candidates for AoI-efficient policies.

The rest of this paper is organized as follows. We first discuss related work in Section II. Then, we describe our system model in Section III. In Section IV, we evaluate the AoI performance of size-based scheduling policies. We further propose AoI-based scheduling policies in Section V. In addition,  we evaluate the AoI performance of preemptive, informative, AoI-based policies in Section VI. Finally, we make concluding remarks in Section VII.

II. RELATED WORK

The traditional queueing literature on single-server queues is largely focused on delay analysis. In [8], the authors prove that all non-preemptive scheduling policies that do not make use of job size information have the same distribution of the number of jobs in the system. The work of [9], [10] proves that for a work-conserving queue, the SRPT policy minimizes the number of jobs in the system at any point and is, therefore, delay optimal. The work of [11] derives a formula for the average delay for several common scheduling policies (which will be discussed in Section IV).

On the other hand, although the AoI research is still in a  nascent stage, it has already attracted a lot of interest (see [12], [13] for a survey). Here we only discuss the most relevant work,  which is focused on the AoI-oriented queueing analysis. Much of the existing work considers scheduling policies that are based on the arrival time (such as FCFS and LCFS). The AoI is introduced in [2], where the authors study the average AoI in the M/M/1, M/D/1, and D/M/1 queues under the FCFS policy. In [14], the AoI performance of the FCFS policy in the M/M/1/1  and M/M/1/2 queues is studied, where new arrivals are discarded if the buffer is full. In [15], the authors study the average AoI performance of a multi-source FCFS M/G/1 queue. They derive the exact expression and three approximations of the average AoI for a special case of an M/M/1 queue and a general case of an M/G/1 queue, respectively. The average AoI of the LCFS  policy in the M/M/1 queue is also discussed in [14].

There has been some work that aims to reduce the AoI by making use of service preemption. In [16], the average AoI of LCFS in the M/M/1 queue with and without service preemption is analyzed. The work of [17] is quite similar to [16], but it considers the average AoI in the M/M/2 queue. In [18], the average AoI for the M/G/1/1 preemptive system with a multi-stream updates source is derived. The age-optimality of the preemptive LCFS (LCFS_P) policy is proved in [5], where the service times are exponentially distributed.

In addition to taking advantage of service preemption, some of the prior studies also consider the strategy of prioritizing informative updates for reducing the AoI. The work of [6], [7]  reveals that the AoI performance can be improved by prioritizing informative updates and discarding non-informative policies when making scheduling decisions. In [19], the authors consider a G/G/1 queue with informative updates and derive the stationary distribution of the AoI, which is in terms of the stationary distribution of the delay and the peak AoI (PAoI). With the AoI distribution, one can analyze the mean or higher moments of the AoI in GI/GI/1, M/GI/1, and GI/M/1 queues under several scheduling policies (e.g., FCFS and LCFS).

Recent research effort has also been exerted to understand the relationship between the AoI and the delay. In [20], the authors analyze the tradeoff between the AoI and the delay in a single server M/G/1 system under a specific scheduling policy without knowing the service time of each update. In [21], the violation probability of the delay and the PAoI is investigated under an additive white Gaussian noise (AWGN) channel, but the update size is assumed to be identical.

III. SYSTEM MODEL

In this section, we consider a single-server queueing system and give the definitions of the AoI and the PAoI.

We model the information-update system as a G/G/1 queue where a single source generates updates (which contain the current state of a measurement or observation of the source) with rate λ. The updates enter the queueing system immediately after they are generated. Hence, the generation time is the same as the arrival time. We use S to denote the size of an update (i.e.,  the amount of time required for the update to complete service),  which has a general distribution with mean E [S ] = 1/µ. The system load is defined as ρ, λ/µ.

We use ti and t I 0  to denote the time at which the ith update was generated at the source and the time at which it leaves the server, respectively. The AoI at time t is then defined as ∆(t), t − U(t), where U (t), max n ti: t I 0 ≤ to is the generation time of the freshest update among those that have been processed by the server. An example of the AoI evolution under the FCFS policy  is shown in Fig. 2. Then, the average AoI can be defined as

In general, the analysis of the average AoI is quite difficult since it is determined by two dependent quantities: The inter-arrival time and the delay of updates [2]. We define the inter-arrival time between the ith update and (i − 1)th update as Xi, ti − ti−1 and define the delay of the ith update as Ti, t I 0 − ti. Alternatively, the PAoI is also proposed as an information freshness metric [6], which is defined as the maximum value of the AoI before it drops due to a newly delivered fresh update. Let Ai be the ith PAoI. From Fig. 2, we can see Ai = t  i 0 − ti−1. This can be rewritten as the sum of the inter-arrival time between the ith update and the previous update (i.e., Xi) and the delay of the ith update (i.e., Ti). Therefore, the PAoI of the ith update can also be expressed as Ai = Xi + Ti, and its expectation is E[Ai] = E[Xi] + E[Ti].

IV. SIZE-BASED POLICIES

In this section, we investigate the AoI performance of several common scheduling policies, including size-based policies and non-size-based policies, via extensive simulations. Note that these common scheduling policies may serve noninformative updates (which do not lead to a reduced AoI). This is because, in some applications, such as news and social network, obsolete updates are still useful and need to be served [5]. In Section VI, we will discuss the case where obsolete updates are discarded.

Following [4], we first give the definitions of several common scheduling policies that can be divided into four types: Depending on whether they are size-based or not, where the size-based policies use the update-size information (which is available in some applications, such as smart grid [3]) for making scheduling decisions; depending on whether they are preemptive or not. The definition of preemption is given below. In this paper, we do not consider the cost of preemption.

Definition 1. A policy is preemptive if an update may be stopped partway through its execution and then restarted at a later time without losing intermediary work.

The first type consists of policies that are non-preemptive and blind to the update size: 

• First come first served (FCFS): When the server frees up, it chooses to serve the update that arrived first if any. 

• Last come first served (LCFS): When the server frees up, it chooses to serve the update that arrived last if any. 

• Random order service (RANDOM): When the server frees up,  it randomly chooses one update to serve if any.

The second type consists of policies that are non-preemptive  and make scheduling decisions based on the update size:

• Shortest job first (SJF): When the server frees up, it chooses to serve the update with the smallest size if any. The third type consists of policies that are preemptive and  blind to the update size: 

• Processor sharing (PS): All the updates in the system are served simultaneously and equally (i.e., each update receives an equal fraction of the available service capacity). 

• Preemptive last come first served (LCFS_P): This is the preemptive version of the LCFS policy. Specifically, a preemption happens when there is a new update.

The fourth type consists of policies that are preemptive and  make scheduling decisions based on the update size: 

• Preemptive shortest job first (SJF_P): This is the preemptive version of the SJF policy. Specifically, a preemption happens when there is a new update that has the smallest size. 

• Shortest remaining processing time (SRPT): When the server rees up, it chooses to serve the update with the smallest remaining size. In addition, a preemption happens only when there is a new update whose size is smaller than the remaining size of the update in service.

Previous work (see, e.g., [4, Section VII]) reveals that size-based policies can greatly improve delay performance. Due to such results, we conjecture that size-based policies also achieve a  better AoI performance given that the AoI is dominantly determined by the delay when the system load is high or when the size variability is large [2]. As we mentioned earlier, it is in general very difficult to obtain the exact expression of the average AoI except for some special cases (e.g., FCFS and LCFS) [2], [19]. Therefore, we attempt to investigate the AoI performance f size-based policies through extensive simulations.

In Figs. 3 and 4, we present the simulation results of the average AoI and PAoI performance under the scheduling policies we introduced above, respectively. There are three commonly used methods to conduct the simulation: Independent replications, batch means, and regeneration. Here, we use the independent applications for the following reasons: (i) The replication means re-independent; (ii) it allows to start of the individual replications n different initial states such that various sample paths of the underlying stochastic process can be observed. Specifically, we conduct 50 simulation runs and take the average values. In each simulation run, we consider a total number of 105  updates to ensure that the steady state is reached. All the random numbers are generated using the default pseudorandom number generator (i.e., the Mersenne Twister) in the Python standard library. Here, we assume that a single source generates updates according to a Poisson process with rate λ, and the update size is independent and identically distributed (i.i.d.). In Fig. 3(a),  we assume that the update size follows an exponential distribution with mean 1/µ = 1. In Figs. 3(b) and 3(c), we assume  that the update size follows a Weibull distribution1 with mean 1/µ = 1. We define the squared coefficient of variation of the update size as C 2, Var (S ) /E[S ] 2, i.e., the variance normalized by the square of the mean [4]. Hence, a larger C2 means a larger variability. In Fig. 3(b), we fix C 2 = 10 and change the value of system load ρ, while in Fig. 3(c), we fix system load ρ = 0.7 and change the value of C 2 . Note that throughout the paper, these simulation settings are used as default settings unless otherwise specified. In addition, the 95% confidence intervals of Figs. 3  and 4 are also provided in our online technical report [22], in which we observe that the margin of error is only a very small portion of the average (about 1%).

In the following, we will discuss key observations from the simulation results and propose useful guidelines for the design of AoI-efficient policies.

Observation 1. Size-based policies achieve a better average AoI/PAoI performance than non-size-based policies in both non-preemptive and preemptive cases.

In Fig. 3, we can see that for the non-preemptive case, SJF  has a better average AoI performance than FCFS, RANDOM,  and LCFS in various settings. Similarly, for the preemptive case, SJF_P and SRPT have a better average AoI performance than PS  and LCFS_P. Similar observations can be made for the average PAoI performance in Fig. 4.

Observation 2. Under preemptive, size-based policies, the average AoI/PAoI decreases as the system load increases.

In Figs. 3(a) and 3(b), we can see that under SJF, SJF_P, and SRPT, the average AoI decreases as the system load ρ increases. There are two reasons. First, when ρ increases, there will be more updates with small sizes arriving in the queue. Therefore,  size-based policies that prioritize updates with small sizes lead to more frequent AoI drops. Second, preemption operations prevent fresh updates from being blocked by a large or stale update in service. Similar observations can be made for the average PAoI performance in Figs. 4(a) and 4(b).

Observations 1 and 2 lead to the following guideline:

Guideline 1. When the update-size information is available, one should prioritize updates with a small size. 

However, in certain application scenarios, the update-size information may not be available or is difficult to estimate. Hence, the scheduling decisions have to be made without the updated information. In such scenarios, we make the following observations from Figs. 3 and 4.

Observation 3. LCFS and LCFS_P achieve the best average AoI performance among non-preemptive, non-size-based policies and preemptive, non-size-based policies, respectively.

Observation 4. Under LCFS_P, the average AoI/PAoI decreases as the system load increases.

Observations 3 and 4 have also been made in previous work [5], [14], [23]. It is quite intuitive that when the update size information is unavailable, one should give a higher priority to more recent updates. This is because while all the updates have the same expected service time, the most recent update arrives the last and thus leads to the smallest AoI once delivered. Therefore, Observations 3 and 4 lead to the following guideline:

Guideline 2. When the update-size information is unavailable,  one should prioritize recent updates.

Note that Observations 2 and 4 also suggest that under preemptive policies, the average AoI/PAoI decreases as the system load ρ increases. This is because preemptions prevent fresh updates from being blocked by a large or stale update in service. In addition, we have also observed the following nice properties of preemptive policies.

Observation 5. Not only do preemptive policies achieve a better average AoI/PAoI performance than non-preemptive policies, but they are also less sensitive when the update-size variability changes, i.e., they are more robust.

In Figs. 3(a) and 3(b), we can see that preemptive policies (e.g., LCFS_P, SJF_P, and SRPT) generally have a better average AoI performance than non-preemptive ones (e.g., FCFS, RANDOM, LCFS, and SJF), especially when the system load is high. In Fig. 3(c), we can see that the advantage of preemptive policies becomes larger as the update-size variability (i.e., C²) increases. Moreover, the AoI performance of preemptive policies is only very slightly impacted when the update-size variability changes, while that of non-preemptive policies varies significantly. Therefore, Observations 2, 4, and 5 lead to the  following guideline:

Guideline 3. Service preemption should be employed when it is allowed. 

Note that the above observations not only hold for the M/G/1  queue but also can be made for the G/G/1 queue. More simulation results for the G/G/1 queue (i.e., Figs. 16–23) can be found in Appendix A and our technical report [22]. In addition, we make the following interesting observations regarding the average PAoI and AoI in a G/G/1 queue.

Observation 6. The average PAoI could be much smaller than the average AoI when the interarrival time has a large variability.

In Figs. 16(a) and 17(a), we can see that the average PAoI is much smaller than the average AoI for all the common scheduling policies we considered. This is due to the interarrival time having a large variability. We present an example in Fig. 5 to illustrate that this phenomenon comes from the large variability of the interarrival time. We consider three updates: The ith, the (i + 1)st, and (i + 2) and updates, which are served in sequence during (t I 0−1, t I 0+2 ). Their interarrival times are as follows: ti − ti−1 = 30, ti+1 − ti = 1, and ti+2 − ti+1 = 1;  and their system times are as follows: t I 0 − ti = 1, t I 0+1−ti+1 = 1, and t I 0+2−ti+2 =1. In addition, we also assume t I 0−1 − ti−1 = 1. Therefore, the average AoI and the average PAoI during (t I 0−1, t I 0+2 ) are 312 + 2 2 + 2 2 −3 × 1 2 /2 × (30 + 1 + 1) ≈ 15.09 and 31 + 2 + 2/3 ≈ 11.67, respectively. In this case, the average PAoI is indeed smaller than the average AoI.

Observation 7. While the average AoI performance of several non-preemptive policies (such as RANDOM, LCFS, and SJF) is sensitive to the update-size variability, their average PAoI performance is not.

In Fig. 4(c), we observe that while the average PAoI performance of FCFS is sensitive to the update-size variability, under several non-preemptive policies (such as RANDOM, LCFS, and SJF), the average PAoI performance is much less sensitive. An explanation for this observation is the following.

First, we explain why the average PAoI under FCFS is still sensitive to the update-size variability. Note that a key difference between FCFS and other non-preemptive policies is that under FCFS, every update leads to an AoI drop and thus corresponds to an AoI peak2. When a large update is in service, it will block all the following updates that are waiting in the queue, which results in a large delay for all such updates and thus a large PAoI corresponding to these updates. In contrast, under RANDOM, LCFS, and SJF, the impact of such a blocking issue is minimal for the updates that lead to an AoI drop.

Next, we explain why under RANDOM, LCFS, and SJF,  while the average AoI is sensitive to the update-size variability,  the average PAoI is not. We first consider LCFS. In the setting we consider, there is a high chance that the newest update has a small size. Serving such small-size updates leads to a small PAoI. When the newest update has a large size, the corresponding PAoI would also be large. However, this happens less often. Therefore, the AoI trajectory would consist of a smaller percentage of large AoI peaks with many small AoI peaks in between. As the update-size variability increases, there will be fewer but larger AoI peaks. In such cases, while the average AoI is sensitive to the large AoI peaks (which come from the large update-size variability), the average PAoI is much less sensitive.

2 Consider a non-preemptive policy, the LCFS policy, as an example. Under LCFS, there may be older updates waiting in the queue when a new update is being served. After this new update finishes service, those older updates waiting in the queue become outdated, and the delivery of any of these older updates will not lead to an AoI drop.

To illustrate this fact, we provide an example in Fig. 6, where there is a large update of size n − 1, immediately followed by n small updates of size 1. In this case, we can compute the average AoI as ∆=[1×(n2/ 2− 12/2 )+n ×(22 /2−12 /2)]/ ((n−1)+n) = (n2+3n−1)/(4n−2)= O(n) and compute the average PAoI as A = (n+2×n)/(n+1)=3n/(n+1) = O(3). This example shows that a larger update-size variability (i.e., a larger n in this example) results in a larger average AoI but only minimally affects the average PAoI. A similar explanation also applies to SJF and RANDOM.

【For more info:george.deng@wecistanche.com / WhatApp:86 13632399501】