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

V. AOI-BASED POLICIES 

In Section IV, we have demonstrated that size-based policies achieve a better average AoI/PAoI performance than non-size-based policies. However, size-based policies do not utilize the arrival-time information, which also plays an important role in reducing the AoI. In this section, we propose three AoI-based scheduling g policies, which leverage both the update size and arrival-time information to reduce the AoI. Our simulation results show that these AoI-based policies outperform non-AoIbased policies.

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 Portugal

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

We begin with the definitions of three AoI-based policies that  attempt to optimize the AoI at a specific future time instant from  three different perspectives:

• AoI drop earliest (ADE): When the server frees up, it chooses to serve an update such that once it is delivered, the AoI drop as soon as possible. 

• AoI drop to smallest (ADS): When the server frees up, it chooses to serve an update such that once it is delivered, the AoI drops to a value as small as possible. 

• AoI drop most (ADM): When the server frees up, it chooses to serve an update such that once it is delivered, the AoI drops as much as possible.

If all updates waiting in the queue are obsolete, then the above policies choose to serve an update with the smallest size.

Although all of these AoI-based policies are quite intuitive,  they behave very differently. To explain the differences between these AoI-based policies, we present an example in Fig. 7  to show how the AoI evolves under these policies. Suppose that when the (i−1)st update is being served, three new updates (i.e.,  the ith, (i+1)st, and (i+2) and updates) arrive in sequence at times ti, ti+1, and ti+2, respectively. The sizes of these updates satisfy S i < S i+1 < S i+2. When the server frees up after it finishes serving the (i − 1)st update at time t I 0−1, ADE, ADS, and ADM  choose to serve the ith, (i + 1)st, and (i + 2) and updates, respectively. This is because serving the ith update leads to the earliest AoI drop at time t I 0 (following the red curve), serving the (i+1)st update leads to the AoI dropping to the smallest at time t I 0+1 (following the blue curve), and serving the (i + 2) and update leads to the largest AoI drop at time t I 0+2 (following the green curve). ADE, ADS, and ADM aim to optimize AoI at a specific future time instant (i.e., the future delivery time of chosen update) with different myopic goals. Note that at first glance, ADS  and ADM may look the same. Indeed, they would be equivalent if the events of the AoI drop have happened at the same time instant. However, these two policies are different as the time instants at which the AoI drops are not necessarily the same (e.g., t I 0+1  vs. t I 0+2  in Fig. 7). In addition, ADE and SJF may also look the same at first glance. Indeed, these two policies would make the same decision (i.e., choose the smallest update to serve) when the smallest update leads to an AoI drop. However, they make different decisions when the smallest update does not lead to an AoI drop. An example is provided in Fig. 8 to illustrate the key difference. In Fig. 8, after the (i − 1)st update completes service at time t I 0−1, two updates are waiting to be served: the (n−2) and update and the ith update. Suppose that the update size and the arrival time of these two updates satisfy the following: S i−2 < S I and ti−2 < ti−1 < ti. ADE chooses to serve the ith update that leads to an earlier AoI drop (see Fig. 8(a)), while SJF chooses to serve the (i − 2) and update that has a smaller size (see Fig. 8(b)).

Next, we conduct extensive simulations to investigate the AoI performance of these AoI-based policies. In Fig. 9, we present the simulation results of the average AoI performance of the AoI-based policies compared to a representative arrival-time-based policy (i.e., LCFS) and a representative size-based policy (i.e., SJF). All the policies considered here are non-preemptive;  the preemptive cases will be discussed in Section VI.

In Fig. 9(a), we observe that most AoI-based policies are slightly better than non-AoI-based policies, although their performances are very close. Among the AoI-based policies, ADE  is the best, ADM is the worst, and ADS is in-between. This is not surprising that ADM is the worst: Although ADM has the largest AoI drop, this is at the cost that it may have to wait until the AoI becomes large first. ADE being the best suggests that giving a higher priority to small updates (so that the AoI drops as soon as possible) is a good strategy. In Figs. 9(b) and 9(c), similar observations can be made for update size following Weibull distributions.

The above observations lead to the following guideline:

Guideline 4. Leveraging both the update size and arrival-time information can further improve the AoI performance. However,  the benefit seems marginal.

VI. PREEMPTIVE, INFORMATIVE, AOI-BASED POLICIES 

