# Priority Queues with Fractional Service for Tiered Delay QoS

^{*}

^{†}

## Abstract

**:**

## 1. Introduction

## 2. Related Works

## 3. Fractional Service Buffers

^{2}Q [14] and Least Attained Service [15], which map flow throughputs into packet delays, are also suitable candidates. A flow scheduling policy, in conjunction with the delay protection provided by the packet queueing engine, provides configurable parameters for network operators to tune the desired level of QoS. The key in a configurable QoS scheduler is the packet queueing engine that offers multiple classes of delay protections, where the delay protection of each class can be quantified based on the traffic parameters given by a flow scheduling policy and an admission control policy. In this paper, we are leaving open the flow scheduling policy while assuming that the flow scheduler assigns each packet a delay class according to some selected flow QoS principles. We shall focus on the design and analysis of the packet queueing engine, dubbed the Fractional Service Buffers (FSB), of which the objective is to deliver the packet delay limit of each delay class.

_{i}to be protected by the FSB, where τ

_{0}< τ

_{1}< … < τ

_{M}.

_{i+k}= 1/(m(i + k)), regardless of the size of the arriving packet. In other words, Buffer-i receives a credit 1/(mi) whenever a packet arrives at one of the buffers with a priority higher than i (i.e., Buffer-0, Buffer-1, …, Buffer-(i − 1)). The integer m is a configurable parameter used to control the unit fractional credit. When the credit accumulated by Buffer-i reaches unity, its leading packet is moved to Buffer-(i − 1) and is thus “promoted” to Class-(i − 1). A promoted packet is treated equally as any other newly arriving packets to that class. We note that unit fractional credits always accumulate to unity with no leftovers. This would avoid credit remainder issues and their associated analytical and algorithmic complications. Similar to a strict priority queueing system, services are dedicated to a lower-priority buffer when all the higher-priority buffers are empty.

_{i}on the aggregate queue length of Buffer-0 to Buffer-i. That is, the FSB algorithm prevents the total number of packets inside the lowest i buffers, denoted by Q

_{i}, from exceeding K

_{i}. As such, a Class-i packet can enter Buffer-i only if it does not result in Q

_{i}> K

_{i}.

_{i}= K

_{i}. We refer to this event as a packet overflow. An overflowed packet is no longer protected within the delay limit of its priority class originally determined by the flow scheduler. Once a packet overflows from Buffer-i to Buffer-(i + 1), it will be treated as Class-(i + 1) and, thus, receives the delay protection of Class-(i + 1). If Buffer-(i + 1) has also reached its threshold, the packet will be overflowed to Buffer-(i + 2) and so on. Figure 2 illustrates the packet management of the FSB for M + 1 buffers. Figure 2a shows that classified packets from the flow scheduler enter different buffers based on their assigned delay classes. Figure 2b shows packet movements between adjacent buffers based on the FSA, where a rightward arrow signifies packet promotion, while a leftward arrow signifies packet overflow. We note that without buffer capacity thresholds, the FSB becomes strict priority queues when m→∞.

**Figure 2.**(

**a**) Packets are assigned to different buffers in accordance with their delay classification; (

**b**) Packet movements between buffers as directly by the FSA.

_{0}= 6, K

_{1}= 12, K

_{2}= 18 for classes 0, 1, and 2 respectively. Figure 4 illustrates the first overflow scenario. In Figure 4a, the arriving Packet X is classified as Class-1 and is supposed to be admitted to Buffer-1. However, the threshold of Class-1 has already been reached (i.e., Q

_{1}= K

_{1}) at the time. Thus, X has to be overflowed to the tail of Buffer-2 as shown in Figure 4b and counted as a delay violation. In this case, no service credit is awarded to Buffer-2 as a result of X’s arrival because X is not admitted to Buffer-1. Figure 5 illustrates the second overflow scenario. In Figure 5a, Packet Y of Class-0 arrives and is assigned to Buffer-0. In this case, the threshold of Class-0 has not been reached (i.e., Q

_{0}< K

_{0}) and thus Y can be admitted to Buffer-0. However, the combined number of packets from Class-0 and Class-1, Q

