Adapting Packet Fair Queueing Algorithms to Wireless ... - CiteSeerX

Adapting Packet Fair Queueing Algorithms to Wireless Networks Parameswaran Ramanathan Dept. of Elect. & Comp. Engr. University of Wisconsin Madison, WI 53706 [email protected]

Abstract Bit errors are fairly common during transmission in a wireless network. As a result, a straight-forward application of existing packet fair queueing (PFQ) algorithms from wireline to wireless networks results in an inecient use of the limited wireless bandwidth. In this paper, we propose a simple approach for adapting the existing PFQ algorithms for the wireline networks to provide the same kind of long-term fairness guarantees while making ecient use of the wireless bandwidth. In the proposed approach, long-term fairness guarantees are provided by supplementing the bandwidth given to sessions which have not received satisfactory service in the short-term due to poor quality of their wireless channel. To eciently keep track of the amount of supplemental bandwidth for each session, the paper introduces the concept of a long-term fairness server. This concept also allows one to easily integrate the proposed approach with any of the existing PFQ algorithms. 1 Introduction Next generation wireline and wireless networks will have to concurrently support communication sessions from a wide range of applications. As a result, they must integrate support for communication sessions with diverse quality of service requirements. For example, the needs and characteristics of communication sessions from applications like telnet, ftp, and email will be considerably dierent from those of applications like Internet phone, Web browsing, and videoconferencing. Some sessions will require service guarantees such as bounds on delays or throughput while others may be satis ed with a best-eort guarantee. To concurrently meet such varied quality of service needs, many dierent scheduling policies have been proposed in literature. For wireline networks, these policies are generally referred to as Packet Fair Queueing (PFQ) algorithms

To appear in Proceedings of MOBICOM, 1998.

Prathima Agrawal Internet Arch. Research Lab Bellcore, Morristown New Jersey 07960. [email protected]

[5, 2, 11, 13, 7]. The PFQ algorithms focus on providing some notion of fair access to all sessions sharing a given link. For instance, the fairness criteria in some policies is to guarantee each backlogged session the amount of the service promised to it during session initialization [5, 2, 11, 13]. In contrast, the fairness criteria in other policies is to meet a link-sharing objective in which each group of sessions its promised share of bandwidth, where the grouping may be based on administrative aliation, protocol, trac type, or any other suitable criteria [7]. More recent policies strive to combine individual service guarantees with link-sharing objectives [3, 14]. Until recently, the issue of fairness in wireless networks has not received much attention. Instead, most scheduling policies for wireless networks focus on dealing with uctuations in the bit-error rates due to factors such as interference from other transmitters, fading, and line of sight problems. Most solutions for dealing with these uctuations rely on either deferment of transmission or on the use of error-correcting codes [1, 4, 6, 15]. Unfortunately, direct application of these techniques does not result in fairness guarantees similar to those in the wireline network. Similarly, direct applications of PFQ algorithms from wireline to wireless networks often results in an inecient use of the limited wireless bandwidth. This is because these algorithms assume that all transmitted packets are received correctly, which of course is not true in a wireless network. To provide fairness guarantees similar to that in the wireline network while making ecient use of the wireless bandwidth, Fragouli, Sivaraman, and Srivastava [8] proposed a strategy which combines CBQ [7] with channel-state based scheduling of Bhagwat et al.[4]. Through simulations they show that the resulting strategy is better in meeting the linksharing objectives than a direct implementation of CBQ on a wireless network. Lu, Bharghavan, and Srikanth [9] proposed a fair scheduling policy for wireless networks which tries to approximate the WFQ policy [5] of the wireline network. To make ecient use of the wireless bandwidth, the scheduling policy in [9] defers transmission of packets from sessions with poor quality wireless channels. To guarantee fairness, these sessions are later supplemented with additional bandwidth once the quality of their wireless channel improves. To determine how much bandwidth a session is to be supplemented, the scheduler simulates an Idealized WFQ policy in real-time and compares the actual amount of service received by a session to that it has received in simulation. Sessions which