In Section IV, we have observed that preemptive policies have several advantages and perform better than non-preemptive policies. In this section, we first demonstrate that policies that prioritize informative updates (i.e., those that can lead to AoI drops once delivered) perform better than non-informative policies. Then, by integrating the guidelines we have, we consider preemptive, informative, AoI-based policies and evaluate their performances through simulations.

A. Informative Policies

As far as the API is concerned, there are two types of updates: Informative updates and non-informative updates [24]. Informative updates lead to AoI drops once delivered while noninformative updates do not. In some applications, such as autonomous vehicles and stock quotes, it is reasonable to discard non-informative updates (which do not help reduce the AoI but may block new updates). In this subsection, we introduce the “informative” versions of various policies, which prioritize informative updates and discard non-informative updates. Then,  we use simulation results to demonstrate that informative policies generally have a better average AoI/PAoI performance than the original (non-informative) ones. Furthermore, we rigorously prove that in a G/M/1 queue, the informative version of LCFS is stochastically better than the original LCFS policy.

We use π_I to denote the informative version3 of policy π. All the scheduling policies we consider have their informative versions. In some cases, the informative version is simply the same as the original policy (e.g., FCFS and LCFS_P).

3 For simplicity, we omit the additional “_" in the policy name if policy π is a  preemptive policy ending with “_P". For example, we use LCFS_PI to denote the informative version of LCFS_P.

In Fig. 11, we show the simulation results of the average AoI performance of several informative policies compared to their non-informative counterparts. To evaluate the benefit of informative policies, we plot the informative AoI gain, which is the ratio of the difference between the average AoI of the noninformative version and the informative version to the average AoI of the non-informative version. Hence, a larger informative gain means a larger benefit from the informative version. One important observation from Fig. 11 is as follows.

Observation 8. Informative policies achieve a better average AoI performance than their non-informative counterparts. The informative gain is larger for non-preemptive policies and increases as the system load increases.

Intuitively, informative policies are expected to outperform their non-informative counterparts because serving noninformative updates cannot reduce the AoI but may block new updates. The simulation results verify this intuition as the informative AoI gain is always non-negative. Second, we can see that most non-preemptive policies (e.g., RANDOM, LCFS, and SJF)  benefit more from prioritizing informative updates. Third, as the system load ρ increases, the informative AoI gain increases under most considered policies, especially those non-preemptive ones. This is because as the system load increases, the number of non-informative updates also increases, which has a larger negative impact on the AoI performance for non-preemptive,  non-informative policies.

Observation 8 leads to the following guideline:

Guideline 5. The server should prioritize informative updates and discard non-informative updates when it is allowed.

Based on Observation 8, we conjecture that an informative policy is as least as good as its non-informative counterpart. As a preliminary result, we prove that this conjecture is indeed true for LCFS in a G/M/1 queue. In the following, we introduce the stochastic ordering notion, which will be used in the statement of Proposition 1.

Definition 2. Stochastic ordering of stochastic processes [25, Ch.6.B.7]: Let {X(t), t ∈ [0, ∞)} and {Y(t), t ∈ [0, ∞)} be two  stochastic processes. Then, {X(t), t ∈ [0, ∞)} is said to be  stochastically less than {Y(t), t ∈ [0, ∞)}, denoted by {X(t), t ∈ [0, ∞)}≤st{Y(t), t ∈ [0, ∞)}, if, for all choices of integer n and  t1 < t2 < · · · < tn in [0, ∞), the following holds for all upper  sets4 S U ⊆ R  n :

where X~ , (X(t1), X(t2), · · ·, X(tn)) and Y~ , (Y(t1), Y(t2), · · ·, Y(tn)). Stochastic equality can be defined similarly and is denoted by {X(t), t ∈ [0, ∞)}=st{Y(t), t ∈ [0, ∞)}.

Roughly speaking, (2) implies that X~ is less likely than Y~ to take on large values, where “large” means any value in an upper set S U. We also use ∆π(t) to denote the AoI process under policy π. Furthermore, we define a set of parameters I = {n, (ti)  n  i=1 }, where n is the number of updates and ti is the generation time of update i. Having these definitions and notations, we are now ready to state Proposition 1.

Proposition 1. In a G/M/1 queue, for all, I, the AoI under LCFS_I is stochastically smaller than that under LCFS, i.e., Proof. Recall that we use ti and t I 0  to denote the arrival time and the delivery time of the ith update, respectively. In addition, we use it to denote the service start time of the ith update.