_{1}will exceed the Class-1 threshold (i.e., Q

_{1}> K

_{1}) as a result. As shown in Figure 5b one of the Class-1 packets, Packet 18, has to be overflowed to the head of Buffer-2 and counted as a delay violation. This is similar to “push-out on threshold” policies in buffer management [16]. Certainly, the FSB has to limit the frequency of overflow for each class, denoted δ

_{i}for Class-i, to maintain a meaningful delay QoS for that class. In this latter case, the successful insertion of Y grants both Class-1 and Class-2 service credits. Because m = 1, Class-1 and Class-2 receive credits of 1 and 1/2 respectively. As a result, Class-1 has sufficient credit to have its leading packet promoted to Buffer-0 while Class-2 does not. Since promoting a packet from Buffer-1 to Buffer-0 does not change the value of Q

_{1}, the promotion can take place even though Q

_{1}is at its threshold level Q

_{1}= K

_{1}. Figure 5c displays the renumbered packets in the buffers after the arrival, the overflow, and the promotion. In particular, Packet Y is now Packet 05, Packet 06 is the promoted Packet 11, and Packet 21 is the overflowed Packet 18 in Figure 5b. We note that each buffer in FSB can be implemented with a link-list and a promotion is achieved by simply moving the tail pointer of the higher-priority buffer by one (packet) to accommodate for the packet promoted from the lower-priority buffer as shown in Figure 5c. In this case, pointer to the tail of Class-0 is moved, while pointer to the tail of Class-1 is not because Class-2 has not earned sufficient credits. With this pointer management scheme, packets do not have to be physically moved once they are placed in the buffer memory.

## 4. Performance Analysis

_{0}. Queueing analysis of Buffer-0 is performed under the assumption that the traffic input rate is sufficiently high.

_{1}= 1/2. In this example, every other Class-0 packet arrival from the flow scheduler is accompanied by a Class-1 packet promoted to Class-0 from Buffer-1. Thus, the traffic served by Buffer-0 includes Class-0 packets coming straight from the flow scheduler and promoted packets coming from Buffer-1. Essentially, Buffer-0 is a G/G/1/K

_{0}queueing system where inter-arrival times should account for Class-0 traffic from the flow scheduler and traffic promoted from Buffer-1.

_{0}queueing system where K

_{0}is the buffer threshold for Buffer-0. Diffusion process is often used by researchers to model packet schedulers, under heavy load conditions [10], because it leads to closed-form results for the behavior of the scheduler. The key notion is, under heavy traffic conditions, the discontinuities in time from the arrival and departure processes are much smaller than queueing delay. Thus, these processes may be treated as continuous fluid flows, which allow the queue length to be approximated by a diffusion process. For finite buffer cases, the overflow probability can be obtained by imposing boundary conditions on the diffusion process. A comprehensive survey article [17] compared different diffusion approximation techniques and concluded that the diffusion formula by Gelenbe [18] for G/G/1/K queue is the most accurate and robust. It solved the diffusion equation with jump boundaries and instantaneous returns at 0 and K.

_{0}*, as the time interval between two successive packets entering Buffer-0, regardless of the packets’ origins. Then, it is readily shown that the mean and the variance of t

_{0}* are:

_{0}, the probability that Buffer-0 is at its threshold K

_{0}when a new Class-0 packet arrives. This is the probability of delay limit violation for Class-0 and it depends on the effective load of Buffer-0, ${\mathsf{\rho}}_{0}^{*}=\overline{X}/(C{{\overline{t}}_{0}}^{*})$. For m = 2, a two-buffer system (M = 1) with exponentially distributed inter-arrival time and exponentially distributed service time, Figure 7 shows the simulation result for δ