2 have received more (less) service than in simulation are said to be leading (lagging). Leading sessions are forced to give up a part of their guaranteed bandwidth to lagging sessions to ensure long-term fairness among all sessions. Lu, Bharghavan, and Srikanth theoretically characterize their approach. If a session's wireless channel is always in a good state, then there is a bound on the maximum deviation between the actual amount of service received by a session and the amount of service received by it in the simulated WFQ policy. However, the approach has the following limitations. First, it has the large overhead of a real-time simulation of an Idealized WFQ policy to make scheduling decisions. Second, since in WFQ, the delay guarantee for a session is directly coupled to its bandwidth guarantee, the same is true for the scheduling policy in [9]. Third, since the WFQ policy does not handle link-sharing objectives, the scheduling policy in [9] cannot also deal with the link-sharing objectives. Ng, Stoica, and Zhang [10] have recently proposed an approach for adapting wireline PFQ algorithm to wireless networks. In [10], sessions are classi ed as leading, lagging, satis ed depending on the dierence between the service they have received and the service they should have received in the wireline PFQ. Sessions in the same state (i.e., leading, lagging, or satis ed) are treated fairly just as in the wireline PFQ. However, sessions in dierent states may be treated dierently. In particular, sessions in the leading state give up part of their service to compensate sessions in the lagging state. However, leading sessions whose wireless channels are in good state are still guaranteed a minimum fraction of their promised service. The basic problem addressed in [10] is similar to the one in this paper. However, the solution approach is quite dierent. The solution in this paper is based on the assumption that all sessions whose wireless channel is in a good state must receive their promised service and not a fraction of the service as in [10]. Sessions which not received adequate service due to poor quality of the wireless channel are compensated in our approach using a pre-allocated portion of the bandwidth. More speci cally, in this paper, we propose a simple approach called Server Based Fairness Approach (SBFA) which can be integrated with any PFQ policy designed for wireline networks. The fairness guarantees provided by the integrated policy will be similar to that provided by the PFQ policy into which it is integrated. As in [9, 10], the basic idea of SBFA is to supplement the bandwidth of sessions which have received reduced goodput due to poor quality of their wireless channel. To keep track of the amount of bandwidth a session is to be supplemented, SBFA creates one or more special sessions called Long-Term Fairness Servers (LTFSs). These servers share the wireless bandwidth with other sessions. However, the bandwidth allocated to a LTFS is used to supplement the bandwidth of sessions in such a way that fairness guarantees are provided to all sessions over a long time horizon. The rest of this paper is organized as follows. In Section 2, we describe problem addressed in this paper. Then, Section 3 gives an informal overview of SBFA. Formal details of SBFA are presented in Section 4. Section 5 discusses implementation issues related to the SBFA. Results from a simulation of the SBFA integrated with HFS-C are shown in Section 6. The paper concludes in Section 8.

2 Problem Statement In a wireline network, a scheduling policy is considered to be fair to all the sessions sharing a link if it has the following two properties: (i) each session is guaranteed the amount of service promised to it during session initialization, and (ii) each session gets a fair share of the excess bandwidth (i.e, bandwidth available over and above that needed to meet the rst property). As described in the introduction, the PFQ algorithms in the literature may dier in the way these two properties are formalized. However, the tradeos between the dierent formalizations are well understood for a wireline network. Unfortunately, a straight-forward application of these policies to the wireless network does not always guarantee the same notion of fairness. To better understand the reasons for this dierence consider the following two examples.

Example 1: Suppose that there are two backlogged sessions s1 and s2 sharing a wireless link. Further suppose that, the scheduler directly implements one of the PFQ algorithms designed originally for a wireline network. Now suppose that this algorithm selects a packet from session s1 for transmission and, at that time instant, the quality of the wireless channel of s1 is very poor. To be perfectly fair to s1 , the packet from s1 must be transmitted even though there is a good chance that the resulting errors in transmission will make the packet unrecoverable at the receiver. If that happens, the packet must be retransmitted resulting in a wastage of the wireless bandwidth. Therefore, to make ecient use of the wireless bandwidth, a better approach may be to defer transmission of s1 's packet and instead transmit a packet from session s2 (assuming, of course the quality of the wireless channel of s2 is in a good state). This introduces some unfairness between the sessions in accessing the wireless bandwidth because session s2 has been given a larger share of the bandwidth (at least over a short-term) than what is required for fair scheduling. Example 2: Consider a session 1 . Suppose a packet from s

needs a retransmission because its earlier transmissions resulted in errors which were not correctable at the receiver. The fair scheduling algorithms in wireline networks do not consider retransmission because the need for retransmission over a wired link is very small. Therefore, a straightforward realization of the fair scheduling algorithm will consider packets which need retransmission as any other packet waiting for transmission. However, in that case, the average delay experienced by packets in the wireless network will be considerably larger than that on a wired link of the same bandwidth. This, in turn, means that the corresponding application's perception of the wireless link will be considerably dierent than that of the wired link of same bandwidth. This means that the same notion of fairness has not been guaranteed in the wireless network as in the wireline network.

s1

The two questions which arise from the above examples are: (i) how should the scheduler remedy the unfairness between sessions caused by deferment of transmission, and (ii) how can one expedite the retransmission of packets without unfairly penalizing sessions which do not need retransmission.