We define the system state at time t under policy π as S π(t), Uπ(t), where Uπ (t) is the largest arrival time of the updates that have been served under policy π by time t. Let {S π(t), t ∈ [0, ∞)}  be the state process under policy π. By the definition of AoI, (3)  holds if the following holds:

Next, we prove (4) by contradiction through a coupling argument. Suppose that stochastic processes ˆS LCFS_I (t) and ˆS LCFS (t)  have the same stochastic laws as S LCFS_I (t) and S LCFS (t), respectively. We couple ˆS LCFS_I (t) and ˆS LCFS (t) in the following manner: If an update i is delivered at t I 0  in ˆS LCFS(t), then the update j being served at t I 0 (if any) in ˆS LCFS_I(t) is also delivered at the same time. This coupling is reasonable because: (i) The updates served in ˆS LCFS_I(t) are not chosen based on update size; (ii) the service time of an update in both ˆS LCFS_I (t) and ˆS LCFS (t) is exponentially distributed and has the memoryless property. Theorem 6.B.30 in [25], (4) holds if the following  holds:

In the following, we want to show that ˆS LCFS_I (t) ≥ ˆS LCFS (t)  holds conditionally on an arbitrary sample path I, which trivially implies (5). We prove it by contradiction. For the sake of contradiction, suppose that ˆS LCFS_I(t) < ˆS LCFS(t) does happen and that it happens for the first time at time t0 (see Fig. 13 for illustration). Let m and n be the index of the served updates with the largest arrival time by t0 in ˆS LCFS_I(t) and ˆS LCFS(t), respectively. Then, we have ULCFS_I(t0) = tm and ULCFS(t0) = tn. Note that we also have tm < tn due to ˆS LCFS_I(t0) < ˆS LCFS(t0) (i.e., ULCFS_I(t0) < ULCFS(t0)). Since t0 is the first time when ˆS LCFS_I(t) < ˆS LCFS(t) happens, a crucial observation is that t0  must be immediately after an update is delivered in ˆS LCFS(t). Hence, we have t0 = (t 0n ) + , where (t 0n ) + denotes the time immediately after t 0n .

Due to the coupling between ˆS LCFS(t) and ˆS LCFS_I(t), there are two cases in ˆS LCFS_I(t): 1) The server is being idle at t 0n; 2) an update is delivered at t 0n  too. We discuss these two cases separately and show that there is a contradiction in both cases.

Case 1): The server in ˆS LCFS_I(t) is idle at t 0n (see Fig. 13(a)). Then, the most recently delivered update in ˆS LCFS_I(t) (i.e., the mth update) must be delivered before t 0n. Hence, we have t 0m < t 0n  and that the server in ˆS LCFS_I(t) stays in the idle state during (t 0m, t 0n ]. Then, the server in ˆS LCFS_I(t) could  have started serving a newer update that arrives later than the mth update immediately after t 0m. (Such a newer update must exist as the nth update is a valid candidate due to tm < tn.) This results in a contradiction with the server being idle during (t'm, t'n ].

Case 2): An update is delivered at t 0n  in ˆS LCFS_I(t). This delivered update is the mth update. Note that we must have sm < tn. This is because if sm ≥ tn, then the server in ˆS LCFS_I(t) would have chosen to serve the nth update or a fresher update that arrives later than tn at time sm since this selected update is newer (due to tm < tn). There are two subcases for the server in ˆS LCFS(t) at time sm: 2a) Idle; 2b) busy. Again, we discuss these two subcases separately and show that there is a contradiction in both cases.

Case 2a): The server in ˆS LCFS(t) is idle at time sm (see Fig. 13(b)). In this case, the mth update must have already been delivered by time sm in ˆS LCFS(t). Otherwise, the server in ˆS LCFS(t) would have started serving the mth update (or a newer update) at or before sm. This implies that ˆS LCFS_I(t) < ˆS LCFS(t)  happens before sm, which results in a contradiction with that t0  is the first time at which ˆS LCFS_I(t) < ˆS LCFS(t) happens.

Case 2b): The server in ˆS LCFS(t) is busy at time sm (see Fig. 13(c)). Assume that the lth update is being served at sm in ˆS LCFS(t). In this case, the lth update must be delivered by time sn in ˆS LCFS(t). This is because the nth update starts service at sn in ˆS LCFS(t). Then, the mth update must also be delivered by time sn in ˆS LCFS_I(t), due to the coupling between ˆS LCFS(t) and ˆS LCFS_I(t). This results in a contradiction that the mth update is delivered at ten.