_{0}as a function of ${\mathsf{\rho}}_{0}^{*}$ almost coincides with our result based on diffusion approximations.

**Figure 7.**Analytical versus simulation results: probability of overflow for Buffer-0 versus its load (2 Buffers, and m = 2).

_{i}as the aggregate of packet queues formed in the i + 1 highest-priority buffers (i.e., Buffer-0, Buffer-1, …, Buffer-i), and H

_{i}the aggregate of packet queues formed in the M-i lowest-priority buffers (i.e., Buffer-(i + 1), Buffer-(i + 2), …, Buffer-M). Figure 8 shows the aggregate queues L

_{2}and H

_{2}for an M = 4 system (5 buffers). The analytical result for the two-buffer case can then be applied to the two aggregate buffers, L

_{i}and H

_{i}.

_{i}as a G/G/1/K

_{i}queueing system whose blocking probability corresponds to the probability of overflow for Class-i. From the conservation law of priority queues [10], the distribution of the number of packets in the system is invariant to the order of service, as long as the scheduling discipline selects packets independent of their service times. Since the FSB is packet-size-neutral, work-conserving, and no packets are dropped inside L

_{i}, we can apply the conservation law to the lower aggregate buffer L

_{i}and use the diffusion result of G/G/1/K

_{i}to find the probability of Q

_{i}= K

_{i}when a new packet arrives at L

_{i}. Interested reader may refer to Reference [10] for a more comprehensive description on the conservation law of priority queues for modeling queueing system.

_{i}denote the packet arrival rate at Buffer-i from the flow scheduler. The aggregate packet arrival rate for L

_{i}coming from the flow scheduler is given by:

_{i}is never empty, the effective inter-arrival time for L

_{i}is given by:

_{i}, the probability of overflow for Class-i packets. Finally, we may obtain the overall packet blocking probability P

_{B}of the system by observing that all M buffers can be aggregated to a single buffer L

_{M}and represented by a G/G/1/K

_{M}queue such that P

_{B}= δ

_{M}.

_{i}, for a Class-i packet that is not overflowed, can be expressed iteratively as a function of the maximum packet size from every class, X

_{max}, and the buffer thresholds K

_{i}s:

## 5. Simulation

_{i}= λ, 0 ≤ i ≤ 4, and vary λ to study the loading effect on each buffer. The assumption that every buffer, except Buffer-0, always has traffic to be promoted, does not hold in the simulations but is expected to be sufficient under heavy traffic loads. Figure 9 compares our analytical results with the simulation results: they track each other very closely in terms of the probabilities of overflow. These probabilities of overflow do not exhibit any particular trend across different classes. The approximation appears to be slightly less accurate on higher-priority classes; this may be because the effective load of the aggregate lower buffers L

_{i}increases with i and the fact that our analytical result is based on heavy traffic assumptions. Therefore, for small is, our result yields a conservative approximation to the actual probabilities of overflow; the actual probabilities of overflow are expected to be slightly lower than our approximations.

**Figure 9.**Probabilities of overflow versus normalized system loads. X is truncated exponential with a maximum size four times the mean, K

_{0}= 10, K

_{1}= 20, K

_{3}= 30, K

_{3}= 40, K

_{4}= 50.

## 6. Discussion

_{i}. The analytical results from Equations (1)–(4), (7), and (9) showed the relationships between the worst-case delay, the delay limit violation probability, and the key parameters m and K

_{i}of the queueing engine. By tuning these parameters, the protections offered to each delay class can be altered.

_{i}is the limit on the aggregate queue length of L

_{i}. Supposing that we set these thresholds to be multiples of K

_{0}, i.e., K

_{1}= 2K

_{0}, K

_{2}= 3K

_{0}… That is, for each additional service class, we increase the buffer capacity by a constant amount K