3 Channel Number of possible transmissions state 1 2 3 Noisy Long code Defer Defer Good Short code Short code Short code Table 1: Example code lookup table for a session. Solutions which address the rst question are proposed in [8, 9, 10]. However, as discussed in the introduction, these solutions in [8, 9] are limited to speci c fair queueing algorithms. Furthermore, the solution in [9] requires a real-time simulation of a fair queueing algorithm, which in turn increases the overhead of scheduling. Also, neither of these three solutions address the issue of expediting the retransmission of packets. In the following two sections, we propose a simple approach called SBFA which addresses both the questions. Also, SBFA is not speci c to any particular fair queueing algorithm. It can be integrated with any of the existing fair queueing algorithms without much increase in overhead. 3 Overview of SBFA Qualitatively, the two key objectives of fair scheduling in a wireless network are: (i) to make ecient use of limited wireless bandwidth over a short time horizon, and (ii) to provide the same notion of fairness over a suciently long time horizon as in the wireline network. Presented below is an informal overview of the techniques used in SBFA to meet these two objectives. 3.1 Ecient use of wireless bandwidth Ecient use of wireless bandwidth involves reducing bandwidth wastage due to erroneous transmissions. There are two commonly used strategies for reducing this wastage. One strategy is to defer the transmission of packets from sessions whose quality of the wireless channel is poor [1, 4, 8, 9]. This approach works well for non-real-time sessions like telnet, ftp, and email. The other strategy is to make use of error-correcting codes to compensate for the errors which occur during the transmission of a packet [6, 12, 15]. This approach is suitable for real-time sessions. Since neither of these two approaches is suitable for all sessions. in this paper, we make the following general assumption. We assume that each session adopts its own appropriate combination of deferment and use of error-correcting codes for dealing with uctuations in the quality of its wireless interface. The transmission strategy of a session is speci ed to the scheduler in the form of a code lookup table whose entries specify the optimal decision for the session given the state of its wireless channel and the packet under consideration. The decision typically involves whether or not to defer transmission of the packet, and if not, which error-correcting code to use in the transmission. For example, consider the code lookup table shown in Table 1. In this table, the selection of the error-correcting code is based on the state of the wireless channel and the maximum number of possible transmissions of the packet under

consideration. For instance, if the delay requirements of the packet allow for three transmissions and if the current state of the channel is noisy, then Table 1 recommends deferring transmission of the packet (see entry in rst row, fourth column). On the other hand, if the delay requirements of the packet allows for only one transmission, then the table recommends transmitting the packet using an error-correcting code even if the state of the wireless channel is noisy (see entry in the rst row, second column). SBFA does not depend on any particular method for computing the entries in this table. Elaoud and Ramanathan describe one possible method for optimally computing the entries in this table with an objective of minimizing the bandwidth required for timely and correct delivery of packets from a given session over a wireless link [6]. 3.2 Long-term fairness As illustrated in Example 1, unfairness between sessions occurs in a wireless network because sessions may defer their transmissions when the quality of the wireless channel is poor. To remedy this unfairness, these sessions must be supplemented with additional bandwidth later. The key issue is how to eciently keep track of the sessions which need to be supplemented and the amount of bandwidth by which each session is to be supplemented. In SBFA, this bookkeeping is done using a concept called a Long Term Fairness Server (LTFS). A LTFS is a special session created for this purpose. A LTFS shares the wireless bandwidth along with other sessions. In general, more than one LTFS may be created to meet the varied needs of the sessions sharing the wireless link. However, each session is assigned to one LTFS which is then responsible for providing additional bandwidth to that session on an as-needed basis so as to maintain the long term fairness guarantees. Note that, multiple sessions may be assigned to the same LTFS. In SBFA, the scheduler maintains two queues for each session, a packet queue (PQ) and a slot queue (SQ). Let PQi and SQi respectively denote the packet and the slot queue of a session i. When a packet arrives for session i it is inserted into PQi . At the same time, an abstract entity called a slot is created with a tag i and inserted into SQi . The tag identi es the slot as belonging to session i. The scheduling policy operates on the slot queues, i.e, the scheduling policy selects a slot for transmission just as a conventional scheduler selects a packet for transmission. The tag on the selected slot identi es the session from which a packet is to be transmitted. The packet at the head of that session's queue is the leading candidate for transmission. This packet may not be transmitted because of deferment. In that case, another session is selected based on the scheduling policy and a packet from that session is transmitted. Now consider what happens following a deferment using the example shown in Figure 1. In this example, there are three sessions sharing a wireless link. In addition, there is one LTFS which is shared by all sessions. As shown in Figure 1(a), there are two packets waiting for transmission in each one of these sessions. For simplicity, assume all packets are of unit length and the fair scheduling policy is Weighted Round Robin with unit weight for all sessions and LTFS. Let us suppose that, at time 0, the scheduler has selected Session 1. Also suppose that at time 0 the quality of session 1's wireless channel is poor and therefore, its code lookup

4

Procedure Receive Packet(i, p) /* pkt p arrives for session i */ 1. Enqueue(PQi , p); 2. Create a slot s with a tag i; 3. Enqueue(SQi , s); 4. If i was not active f

PQ P12 P11 Session 1 S1

S1

SQ PQ

Update Data Structures;

P22 P21 Session 2 S2

S2

SQ

Scheduler

PQ

5.

g

Make i active;

End.

P32 P31 Session 3 S3

Figure 2: Procedure invoked when a packet is received.

S3

SQ

LTFS SQ

(a) Time 0 PQ P12 P11 Session 1 S1 SQ PQ P22 Session 2 S2 SQ