Combining all the cases, we show that ˆS LCFS_I (t) ≥ ˆS LCFS (t)  holds conditionally on an arbitrary sample path I. This trivially implies (5), which further implies (4) by Theorem 6.B.30  in [25]. This completes the proof.

B. Preemptive, Informative, AoI-based Policies

So far, we have demonstrated the advantages of preemptive policies, AoI-based policies, and informative policies. In this subsection, we want to integrate all of these three ideas and propose preemptive, informative, AoI-based policies.

We first consider a preemptive, informative version of three AoI-based policies: ADE_PI, ADS_PI, and ADM_PI. Interestingly, we can show equivalence between ADE_PI and SRPT_I (i.e., the informative version of SRPT) and between ADE_I  and SJF_I (i.e., the informative version of ADE and SJF, respectively) in the sample-path sense. These results are stated in Propositions 2 and 3.

Proposition 2. ADE_PI and SRPT_I are equivalent in every sample path. 

Proof. We use strong induction to prove that under the same sample path, ADE_PI and SRPT_I always choose the same update to serve at the same time. In the following, we only consider informative updates since non-informative updates are discarded under both ADE_PI and SRPT_I.

Suppose that when ADE_PI needs to choose the nth update to serve at time tADE_PI (n), it chooses the update with index  dADE_PI (n). Similarly, SRPT_I chooses the update with index  dSRPT_I (n) as its nth update to serve at tSRPT_I (n).

Claim: ADE_PI and SRPT_I always serve the same update at the same time, i.e., (dADE_PI(n), tADE_PI(n)) = (dSRPT_I(n), tSRPT_I(n)) for all n.

Base case: When n = 1, both ADE_PI and SRPT_I  serve the first update when it arrives. Hence, we have (dADE_PI(1), tADE_PI(1)) = (dSRPT_I(1), tSRPT_I(1)).

Induction step: Suppose that for n = k (k ≥1), we have (dADE_PI(m), tADE_PI(m)) = (dSRPT_I(m), tSRPT_I(m)) for the mth update for all 1≤m≤k. We want to show that (dADE_PI(n), tADE_PI(n)) = (dSRPT_I(n), tSRPT_I(n)) still holds for n = k+1. Note that there are two cases for the (k+1)st update: 1) The (k+1)st update preempts the kth update; 2)  the (k+1)st update does not preempt the kth update, i.e., the (k+1)st update starts service from the idle state or immediately after the kth update is delivered. We discuss these two cases  separately and show that (dADE−PI(k+1), tADE−PI(k+1)) = (dSRPT_I(k+1), tSRPT_I(k+1)) holds in both cases.

Case 1): The (k+1)st update preempts the kth update. During the service of the kth update, the (k+1)st update arrives. Under ADE_PI, to make AoI drop as early as possible, the server compares the remaining service time of the kth update with the original service time of the (k+1)st update and chooses to serve the update with a smaller remaining service time. This is the same as what SRPT_I  does. Therefore, we have (dADE−PI(k+1), tADE−PI(k+1)) = (dSRPT_I(k+1), tSRPT_I(k+1))

Case 2): The (k+1)st update does not preempt the kth update. On the one hand, if the (k+1)st update starts service from the idle state, then by the induction hypothesis,  both ADE_PI and SRPT_I finish serving the kth update at the same time and then go through a period of being idle. Therefore, ADE_PI and SRPT_I will also serve the same (k+1)st update at the same time, i.e.,  (dADE−PI(k+1), tADE−PI(k+1)) = (dSRPT_I(k+1), tSRPT_I(k+1)). On the other hand, if the (k+1)st update starts service immediately after the service of kth update, then by the induction hypothesis, ADE_PI  and SRPT_I will start service at the same time, i.e.,  tADE_PI (k+1) =tSRPT_I (k + 1). SRPT_I will select the (k+1)st update with the shortest remaining size. However, this selected (k + 1)st update must have not been served before. Otherwise,  this update is no longer informative it was preempted by another update. Thus, SRPT_I ends up choosing an update with the shortest original size, which will also be selected by ADE_PI. This implies dADE_PI (k + 1) = dSRPT_I (k + 1). Therefore, we have (dADE−PI(k+1), tADE−PI(k+1)) = (dSRPT_I(k+1), tSRPT_I(k+1)).

Proposition 3. ADE_I and SJF_I are equivalent in every sample path. 