_{0}. In this setup, one may expect the worst-case delays of these classes to scale linearly as the priority decreases. However, this is not the case. Figure 10 plots worst-case delay against priority level, which shows that the increase in delay is faster than a linear rate. This is because the rate of promotion worsens as i increases and for lower-priority buffers (larger i), effects of slower promotion rates compound. This phenomenon is best observed in Equation (9): the difference of the worst-case delays between two adjacent priority classes, τ

_{i}− τ

_{i}

_{−1}, has a denominator that decreases faster than a linear rate as i increases. For example, when m = 1, the denominators of τ

_{i}− τ

_{i}

_{−1}are η

_{1}/(1 + η

_{1}) = 0.5, η

_{2}/(1 + η

_{2}) = 1/3, and η

_{3}/(1 + η

_{3}) = 1/4, for i = 1, 2, 3, respectively, while the numerators remain constant with respect to i.

_{i}= 1/(mi) upon the rate at which Buffer-i can promote its packets. Although this has simplified the analysis and implementation of the FSB considerably, it has also greatly limited its configurability, since a single parameter m controls all the unit fractions η

_{i}. Without such a unit fraction restriction, the values of η

_{i}can be set and tuned individually in order to yield more flexible performance tradeoffs between delay classes. Under this general approach, to lower the worst-case for the ith class, one can choose to either increase η

_{i}or decrease K

_{i.}From the iterative relationship of the worst-case delay, Equation (9), lowering the threshold K

_{i}will naturally lower the delays of all classes i and above. By lowering K

_{i}, the buffer capacity for accommodating packets from the ith class will also be lowered thus leading to a higher delay violation probability for the ith class. Increasing η

_{i}will also lower the worst-case delay of all classes i and above. However, by increasing η

_{i}, we are increasing the service share dedicated to the lower-priority buffers. Thus, even though worst-case delays for higher-priority buffers will not be affected by a larger η

_{i}, their probabilities of delay limit violation will be higher. Basically, favoring some classes inevitably affects the other classes. The tradeoff is determined by the setting of K

_{i}and η

_{i}.

## 7. Designing Fractional Service Buffer

_{i}(i.e., thresholds for the queue length of each L

_{i}) and m, the delay limit and the probability for delay limit violation for each class could be determined. When designing a packet scheduler, however, a common objective is to set the buffer size for each delay class such that a pre-determined delay limit for that class can be achieved. In the following, we illustrate how to utilize our analytical results to achieve this design objective.

_{max}denote the fixed packet size. By letting each τ

_{i}− τ

_{i}

_{−1}= D in Equations (9) and (10), each K

_{i}can be expressed as:

_{i}with the delay limits. However, K

_{i}s and delay limits are meaningless without being accompanied by the probabilities of delay-limit violation (i.e., δ

_{i}), which can be determined given the packet-arrival statistics. For simplicity, let the packet inter-arrival time for each Buffer-i be exponentially distributed with a mean of 1/λ (i.e., λ

_{i}= λ for all 0 ≤ i ≤ M). We use a numeric example to illustrate the relationships between D, K

_{i}, and δ

_{i}, where the numeric values used in this example are summarized in Table 1. Note that $D=50\frac{{X}_{\text{max}}}{C}=7.5\times {10}^{-4}$, which is equal to the time required for serving 50 packets of size X

_{max}= 1500. This results in K

_{0}= 50. Additionally, note that λ is chosen such that the system has a normalized load of 1 (i.e., ${\mathsf{\rho}}_{M}=\frac{(M+1)\mathsf{\lambda}{X}_{\text{max}}}{C}=1$). This means that ${\mathsf{\rho}}_{0}=\frac{\mathsf{\lambda}{X}_{\text{max}}}{C}=0.2$, ${\mathsf{\rho}}_{1}=\frac{2\mathsf{\lambda}{X}_{\text{max}}}{C}=0.4$, and so on. As such, Buffer-0 can store up to 50 Class-0 packets but only has ${\mathsf{\rho}}_{0}=0.2$ of traffic load. Clearly, Class-0 traffic has ample storage space for storing packets and will have a very small probability of delay limit violation, δ