Scheduler

PQ P32 P31 Session 3 S3

S3

SQ

LTFS

S1 SQ

(b) Time 1 PQ

table recommends deferring the transmission of packet P11. The scheduler immediately selects the next active session (i.e, Session 2) and transmits the packet at the head of its packet queue (i.e., packet P21) in place of P11. Since Session 1 did not get its share of the bandwidth at time 0, a slot with tag 1 is inserted into the slot queue of the LTFS. Assuming the transmission of P21 is successful, the state of all queues at time 1 is shown in Figure 1(b). Later at time 3, when the LTFS is selected for transmission, the slot's tag refers to session 1. Therefore, at time 3, the packet at the head of session 1's queue (i.e., packet P11) is transmitted (assuming the wireless channel is in a good state). Again, at time 4, when the scheduler selects session 1, the next packet from session 1 is transmitted. Assuming all transmissions are successful, the state of queues at time 5 is shown in Figure 1(c). Notice that, session 1 has been compensated for the deferment at time 0. Also, notice that, all other sessions got their share of the bandwidth. A similar set of actions occur if a packet of session i needs retransmission. Here again, a slot is inserted into session i's LTFS with a tag indicating that it is for session i. When the slot is picked by the scheduler, a packet at the head of session i's packet queue is transmitted, thus compensating session i for the earlier incorrect transmission. Presented below is formal description of SBFA.

Session 1

4 Formal Description of SBFA

SQ PQ Session 2 SQ

Scheduler

PQ P32 P31 Session 3 S3 SQ

LTFS

S3 SQ

(c) Time 5

Figure 1: Example illustrating deferment in SBFA integrated with WRR.

To keep the description of the proposed approach general, we use two procedures Select Session and Update Data Structures which depend on the fair scheduling algorithm into which the SBFA is integrated. Given a set of backlogged sessions and the data structures containing the relevant past history of services provided to the sessions, procedure Select Session returns the next session from which a packet is to be transmitted as per the fair scheduling policy. Procedure Update Data Structure maintains the data structures used by Select Session in accordance with the rules of the fair scheduling policy. Figures 2, 3, and 4 show the pseudocode of the three key procedures in SBFA. The rst procedure called Receive Packet is invoked when a new packet arrives for a session. The second procedure called Rexmit Packet is invoked when a packet needs retransmission because it was not successfully conveyed over the wireless interface. The third procedure called Get Packet is invoked when the transmission of a

5

Procedure Rexmit Packet(i, p) /* pkt p of session i needs retransmission */ 1. r = Long Term Fair Server assigned to i; 2. Create a slot s with its session tag pointing to i; 3. Enqueue(SQr , s); 4. If r was not active f Update Data Structures; Make r active; 5.

g

End.

Figure 3: Procedure invoked when a packet needs retransmission.

packet completes or when a packet arrives into an idle system. Presented below is a more detailed description of each of these procedures. 4.1