Proof. Similar to the proof of Proposition 2, we use strong induction to show that under the same sample path, ADE_I and SJF_I always choose the same update to serve at the same time. Here, we also only consider informative updates.

Suppose that when ADE_I needs to choose the nth update to serve at time tADE_I (n), it chooses the update with index  dADE_I (n). Similarly, SJF_I chooses the update with index  dSJF_I (n) as its nth update to serve at tSJF_I(n).

Claim: ADE_I and SJF_I always serve the same update at the same time, i.e., (dADE−I(n), tADE−I(n)) = (dSJF−I(n), tSJF−I(n)) for all n.

Base case: When n = 1, both ADE_I and SJF_I serve the first update when it arrives. Hence, we have (dADE−I(1), tADE−I(1)) = (dSJF−I(1), tSJF−I(1)).

Induction step: Suppose that for n = k (k ≥ 1), we have dADE−I(m), tADE−I(m)) = (dSJF−I(m), tSJF−I(m)). for the mth update for 1≤m≤k. We want to show that dADE−I(n), tADE−I(n)) = (dSJF−I(n), tSJF−I(n)) still holds for n = k + 1. Note that there are two cases for the (k + 1)st update: 1) The (k + 1)st update starts service from the idle state; 2) the (k + 1)st update starts service immediately after the kth update is delivered. We discuss these two cases separately and show that dADE−I(k+1), tADE−I(k+1)) = (dSJF−I(k+1), tSJF−I(k+1)) holds in both cases.

Case 1): The (k+1)st update starts service from the idle state. By the induction hypothesis, both ADE_I and SJF_I  finish serving the kth update at the same time and then go through a period of being idle. Therefore, ADE_I and SJF_I  will also serve the same (k+1)st update at the same time, i.e., dADE−I(k+1), tADE−I(k+1)) = (dSJF−I(k+1), tSJF−I(k+1)).

Case 2): The (k+1)st update starts service immediately after the kth update is delivered. By the induction hypothesis, ADE_I and SJF_I will start service at the same time, i.e.,  tADE_I (k + 1) =tSJF_I (k + 1). SJF_I will choose the (k+1)st update that has the smallest update size, which will also be selected by ADE_I since this update can make AoI drop earliest. This implies dADE_PI (k+1)=dSJF_I (k+1). Therefore, we have dADE−I(k+1), tADE−I(k+1)) = (dSJF−I(k+1), tSJF−I(k+1)).

Propositions 2 and 3 imply that although SRPT_I and SJF_I  do not explicitly follow an AoI-based design, they are essentially AoI-based policies. This provides an intuitive explanation for why size-based policies, such as variants of SRPT and SJF, have a good empirical AoI performance. 

In Fig. 14, we present the simulation results for the average AoI performance of the preemptive, informative, AoI-based policies (ADE_PI) compared to several other policies. We observe that in various settings we consider, ADE_PI achieves the best AoI performance. 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.

VII. CONCLUSION 

In this paper, we systematically studied the impact of various aspects of scheduling policies on AoI performance and provided several useful guidelines for the design of AoI-efficient scheduling policies. Our study reveals that among the 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. It turns out that common scheduling policies like SRPT and SJF_P and their informative variants can achieve a very good AoI performance, although they do not explicitly make scheduling decisions based on the AoI. This can be partially explained by the equivalence between such size-based policies and some AoI-based policies. Moreover, when the AoI requirement is not stringent or the update-size information is not available, some simple delay-efficient policies (such as LCFS_P) are also good candidates for AoI-efficient policies.

Our findings also raise several interesting questions that are worth investigating as future work. One important direction is to pursue more theoretical results beyond the simulation results we provided in this paper. For example, it would be interesting to see whether one can rigorously prove that any informative policy always outperforms its non-informative counterpart, which is consistently observed in the simulation results.

APPENDIX A ADDITIONAL SIMULATION RESULTS FOR THE G/G/1 QUEUE

We present additional simulation results for the G/G/1 queue in Figs. 16–23. For all these simulations, we assume that the interarrival time follows a Weibull distribution with C 2 = 10. In subfigure (a), we assume that the update size follows an Exponential distribution with mean 1/µ = 1; in subfigures (b) and (c), we assume that the update size follows a Weibull distribution with mean 1/µ = 1. Note that in subfigures (a) and (b),  we change the value of the system load ρ; in subfigure (c), we change the value of C 2  for the update size while fixing the system load at ρ = 0.7. Observations 1–8 can also be made for the setting of the G/G/1 queue.

REFERENCES