_{0}, regardless of the unit fraction, η

_{1}= 1/m, chosen for packet promotion from Buffer-1 to Buffer-0. This excessive storage space is shared with lower-priority classes, thus allowing these classes to enjoy low probabilities of delay limit violation as well. Table 1 illustrates the K

_{i}required for achieving the delay limits when m = 1 and when m = 2. For m = 1, K

_{i}− K

_{i}

_{−1}decreases as i increases. In other words, the dedicated buffer space for Class-i packets under congestion (i.e., K

_{i}− K

_{i}

_{−1}) is small when Class-i has low priority. This is because as i increases, η

_{i}decreases harmonically while the delay limit increases linearly. The linear increase on the delay limit requires that each Class-i packet be promoted in D seconds, for any Class-i with 1 ≤ i ≤ M. However, the harmonic descent on η

_{i}implies that a Class-i packet is promoted slower than that of a Class-(i−1) packet. That is, as the promotion rate of packets becomes slower when i increases, the limit on the time for a packet promotion remains unchanged. As a result, the dedicated buffer space for Class-i decreases as i increases. This phenomenon is even more apparent for m = 2, which results in a lower η

_{i}for each Class-i when compared with the m = 1 case. Table 1 also summarizes the probabilities of delay limit violation, where the higher-priority classes have very small probabilities of delay limit violation as expected. Even for Class-4 traffic, which has the lowest priority, its delay limit can be protected with a fairly high probability, when m = 1 and m = 2.

**Table 1.**Parameters for the Fractional Service Buffer (FSB) design example, and comparison on the Size of aggregated lower buffers (K

_{i}) vs. probabilities of delay limit violation (δ

_{i}).

D (s) | C (bps) | X_{max} (bits) | λ | ||
---|---|---|---|---|---|

7.5 × 10^{−4} | 1.00 × 10^{8} | 1500 | 1.33 × 10^{5} | ||

m = 1 | |||||

Class | K_{i} | δ_{i} | |||

0 | 50 | 1.26 × 10^{−}^{22} | |||

1 | 75 | 7.17 × 10^{−}^{26} | |||

2 | 91 | 4.72 × 10^{−}^{15} | |||

3 | 104 | 9.50 × 10^{−3} | |||

4 | 114 | 8.70 × 10^{−3} | |||

m = 2 | |||||

Class | K_{i} | δ_{i} | |||

0 | 50 | 2.97 × 10^{−}^{60} | |||

1 | 66 | 7.37 × 10^{−}^{48} | |||

2 | 76 | 1.19 × 10^{−}^{26} | |||

3 | 83 | 1.81 × 10^{−9} | |||

4 | 89 | 1.11 × 10^{−3} |

## 8. Conclusions

## Author Contributions

## Conflicts of Interest

## References