As stated earlier, for each session, the scheduler maintains two queues, a packet queue (PQ) and a slot queue (SQ). We use PQi and SQi to respectively denote the packet queue and the slot queue of session i. When a packet arrives for session i, it is inserted into the PQi and a slot with tag i is inserted into SQi (see Steps 1{3 in Figure 2). If the SQi is empty when the packet arrives, then the session is marked active and the relevant scheduler data structures are updated (see Step 4 in Figure 2). The updates depend on the fair scheduling policy into which SBFA is integrated. 4.2

Procedure Get Packet /* Let A be the set of active sessions */ 1. i = Select Session(A); 2. s = Dequeue slot from SQi ; 3. j = Tag of slot s; 4. p = Head of PQj ; 5. c = Select code(j , p); /* from a lookup table */ 6. If c is DEFER f 6a. If A ?fj g is ; f /* no other session is active */ c = Default code of session j ; Go to step 7. 6b. Else f /* defer */ k = Select Session(A ?fj g); s = Head of SQk ; l = Tag of slot s ; p = Head of PQl ; Transmit p using default code of l; Charge session i and l for transmitting p ; Insert a slot with tag j into the SQ of LTFS of j ; If transmission was correctable f Dequeue slot from k; Dequeue packet from PQl ; 0

0

0

0

0

g

g

g

Go to step 10.

7. Transmit p using code c; 8. Charge session i for transmitting p; 9. If transmission was not correctable f Rexmit Packet(j , p);

g

Else f Dequeue packet from PQj ;

g

10. End. Figure 4: Procedure invoked when a packet is to be selected for transmission.

Receive Packet

Rexmit Packet

This procedure is invoked when the scheduler determines that a packet needs retransmission. A packet may need retransmission due to one of the following two reasons: (i) the errors which occurred during transmission were not correctable at the receiver, or (ii) the scheduler deferred transmission of the packet1 . If a packet needs retransmission, it is not removed from the corresponding packet queue. Instead a slot is inserted into the slot queue of the LTFS of the corresponding session. Speci cally, if a packet of session i needs retransmission, a slot with tag i is inserted into the SQ of LTFS assigned to session i (see Steps 1{3 in Figure 3). If the slot queue of LTFS was empty, then the LTFS is marked active and the scheduler data structures are updated (see Steps 4{5 in Figure 3). 4.3

Get Packet

This routine is invoked when a packet has to be selected for transmission. First, the scheduler selects an active session from which it expects to transmit a packet (see Step 1 in Figure 4). The selection is based on the fair scheduling policy into which SBFA is integrated. Let us suppose that i was the selected session. The scheduler removes the slot at the head of SQi . Let j be the tag in the slot and p be the packet at the head of PQj (see Steps 2{ 4 in Figure 4). Recall that, if i is not a LTFS, then j will be the same as i. Otherwise, j is the session whose bandwidth is to be supplemented. The scheduler decides whether or not to defer transmission of p based on the state of wireless channel of j and the requirements of p. If the decision is not to defer, then the scheduler also selects the error-correcting code to be used in the transmission (see Step 5 in Figure 4). If the decision is not to defer, then p is transmitted using the speci ed error-correcting code. If the transmission is successful, then p is removed from the PQj . Otherwise, 1 For retransmission purposes, a deferment of transmission is considered equivalent to a packet that was transmitted but received erroneously. Of course, no bandwidth was consumed if a transmission is deferred.

6 packet p needs a retransmission and the Rexmit Packet routine is invoked (see Steps 7{9 in Figure 4). On the other hand, if the decision is to defer, then the scheduler tries to identify another active session. The scheduler will succeed if there is at least one other active session. If these is no other active session, session j is not allowed to defer and packet p is transmitted using a default code. The rest of the actions are as if the decision is not to defer, (see Steps 6a and 7{9 in Figure 4). Now consider the case when the decision is to defer and there is at least one other active session. The scheduler selects another session k 6= j based on the fair scheduling policy. In this case, the slot at the head of SQk is not immediately removed but, just looked at to determine whom it belongs to. Let l be the tag of the slot at the head of SQk and let p be the packet at the head of PQl . Irrespective of the state of the wireless channel of l, packet p is transmitted using the default error-correcting code of session l and the scheduling data structures are updated as if it was a packet from session i. Since session j deferred its transmission Rexmit Packet is invoked to insert a slot into the LTFS of session j . This will eventually enable session j to get additional bandwidth from its LTFS. (see Step 6b in Figure 4). If the transmission of packet p was successful, then it is removed from PQl and a slot is removed from SQk . Otherwise, no further action is taken. This ensures that session l is not penalized for an unsuccessful transmission at a time when it was not originally selected for transmission. This is critical to maintain all the fairness guarantees of the fair scheduling policy.

10 Mbps Link

2 Mbps

8 Mbps

RT

128 Kbps

NRT

Audio

3 Mbps

372 Kbps 1.5Mbps

LTFS-RT

Video 30 Kbps

Audio

342 Kbps

3 Mbps

1 Mbps LTFS-NRT

1 Mbps

ftp1

telnet

ftp2

Video

0

0

0

5 Implementation Issues 5.1 Techniques to address wireless channel issues There are many implementation issues related to scheduling which are present in a wireless network but not in the wireline network. Examples of such issues are: (i) estimation of the state of a wireless channel, (ii) need for ecient acknowledgment scheme to indicate erroneous transmissions, and (iii) incomplete knowledge of packets waiting for transmission. In [9], there is an excellent discussion on solutions for addressing these issues. Most, if not all, of those solutions are also applicable to SBFA. We refer the reader to [9] for more details. 5.2 Number of LTFSs required In SBFA, there can be more than one LTFS. The number of LTFS depends on the requirements of the sessions sharing the wireless link. Since sessions assigned to a LTFS share its bandwidth, it is better to assign sessions with similar requirements to the same LTFS. For example, one approach is to create a LTFS for each administrative group. Another approach is to a create a LTFS for each type of trac, e.g., one for real-time sessions and another for non-real-time sessions. The scheduling overhead does not increase signi cantly with number of LTFS. If N is the total number of sessions sharing a link and L is total number of LTFSs, then the

Figure 5: Example of a link-sharing hierarchy with LTFS. scheduling overhead in most of the recent PFQ algorithms is O(log(N + L)) [3, 14]. 5.3 Selection of service guarantees provided to LTFS The service guarantees provided to LTFS depend on the fair scheduling policy into which SBFA is integrated. To illustrate the issues involved and the potential solutions, we discuss the integration of SBFA with three dierent fair scheduling policies, WFQ [5], H-PFQ [3], and HFS-C [14]. Integrating with WFQ: In WFQ, each session is assigned a weight which determines the fraction of bandwidth it receives when backlogged. To integrate SBFA with WFQ, each LTFS must also be assigned a weight. The weight assigned to a LTFS must be greater than its average bandwidth needs. The average bandwidth needs of a LTFS depends on the average number and size of packets which defer transmission and/or need retransmission. These factors in turn depend on the channel characteristics of the sessions, error-correcting capability of the codes used by the sessions, and the code lookup tables. Since the sum of the weights of all sessions including LTFSs cannot exceed one, the weight assigned to a LTFS reduces the total weights available for other sessions. This usually means that fewer sessions can be concurrently supported on the wireless link than what is possible using a scheme without LTFS. Integrating with H-PFQ: In Section 4, the slot queue of a LTFS was assumed to be a FIFO. If SBFA is integrated with a hierarchical fair scheduling policy such as H-PFQ, the slot queue of LTFS need not be a FIFO. Speci cally, the LTFS can be a node in the link-sharing hierarchy with one child for each session sharing it. The bandwidth allocated to LTFS can then be shared by the sessions in proportion to their weights. An example of a link-sharing tree illustrating this approach is shown in Figure 5. In this link-sharing hierarchy, there are two LTFS. One of the LTFS, labeled LTFS-RT, allocates its bandwidth in proportion to the weights of the two sessions sharing it. The other LTFS, labeled LTFSNRT, uses a FIFO to allocate its bandwidth to the three sessions sharing it. This example illustrates the exibility of SBFA integrated with H-PFQ.

7 Integrating with HFS-C: The objectives of the HFS-C policy [14] are two-fold: (i) to guarantee each session a quality of service as de ned by a generalized service curve, and (ii) to allocate the excess bandwidth (i.e., bandwidth over and above that required to meet the service curve guarantees) among sessions in fair manner. Since the service curves of sessions can be non-linear, the bandwidth and delay guarantee provided to a session can be decoupled. The support of non-linear service curves in HFS-C is especially bene cial to SBFA. The bandwidth needs of a LTFS are usually quite small because new slots are inserted into its queue only when a transmission is deferred or a retransmission is required, i.e, when a wireless channel is in a deteriorated state. However, the delay guarantees of LTFS must be comparable to that of the most stringent delayconstrained session sharing that LTFS. A concave service curve can guarantee short delays without allocating a large average bandwidth to LTFS. Another feature of HFS-C is the dual selection criteria of the scheduling policy. Basically, the scheduler rst checks whether a service curve guarantee of a session is in jeopardy of violation. If yes, the selection of the next session is based on the service guarantees. Otherwise, the selection of the next session is based on the link-sharing objective. One can exploit the dual-selection criteria of HFS-C to provide service to LTFS without any service guarantee to it. This may be advantageous in some situations because there will be no reduction in the total number of sessions which can be supported on the link; since LTFS is not provided any service guarantee (see the earlier discussion on integrating with WFQ). This, however, requires a slight modi cation to the link-sharing criteria of HFS-C as described in [14]. In particular, the link-sharing criteria must be modi ed to give LTFS a priority access to the excess bandwidth as compared to normal sessions. This can be easily done by changing the way the virtual times of sessions are updated in HFS-C. 6 Numerical Example In this section, we present the results from a discrete-event simulation of SBFA integrated with the HFS-C policy. We refer to this integrated policy as SBFA+HFS-C. The main goal of this simulation is to illustrate the various aspects of SBFA. It is not intended to be comparative evaluation of this approach with other strategies in literature. Qualitative comparisons of the SBFA with the schemes in [8, 9] were presented in the earlier sections of this paper. For all the results presented here, a wireless link of 10 Mbits/second bandwidth is shared by the following four sessions. Session 1 is an audio constant bit rate (CBR) session in which 160 byte packets are generated periodically once every 20 ms, corresponding to an average bandwidth need of 64 Kbits/second. Session 2 is a video constant bit rate session in which 6 Kbyte packets are generated periodically once every 33 ms, corresponding to an average bandwidth need of 1.457 Mbits/second. Session 3 is a non-real-time Poisson session in which 512 byte packets are generated at a rate of 1.0 packet/millisecond, corresponding to an average bandwidth need of 4.096 Mbits/second. Session 4 is a non-real-time On-O session in which 400 byte packets are generated once every 0.6 ms when On and no packets

Session 2 bits

Session 4

bits

1600

Session 3 1100

3200 100

4500

Session 1

256 5

15

19

ms

ms

(a) Sessions bits

300 3200

1000

10

ms

(b) LTFSs

Figure 6: Service curves guaranteed to the sessions and LTFSs in the simulation. are generated when O. The On and the O durations are taken from an exponential distribution. The mean On and O durations are 60 and 100 milliseconds, respectively. For simplicity, we assume that the sessions are organized in a single level hierarchy. Furthermore, the service curves guaranteed to sessions are shown in Figure 6(a). Note that, the service curve for sessions 1 and 2 are concave, while that of session 2 is convex and that of session 4 is linear. This is because the sessions 1 and 2 are real-time while session 3 and 4 are non-real-time. In addition to the four sessions, there are two LTFS, one shared by sessions 1 and 2, and the other shared by sessions 3 and 4. The service curve guaranteed to the two LTFS are shown in Figure 6(b). The concave curve is for the LTFS shared by sessions 1 and 2 and the linear curve is for the LTFS shared by sessions 3 and 4. The slope of the rst segment is chosen to meet the most stringent needs of the sessions which share them. The slope of the second segment is larger the average bandwidth demand. The wireless channels of sessions 1{3 may temporarily deteriorate in quality while that of session 4 is always in a good state. The state of the channel of sessions 1{3 are modeled using a two-state Markov chain representing the Good and the Noisy states. The time spent by a channel in the Good and the Noisy states are exponentially distributed. For sessions 1 and 2, the mean duration of Good and Noisy states are 300 and 72 milliseconds, respectively, while for session 3 they are 300 and 150 milliseconds. Moreover, sessions 1 and 2 use the code lookup table shown in Table 1 while sessions 3 and 4 always defer transmission when in Noisy state and use a short error-correcting code when in Good State. We assume transmissions which occur when a wireless channel is in a Good state are error-free. In Noisy state, the probability of a correctable transmission depends on the error-correcting code. For sessions 1 and 2, the probability

8 speci cally, we say that a wireline PFQ guarantees a service curve Si (
) to session i if the following holds. If session i is backlogged t, there exists t0 < t such that Wi (t0 ; t)  Si (t ? t0 ) where t0 is a start of a backlog period of session i and Wi (t0 ; t) is the amount of service received by session i in the interval [t0 ; t). That is, if a session is backlogged at time t, then there exists a start of a backlog period t0 (not necessarily the one containing t) such that amount of service received by the session in [t0 ; t] is greater than the amount promised to it by the service curve. Now let us suppose SBFA is based on such a wireline PFQ algorithm. Also suppose that, for each session, the quality of its wireless channel is clear for at least some duration and all transmissions during this period are error-free. Then, we can prove the following two theorems.

10000 Session 1 Session 2 Session 3 Session 4

Bandwidth share (Kbps)

8000

6000

4000

2000

Theorem 1: If a session's wireless channel is always in a 0

0

250

500 Time (ms)

750

1000

Figure 7: Bandwidth distribution among the four competing sessions. of a correctable transmission in Noisy state for the short and the long codes are respectively 0.5 and 0.9. The corresponding parameters for session 3 are 0.7 and 0.9. Figure 7 shows the bandwidth share of the four sessions in a 1000 ms snapshot in the middle of a long simulation. The snapshot was chosen to illustrate the various aspects of SBFA+HFS-C. Observe the bandwidth share of session 2. In the curve corresponding to session 2, triangles mark the time instances when the wireless channel of session 2 becomes Noisy and the circles mark the time instances when it returns to the Good state. At the start of the snapshot (i.e, reference time 0), session 2's channel has been in a Good state for a while and therefore session 2 gets approximately its promised bandwidth share of 1600 Kbps. At time 104 ms, session 2's channel becomes Noisy and there is a drop in the bandwidth share of session 2. This is because of deferment. Notice that, session 4 bene ts from this deferment and gets an increased of share of the bandwidth. At 200 ms, the LTFS of session 2 starts supplementing the bandwidth of session 2 and packets are transmitted using error-correcting codes. At time 240 ms, the session 2's channel returns to a Good state and the bandwidth share of session 2 increases even further. After the compensation is completed, the bandwidth share of session 2 returns its promised levels of 1600 Kbps. From 700 to 709 ms, the session 2's channel becomes Noisy. Again, session 2 sees an increase in the bandwidth share as a consequence of supplementation from its LTFS. At 920 ms, the bandwidth share of session 2 drops to zero because it is no longer backlogged. 7 Theoretical Results In this section, we formalize the fairness guarantees provided by SBFA. As stated earlier, its fairness guarantees depends on the underlying wireline PFQ algorithm. More

clear state, then its service curve is guaranteed just as in the underlying wireline PFQ. That is, if the session is backlogged at time t, then there exists time t0  t such that Wi (t0 ; t)  Si (t ? t0 ) where t0 is a start of a backlog period of session i and Wi (t0 ; t) is the amount of service received by session i in the interval [t0 ; t).

Proof: The proof follows from the following two observa-

tions. First, the selection of a session for service is done independent of quality of its wireless channel. Furthermore, if the channel quality is clear, then the session will not defer its transmission. Second, if a session receives service because some other session deferred its transmission, then it is not charged for this additional service; the session which deferred its transmission is charged for the service. Therefore, a session with always a clear channel receives at least as much service as it would receive in the underlying wireline PFQ. Hence the theorem. Recall that, in the SBFA approach, the LTFSs may have to be provided some service guarantees just like other sessions in the underlying wireline PFQ. We say that a LTFS has been provisioned satisfactorily, if its service guarantees are adequate to meet its long-term bandwidth needs. For example, let suppose the underlying wireline PFQ is WFQ. In WFQ, each session is guaranteed a certain fraction of the link bandwidth. Therefore, the LTFSs must also be guaranteed a certain of the link bandwidth. Further suppose that a particular session i's channel quality is not clear for say f % of the time on the average, when measured over a long time horizon. Then, the bandwidth needs of the LTFS of session i may be at least as large as f % of session i's bandwidth guarantee over this long time horizon. Therefore, with respect to session i, its LTFS is provisioned satisfactorily if the LTFS's bandwidth guarantees are at least as large as f % of session i's bandwidth guarantee. Since the LTFS may be shared by other sessions, the LTFS is provisioned satisfactorily, if its bandwidth guarantees in this case exceeds the sum of the long-term \not clear" fraction of the bandwidth guarantees of its sessions.

Theorem 2: Assume that each session's LTFS has been provisioned satisfactorily. If at time t, session i is backlogged

9 and its wireless channel is in the clear state, then there exists t0  t  t1 such that Wi (t0 ; t1 )  Si (t1 ? t0 ) where t0 is a start of a backlog period of session i and Wi (t0 ; t1 ) is the amount of service received by session i in the interval [t0; t1 ). Furthermore, the value of t1 is independent of the characteristics of the channels of other sessions.

Proof: The theorem follows from the following observation. Since the LTFS have been provisioned satisfactorily, their slot queues will become empty. When a LTFS's slot queue becomes empty, no bandwidth compensation is pending, and the service guarantees of all its sessions have been satis ed. Informally, Theorem 2 states the following. Consider a session i and a time t at which it is backlogged and its channel is in clear state. Since the quality of session i's channel may have been poor at some time before t, session i may have received less than promised service in a time window prior to t. However, there exists a time t1 in the future by which session i will be compensated for the loss of service while its channel quality was poor. That is, the service guarantees are met over a suciently long-time horizon. Furthermore, this time horizon does not depend on the other sessions. 8 Conclusions In this paper, we propose a simple approach for fair scheduling in wireless networks. This approach can be integrated with most packet fair scheduling policies originally designed for wireline networks. Since extensive research has been done on fair scheduling in wireline networks, the proposed approach makes all the existing solutions applicable to wireless networks. References [1] B. R. Badrinath and P. Sudame. To send or not to send: Implementing deferred transmissions in mobile hosts. In Proceedings of International Conference on Distributed Computing Systems, pages 327{333, May 1996. [2] J. C. R. Bennett and H. Zhang. WF2 Q: Worst-case fair weighted fair queueing. In Proceedings of INFOCOMM, pages 120{128, March 1996. [3] J. C. R. Bennett and H. Zhang. Hierarchical packet fair queueing algorithms. IEEE/ACM Transactions on Networking, 5(5):675{689, October 1997. [4] P. Bhagwat, A. Krishna, and S. Tripathi. Enhancing throughput over wireless LANs using channel state dependent packet scheduling. In Proceedings of INFOCOM, pages 1133{1140, March 1996. [5] A. Demers, S. Keshav, and S. Shenker. Analysis and scheduling of a fair queueing algorithm. In Proceedings of SIGCOMM, September 1989.

[6] M. Elaoud and P. Ramanathan. Adaptive use of errorcorrecting codes for real-time communication in wireless networks. In Proceedings of INFOCOM, pages 548{ 555, March 1998. [7] S. Flyod and V. Jacobson. Link-sharing and resource management models for packet networks. IEEE/ACM Transactions on Networking, 3:365{386, August 1995. [8] C. Fragouli, V. Sivaraman, and M. Srivastava. Controlled multimedia wireless link sharing via enhanced class-based queuing with channel-state dependent packet scheduling. In To appear in Proceedings of INFOCOM, March 1998. [9] S. Lu, V. Bhargavan, and R. Srikant. Fair scheduling in wireless packet networks. In SIGCOMM, September 1997. [10] T. S. E. Ng, I. Stoica, and H. Zhang. Packet fair queueing algorithms for wireless networks with location dependent errors. In Proceedings of INFOCOM, pages 1103{1111, March 1998. [11] A. K. Parekh and R. G. Gallager. A generalized processor sharing approach to ow control in integrated services networks: The single node case. IEEE/ACM Transactions on Networking, 1:344{357, June 1993. [12] Y. Ryu, S. C. Kime, I. Song, S. I. Park, and K. M. Kim. Adaptive change of code rate in DS-SSMA communication systems. In Proceedings of International Symposium on Signals, Systems, and Electronics, pages 199{ 202, October 1995. [13] H. Sariowan, R. L. Cruz, and G. C. Polyzos. Scheduling for quality of service guarantees via service curves. In Proceedings of ICCCN, pages 512{520, September 1995. [14] I. Stoica, H. Zhang, and T. S. E. Ng. A hierarchical fair service curve algorithm for link-sharing, real-time, and priority services. In SIGCOMM, September 1997. [15] S. Yajnik, J. Sienicki, and P. Agrawal. Adaptive coding for packetized data in wireless networks. In Proceedings of Personal, Indoor, and Mobile Radio Communications, September 1995.