[1] Z. Liu, L. Huang, B. Li, and B. Ji, “Anti-aging scheduling in single-server queues: A systematic and comparative study,” in Proc. INFOCOM WKSHPS, 2020. 

[2] S. Kaul, R. Yates, and M. Gruteser, “Real-time status: How often should one update?” in Proc. IEEE INFOCOM, 2012. 

[3] S. Wu, X. Ren, S. Dey, and L. Shi, “Optimal scheduling of multiple sensors with packet length constraint,” IFAC-PapersOnLine, vol. 50, no. 1,  pp. 14 430–14 435, July 2017. 

[4] M. Harchol-Balter, Performance modeling and design of computer systems: Queueing theory in action. Cambridge University Press, 2013. 

[5] A. M. Bedewy, Y. Sun, and N. B. Shroff, “Optimizing data freshness,  throughput, and delay in multi-server information-update systems,” in Proc. IEEE ISIT, 2016. 

[6] M. Costa, M. Codreanu, and A. Ephremides, “Age of information with packet management,” in Proc. IEEE ISIT, 2014. 

[7] N. Pappas, J. Gunnarsson, L. Kratz, M. Kountouris, and V. Angelakis, “Age of information of multiple sources with queue management,” in Proc. IEEE ICC, 2015. 

[8] M. E. Crovella, R. Frangioso, and M. Harchol-Balter, “Connection scheduling in web servers,” Boston University Computer Science Department, Tech. Rep., 1999. 

[9] L. Schrage, “A proof of the optimality of the shortest remaining processing time discipline,” Operations Research, vol. 16, no. 3, pp. 687–690, 1968. 

[10] D. R. Smith, “A new proof of the optimality of the shortest remaining processing time discipline,” Operations Research, vol. 26, no. 1, pp. 197–199, 1978. 

[11] M. Harchol-Balter, “Queueing disciplines,” Wiley Encyclopedia of Operations Research and Management Science, 2010. 

[12] A. Kosta, N. Pappas, and V. Angelakis, Age of Information: A New Concept, Metric, and Tool, 2017. 

[13] Y. Sun, I. Kadota, R. Talak, and E. Modiano, Age of Information: A New Metric for Information Freshness, 2019. 

[14] M. Costa, M. Codreanu, and A. Ephremides, “On the age of information in status update systems with packet management,” IEEE Trans. Inf. Theory,  vol. 62, no. 4, pp. 1897–1910, Apr. 2016. 

[15] M. Moltafet, M. Leinonen, and M. Codreanu, “On the age of information in multi-source queueing models,” IEEE Trans. Commun., vol. 68, no. 8,  pp. 5003–5017, May 2020. 

[16] S. K. Kaul, R. D. Yates, and M. Gruteser, “Status updates through queues,”  in Proc. CISS, 2012. 

[17] C. Kam, S. Kompella, and A. Ephremides, “Effect of message transmission diversity on status age,” in Proc. IEEE ISIT, 2014, pp. 2411–2415. 

[18] E. Najm and E. Telatar, “Status updates in a multi-stream m/g/1/1 preemptive queue,” in IEEE INFOCOM WKSHPS, 2018. 

[19] Y. Inoue, H. Masuyama, T. Takine, and T. Tanaka, “A general formula for the stationary distribution of the age of information and its application to single-server queues,” arXiv preprint arXiv:1804.06139, 2018. 

[20] R. Talak and E. Modiano, “Age-delay tradeoffs in single server systems,”  arXiv preprint arXiv:1901.04167, 2019. 

[21] R. Devassy, G. Durisi, G. C. Ferrante, O. Simeone, and E. UysalBiyikoglu, “Delay and peak-age violation probability in short-packet transmissions,” in Proc. IEEE ISIT, 2018. 

[22] Z. Liu, L. Huang, B. Li, and B. Ji, “Anti-aging scheduling in single server queues: A systematic and comparative study,” arXiv e-prints, p. arXiv:2003.04271, Oct. 2020. 

[23] R. D. Yates and S. K. Kaul, “The age of information: Real-time status updating by multiple sources,” IEEE Trans. Inf. Theory, vol. 65, no. 3, pp. 1807–1827, Mar. 2019. 

[24] C. Kam, S. Kompella, and A. Ephremides, “Age of information under random updates,” in Proc. IEEE ISIT, 2013. 

[25] M. Shaked and J. G. Shanthikumar, Stochastic orders. Springer Science & Business Media, 2007.

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