- Guo, C. SRR: An O(1) time complexity packet scheduler for flows in multi-service packet networks. IEEE/ACM Trans. Netw.
**2004**, 12, 1144–1155. [Google Scholar] [CrossRef] - Jiwasurat, S.; Kesidis, G.; Miller, D. Hierarchical shaped Deficit Round-Robin scheduling. In Proceedings of the IEEE Global Telecommunications Conference, St. Louis, MO, USA, 28 November–2 December 2005.
- Kanhere, S.; Sethu, H.; Parekh, A. Fair and efficient packet scheduling using elastic round robin. IEEE Trans. Parallel Distrib. Syst.
**2002**, 13, 324–336. [Google Scholar] [CrossRef] - Shreedhar, M.; Varghese, G. Efficient fair queuing using deficit round-robin. IEEE/ACM Trans. Netw.
**1996**, 4, 375–385. [Google Scholar] [CrossRef] - Ramabhadran, S.; Pasquale, J. Stratified Round Robin: A low complexity packet scheduler with bandwidth fairness and bounded delay. In Proceedings of the 2003 Conference on Applications, Technologies, Architectures, and Protocols for Computer Communications, Karlsruhe, Germany, 25–29 August 2003.
- Zhang, H.; Ferrari, D. Rate-Controlled Static-Priority Queueing. In Proceedings of the Twelfth Annual Joint Conference of the IEEE Computer and Communications Societies, San Francisco, CA, USA, 28 March–1 April 1993.
- McKenney, P. Stochastic fairness queueing. J. Internetworking Res. Exp.
**1991**, 2, 113–131. [Google Scholar] - Dovrolis, C.; Stiliadis, D.; Ramanathan, P. Proportional Differentiated Services: Delay Differentiation and Packet Scheduling; ACM: New York, NY, USA, 1999. [Google Scholar]
- Parekh, A.K.; Gallager, R.G. A generalized Processor Sharing Approach to Flow Control in Integrated Services Networks: The Single-Node Case. IEEE/ACM Trans. Netw.
**1993**, 1, 344–357. [Google Scholar] [CrossRef] - Kleinrock, L. Queuing Systems, Volume II: Computer Applications; Wiley-Interscience: Hoboken, NJ, USA, 1976. [Google Scholar]
- Zhou, X.; Ippoliti, D.; Zhang, L. Fair bandwidth sharing and delay differentiation: Joint packet scheduling with buffer management. Comput. Commun.
**2008**, 31, 4072–4080. [Google Scholar] [CrossRef] - Lim, Y.; Kobza, J. Analysis of a delay-dependent priority discipline in an integrated multiclass traffic fast packet switch. IEEE Trans. Commun.
**1990**, 38, 659–665. [Google Scholar] [CrossRef] - Maertens, T.; Walraevens, J.; Bruneel, H. Performance comparison of several priority schemes with priority jumps. Ann. Oper. Res.
**2008**, 162, 109–125. [Google Scholar] [CrossRef] - Zhang, H. Service disciplines for guaranteed performance service in packet-switching networks. IEEE Proc.
**1995**, 83, 1374–1396. [Google Scholar] [CrossRef] - Avrachenkov, K.; Ayesta, U.; Brown, P.; Nyberg, E. Differentiation between short and long tcp flows: Predictability of the response time. In Proceedings of the Twenty-Third AnnualJoint Conference of the IEEE Computer and Communications Societies, Hong Kong, China, 7–11 March 2004.
- Cidon, I.; Georgiadis, L.; Guerin, R.; Khamisy, A. Optimal Buffer Sharing. IEEE J. Sel. Areas Commun.
**1995**, 13, 1229–1240. [Google Scholar] [CrossRef] - Springer, M.; Makens, P. Queueing models for performance analysis: Selection of single station models. Eur. J. Oper. Res.
**1992**, 58, 123–145. [Google Scholar] [CrossRef] - Gelenbe, E. On approximate computer system models. J. ACM
**1975**, 22, 261–263. [Google Scholar] [CrossRef]

© 2015 by the authors; licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons by Attribution (CC-BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Chang, G.; Lee, C.-C.
Priority Queues with Fractional Service for Tiered Delay QoS. *Future Internet* **2016**, *8*, 1.
https://doi.org/10.3390/fi8010001

**AMA Style**

Chang G, Lee C-C.
Priority Queues with Fractional Service for Tiered Delay QoS. *Future Internet*. 2016; 8(1):1.
https://doi.org/10.3390/fi8010001

**Chicago/Turabian Style**

Chang, Gary, and Chung-Chieh Lee.
2016. "Priority Queues with Fractional Service for Tiered Delay QoS" *Future Internet* 8, no. 1: 1.
https://doi.org/10.3390/fi8010001