A Distributed Scheduling Algorithm to Provide Quality-of-Service in Multihop Wireless Networks

TL;DR

This paper introduces a distributed scheduling algorithm for multihop wireless networks that ensures quality-of-service by managing end-to-end delays through an iterative, gradient-based optimization with minimal communication.

Contribution

It presents a novel distributed algorithm leveraging fluid limit theory and discrete review to meet delay requirements with minimal inter-node information exchange.

Findings

Algorithm effectively manages delay constraints in multihop networks.

Uses iterative gradient ascent for distributed optimization.

Performs well under interference modeled by independent sets.

Abstract

Control of multihop Wireless networks in a distributed manner while providing end-to-end delay requirements for different flows, is a challenging problem. Using the notions of Draining Time and Discrete Review from the theory of fluid limits of queues, an algorithm that meets delay requirements to various flows in a network is constructed. The algorithm involves an optimization which is implemented in a cyclic distributed manner across nodes by using the technique of iterative gradient ascent, with minimal information exchange between nodes. The algorithm uses time varying weights to give priority to flows. The performance of the algorithm is studied in a network with interference modelled by independent sets.

Tables

Table 1. TABLE I : Two Flows with mean delay requirement

Mean Delay(slots)
Flow 7			Flow 8			Flow 9
Target	Achieved		Target	Achieved		Delay	Delay
Mean Delay	with $\hat{\theta }=6$	with $\hat{\theta }=7$	Mean Delay	with $\hat{\theta }=6$	with $\hat{\theta }=7$	with $\hat{\theta }=6$	with $\hat{\theta }=7$
50	51	51	30	32	33	318	275
40	40	40	25	26	28	253	196
30	32	30	20	22	21	172	165
25	30	26	15	18	15	145	147

Table 2. TABLE II : One mean delay and one hard deadline

Flow 7		Flow 8		Flow 9
Hard Delay Target(slots), Drop Ratio Target	Drop Ratio Achieved	Mean Delay Target (slots)	Mean Delay Achieved (slots)	Mean Delay (slots)
180,2%	2%	50	51	136
180,2%	2%	40	43	100
180,2%	2%	35	36	89
160,2%	2%	45	45	88
140,2%	2%	30	33	91
120,2%	2%	35	37	94

Equations

$$Q_i^f(t)=Q_i^f(0)+\sum _{s=0}^{t-1}(A_i^f(s)+\sum _{k\ne i}{S}_{ki}^f(s)-\sum _{j\ne i}{S}_{ij}^f(s))$$

$$\frac{d^{+}}{dt}{q}_i^f(t;x_i^f)={\lambda }_i^f+\sum _{k\ne i}{\zeta }_{ki}^f(t){\mu }_{ki}-\sum _{j\ne i}{\zeta }_{ij}^f(t){\mu }_{ij}$$

$$q(t;x)=\max (x-(\mu -\lambda )t,0).$$

$$\tau =\frac{x}{\mu -\lambda }.$$

$$x_i^f+{\lambda }_i^f\tau +\sum _{k\ne i}{\mu }_{ki}{\int }_0^{\tau }{\zeta }_{ki}^f(t)dt-\sum _{j\ne i}{\mu }_{ij}{\int }_0^{\tau }{\zeta }_{ij}^f(t)dt=0.$$

$$\tau =\frac{x_i^f}{{\sum }_{j\ne i}{\mu }_{ij}{\zeta }_{ij}^f-{\lambda }_i^f-{\sum }_{k\ne i}{\mu }_{ki}{\zeta }_{ki}^f}.$$

$$D_i^f=\frac{x_i^f}{{\sum }_{j\ne i}{\mu }_{ij}{\zeta }_{ij}^f}.$$

$$\max \sum _{i,f}\frac{w_i^f}{D_i^f},$$

$$\max \sum _{i,f}{\theta }^f{x}_i^f\sum _{j\ne i}{\zeta }_{ij}^f{\mu }_{ij}.$$

$$\max \sum _{i,j,f}{\theta }^f{x}_i^f{\zeta }_{ij}^f{\mu }_{ij},$$

$$s.t0\le {\zeta }_{ij}:=\sum _{f\in F}{\zeta }_{ij}^f\le 1\forall ij,$$

$$0\le {\zeta }_{ij}+{\zeta }_{kl}\le 1,\forall (i,j),(k,l)\in I_m,\forall m.$$

$$\underset{\text{s}\in \mathcal{S}}{\max }\sum _{k\in \mathcal{K}}{f}_k(\text{s})$$

$${\text{s}}_{j+1}={\Pi }_{\mathcal{S}}({\text{s}}_j+{\alpha }_j\nabla f_{k_j}({\text{s}}_j)),$$

$$\nabla f_{k_j}({\text{s}}_j)=w_{k_j}{\mu }_{k_j}\text{v}(k_j).$$

$${\text{s}}_j^{{}^{\prime }}={\text{s}}_j+{\alpha }_j{w}_{k_j}{\mu }_{k_j}\text{v}(k_j).$$

$${\text{s}}_{j+1}={\Pi }_{\mathcal{S}}({\text{s}}_j^{{}^{\prime }}).$$

$$⟨\text{s},{\mathbf{\nu }}^i⟩\le {\beta }_i.$$

$$s_1+s_2+s_4\le 1$$

$$⟨\text{s},{\mathbf{\nu }}^j⟩\le {\beta }_j,$$

$$⟨\text{s},{\mathbf{\nu }}^v⟩\le {\beta }_v.$$

$${\beta }_v^{\ast }\triangleq ⟨{\text{s}}^{{}^{\prime }},{\mathbf{\nu }}^v⟩>{\beta }_v.$$

$${\text{s}}^{{}^{\prime \prime }}={\text{s}}^{{}^{\prime }}-({\beta }_v^{\ast }-{\beta }_v){\mathbf{\nu }}^v.$$

$$⟨{\text{s}}^{{}^{\prime \prime }},{\mathbf{\nu }}^v⟩$$

$$={\beta }_v^{\ast }-({\beta }_v^{\ast }-{\beta }_v)={\beta }_v.$$

$$⟨{\text{s}}^{{}^{\prime \prime }},{\mathbf{\nu }}^w⟩$$

$$s_1+s_2+s_4\le 1,$$

$$s_1=s_1-\frac{s-1}{3},s_2=s_2-\frac{s-1}{3},s_4=s_4-\frac{s-1}{3}.$$

$$f(\text{s}):=\sum _{k\in \mathcal{K}}{f}_k(\text{s}),f^{\ast }:=\underset{\text{s}\in \mathcal{S}}{\max }\sum _{k\in \mathcal{K}}{f}_k(\text{s}).$$

$$\underset{j\to \infty }{\lim }\sup f({\text{s}}_j)\ge f^{\ast }-c_3,$$

$$T_{rev}=t+a_1\log (1+a_2\sum _{i,f}{Q}_i^f(t)),$$

$$\text{s}(1)=\text{s}(1)+\alpha w(1)\mu (1).$$

Full text

I Introduction and Literature Review

A multihop wireless network consists of nodes communicating data to each other through time varying, stochastic wireless channels. A network controller has to make decisions about the routing of flows, scheduling of links and the power control at each node, subject to various constraints. The controller may be a single node, making a centralized decision after accessing all the relevant information. Alternatively, the control process may be localized, with nodes making decisions about themselves in a distributed manner. While distributed algorithms are attractive from an implementation perspective, they may not always catch up with the centralized algorithms in terms of performance. In many general network scenarios, however, the centralized control problem may itself be intractable, and there is a need for suboptimal algorithms that are easily implementable [1].

Providing Quality-of-Service (QoS) is a central theme in network literature. Flows may demand different kinds of QoS depending on the application which generated them. Some applications may require a guarantee on the end-to-end mean delay, whereas others, such as live streaming, may require a hard guarantee on the deadline. Some other applications may ask for a minimum bandwidth to be guaranteed at all times. In the large queue length regime, one approach to provide mean delays is to translate these requirements in terms of effective bandwidth and effective delay from Large Deviations theory, and obtain solutions in the physical layer; in [2], the authors use this technique for a K-user downlink scenario. Such techniques, however, cannot be applied easily in the multihop context, owing to the complex coupling between the queues, which makes it difficult to have a simplified one-to-one translation between delay requirements and control actions[3].

Another approach to network control is to consider throughput optimal algorithms [4] which use backpressure. Such algorithms stabilize the network for any arrival rate inside the network capacity region. However, backpressure based algorithms may not have good delay performance, especially under light loads [5, 6]. In [7], an algorithm is proposed that improves the energy-delay trade-off in a queue by intelligent dropping of packets.In [8] the authors use a weighted backpressure scheme to provide improvements in performance metrics such as delay, over traditional backpressure systems. Using Markov Decision Processes (MDPs) [9] has been another approach to provide QoS, in the single hop as well as multihop context [10]. In general settings, however, MDPs are not easy to handle owing to the huge size of the state space. Control based on Lyapunov Optimization is quite popular in the multihop network setting [11]. In [12] the authors study the problem of minimizing power while simultaneously providing hard deadline guarantees in a wireless network. In [13] the authors devise a randomized algorithm which provides targeted mean delay and hard deadline for flows in a multihop setting under the SINR model.

One way to construct tractable models of networks is to use the notion of fluid limits. A comprehensive treatment of the theory and techniques used in fluid control is available in [14]. The idea is to establish a suitable scaling under which the network converges to a simpler, deterministic fluid network, in which the various processes can be modelled by systems of ordinary differential equations (ODEs). One then obtains control policies at the level of these ODEs, and translates them to the actual network setting. A number of results are available that relate the performance of the fluid control to the control of the actual stochastic system [15]. A continuous control policy can be built from the fluid model by means of the technique of discrete review [16, 17]. Here, the network is reviewed at certain points in time, and control decisions, as well as the next review instant, are calculated based on the system state at the review instants. A scheduling algorithm based on draining time was proposed in [18]. The authors consider a network without interference constraints, and are able to obtain stability results for simple models. They also note that obtaining stability results in the general case may be difficult. In [19], the authors develop a robust fluid model, which adds stochastic variability to the deterministic fluid process, and develop a polynomial time algorithm to solve the network control problem.

Incremental Gradient methods [20] have been used in neural networks and other areas, especially for implementing distributed optimization. Here, in order to optimize a separable sum of functions, the gradient of each constituent function is taken iteratively, instead of calculating the gradient of the sum function. This leads to a separable iterative process that leads to the optimal point in the limit. Our main contributions in this paper are summarised below.

• •

We propose an optimization problem motivated by the draining time of the fluid model associated with the network. A draining time based scheduling algorithm is considered in [18], but there is no interference, and the function being optimized is different. In [10] the authors provide end to end hard deadline guarantees by solving the dual problem of an appropriate MDP. However, their model has unreliable links but no interference constraints.

• •

The control variables that appear in the optimization are given time varying weights, in order to give priority to flows whose delay requirements have not been met.

• •

The optimization is to be solved at review instants, and the control variables obtained at the beginning of a review instant are used till the next review instant. This makes it less computationally intensive than algorithms that require computations to be done at each time slot, such as in [8] or [13]; [13] also uses a different interference model. Discrete review is used in works such as [17], but for open queuing networks; moreover, the implementation is centralized and they do not consider delay deadlines.

• •

We use iterative gradient ascent to obtain a distributed algorithm in order to solve the optimization problem. This can be implemented easily in a cyclic manner, with message passing between the nodes after each step. We also show how the projection step involved in the optimization can be done by messaging between links that share a node.

• •

The algorithm only requires whether the delay constraint has been met at the flow destination at each review instant, apart from the local state information. We do not need to compute metrics over paths, as in [12]. Also, the algorithm in [12] is not fully distributed.

The rest of this paper is organized as follows. In Section II, we describe the system model, and provide the corresponding Fluid Model, as well as formulate the optimization problem for our QoS problem. In Section III we develop a distributed algorithm to solve this problem. We provide the simulation results in Section IV, followed by the conclusion in Section V.

II System Model

We consider a multihop network (Fig. 1), given by a graph $G=(V,E)$ where $V=\{1,2,..,N\}$ is the set of vertices and $E$, the set of links on $V$. We assume a slotted system, with the discrete time index denoted by $t\in\{0,1,2,...\}$. We have directional links, with link $(i,j)$ from node $i$ to node $j$ having a time varying channel gain $\gamma_{ij}(t)$ at time $t$. At each node $i$, $A_{i}^{c}(t)$ denotes the i.i.d process of exogenous arrival of packets destined to node $c$, with mean arrival rate $\lambda_{i}^{c}=\mathbb{E}[A_{i}^{c}(t)]$. All traffic in the network with the same destination $c$ is called flow $c$; the set of all flows is denoted by $F$. Each flow has a fixed set of routes to follow to its destination. At each node there are queues, with $Q_{i}^{c}(t)$ denoting the queue length at node $i$ corresponding to flow $c\in F$. The queues evolve as

[TABLE]

where $S_{mn}^{f}(s)$ denotes the number of packets of flow $f$ that are transmitted from node $m$ to node $n$ in time slot $s$. Each node transmits at a fixed power $p$. The rate of transmission between node $i$ and node $j$ is $\mu_{ij}(t)=f(p,\gamma(t))$ where $f$ is some achievable rate function.

We will assume that the links are sorted into $M$ interference sets $I_{1},I_{2},\dotsc,I_{M}$. At any time, only one link from an interference set can be active. A link may belong to multiple interference sets. In this work we will assume that any two links which share a common node will fall in the same interference set.

II-A Fluid Model

The fluid model is an ODE approximation to the evolution of the queue. Under appropriate scaling, the queue evolution in equation (1) converges[14] to the fluid equation given by

[TABLE]

where $\frac{d^{+}}{dt}$ denotes the right derivative, which is the derivative limit taken from the right, and $q_{i}^{f}(0;x_{i}^{f})=x_{i}^{f}$ is the initial condition, and $\zeta_{ij}^{f}$ corresponds to a fluid flow from node $i$ to node $j$, of flow $f$. This models the queue as a continuous time, deterministic process with continuous arrival and departure processes. For the fluid model, the draining time of a queue is defined to be the time to empty that queue. Consider the evolution of a fluid queue which has initial state $x$ and has arrivals at rate $\lambda$ and service at rate $\mu(>\lambda)$, given by

[TABLE]

The draining time in this case is given by

[TABLE]

Draining time captures in some sense the delay associated with a flow. It is the time that an arrival at time $t=0$ would have to wait before it gets served, assuming first-in-first-out service discipline. In a multihop network, the draining time will be given by the smallest $\tau$ that solves the equation

[TABLE]

Assuming $\zeta_{ij}^{f}(t)=\zeta_{ij}^{f}$ for all $t$, we obtain

[TABLE]

Calculating this requires knowledge of arrival rates as well as the scheduling decisions of other nodes. Hence, this term is not easy to calculate locally at a queue $q_{i}^{f}$. Therefore, we define a pseudo draining time, given by

[TABLE]

This $D_{i}^{f}$ is a lower bound to $\tau$. The draining time of the queue $q_{i}^{f}$ would have been $D_{i}^{f}$ if the queue had no inflow, and was serving at constant rate $\sum_{j\neq i}\mu_{ij}\zeta_{ij}^{f}$. Consider the optimization

[TABLE]

where $w_{i}^{f}$ is a weight corresponding to flow $f$ on node $i$. Choosing $w_{i}^{f}=\theta^{f}(x_{i}^{f})^{2}$, we obtain the problem

[TABLE]

Defining $\mu_{ii}=0$ for all $i$, we can rewrite this as

[TABLE]

where the first constraint corresponds to the fact that only one flow can be scheduled across a link, and the second constraint corresponds to interference constraints on the links. This is also the standard weighted-rate maximization problem [21], with the weight given to rate $\mu_{ij}$ being $\sum_{f}\theta^{f}x_{i}^{f}\zeta_{ij}^{f}$.

We will use the technique of discrete review (See [17], [14] for discussions). This involves an increasing sequence of times $0\leq T_{1}<T_{2}\dotsc$, at which we make control decisions for the network, based on the optimization problem (2)-(4). We solve the fluid problem, and obtain scheduling variables corresponding to those fluid variables, at every review instant. In the time frame $[T_{i},T_{i+1}]$, we will assume that the channel gain is fixed (slow-fading), but drawn as an i.i.d sequence from a distribution. Each node transmits at power $P$. The rate $\mu_{ij}=\log(1+\frac{\gamma_{ij}P}{\sigma^{2}})$. Consider a packet of flow $f$ which arrives at node $i$ at the beginning of a review period. Such a packet observes a backlog of $x_{i}^{f}$ in its queue. The total service allocated to flow $f$ over link $(i,j)$ in that period is $\zeta_{ij}^{f}(T_{i+1}-T_{i})$ where $\zeta_{ij}^{f}\leq 1$. The times are chosen as $T_{i+1}-T_{i}=a_{1}\log(1+a_{2}\sum_{i,f}Q_{i}^{f}(T_{i}))$. We will also be using safety stocks [14] to ensure that there is no starvation of resources in the network. These are thresholds below which each queue is not allowed to go.

II-B Providing Quality-of-Service

We will be solving the optimization problem defined by equations (2)-(4) at every discrete review instant. In order to take care of QoS constraints, we will let $\theta^{f}$ vary dynamically. At a review instant, and flow $f_{1}$ requires its mean delay to be less than or equal to $d_{1}$. At the destination node of $f_{1}$, we estimate empirically the mean delay of flow $f_{1}$ up to the last review period, and if it is greater than $d_{1}$, we set $\theta^{f}=\hat{\theta}>1$. Otherwise, $\theta^{f}=1$. Thus the control variables corresponding to the flows that require QoS obtain higher weight in the optimization problem. For a hard deadline guarantee flow, we have two parameters, the hard deadline and the drop ratio, which is the percentage of packets we are willing to allow with delays larger than the hard deadline. At every review instant, at the destination of that flow, we check whether the percentage of packets that have arrived with delays larger than the deadline, exceeds the drop ratio. If yes, we set the corresponding $\theta^{f}=\hat{\theta}$. In the next section we will provide a distributed algorithm for the optimization problem defined by equations (2)-(4).

III Distributed Optimization

Define the set of all link-flow pairs $((i,j),f)$ as $\mathcal{K}$. For any $k\in\mathcal{K}$, there exists a link $(i(k),j(k))$ and a flow $f(k)$. A schedule is a vector s of length $|\mathcal{K}|$, with each element $\textbf{s}(k)$ corresponding to the fraction of time that link $(i(k),j(k))$ transmits flow $f(k)$. Define the feasible set $\mathcal{S}$ to be the set of schedules that satisfy constraints (3) and (4); however, we remove the positivity constraint. Note that this changes the search space, but does not change the optimal value or the optimal point, since the quantity being maximized is a weighted sum of $\zeta_{ij}^{f}$ with positive weights. The set $\mathcal{S}$ will be a convex polytope, owing to the fact that it is generated by linear inequalities, and will be a closed subset of $\mathbb{R}^{|\mathcal{K}|}$.

We can rewrite equations (2) through (4) as

[TABLE]

with $f_{k}(\textbf{s})=w_{k}\mu_{k}\textbf{s}(k)$, $w_{k}=\theta^{f(k)}x_{i(k)}^{f(k)}$, $\mu_{k}=\mu_{i(k)j(k)}$ and $\textbf{s}(k)=\zeta_{i(k)j(k)}^{f(k)}$.

III-A Incremental Gradient Ascent

In order to optimize (5), we will use the incremental gradient method [20]. This involves the iteration

[TABLE]

with $k_{j}=j\ \text{modulo}\ |\mathcal{K}|+1$, and $\Pi_{\mathcal{S}}$ denotes projection onto the set $\mathcal{S}$. Let $\textbf{v}(r)$ denote a vector which is one only at its $r$th index and zero elsewhere. We can write

[TABLE]

Hence we may write the gradient ascent equation as

[TABLE]

Following this, we do the projection, to obtain the new point

[TABLE]

III-B Projection

Since interference exists between any two links that share a common node, any update of the optimization variables at a link will affect only those links which share a node with it. The constraint set $\mathcal{S}$ is a polytope, which is defined by the intersection of half-spaces $\{\mathcal{H}_{i}\}_{i=1}^{M}$, where each half-space $\mathcal{H}_{i}$ is characterized by an equation of the form

[TABLE]

where $\boldsymbol{\nu}^{i}$ is the unit normal vector to the plane, with $||\boldsymbol{\nu}^{i}||_{2}=1$. For example, the interference constraint

[TABLE]

can be represented by

[TABLE]

where $\boldsymbol{\nu}^{j}=\frac{1}{\sqrt{3}}\sum_{n=1,2,4}\textbf{v}(n)$, and $\beta_{j}=\frac{1}{\sqrt{3}}$. Due to the nature of our constraints, $\boldsymbol{\nu}^{i}$ will have only non-negative components. Each of these half-spaces corresponds to exactly one interference constraint.

In step (6), we update one component $\textbf{s}(k)$ of s, which corresponds to a link flow pair $(i(k),j(k)),f(k)$. There are two half-space constraints, corresponding to links connected to $i(k)$ and $j(k)$; let these be $\mathcal{H}_{v}$ and $\mathcal{H}_{w}$. Fig. 2(a) shows the case in which equation (6) violates $\mathcal{H}_{v}$ but not $\mathcal{H}_{w}$, moving from $\mathcal{S}$ to $C$. The perpendicular projection on the boundary of $\mathcal{H}_{v}$ is $\textbf{s}^{{}^{\prime\prime}}$. After (6), if the point moves to $D$, projection can be done repeatedly, first on $\mathcal{H}_{v}$ and then on $\mathcal{H}_{w}$, and so on. It can be shown [22, Theorem 13.7] that this iterative projection converges to the projection of the point onto $\mathcal{H}_{v}\cap\mathcal{H}_{w}$. Three steps of this iterative process are depicted in Fig. 2(b). We will now obtain the analytical expressions for projecting a point onto a hyperplane. Let $\mathcal{H}_{v}$ be defined by

[TABLE]

Let the point $\textbf{s}^{{}^{\prime}}$ be such that

[TABLE]

Hence it lies outside $\mathcal{S}$. Let us define

[TABLE]

Observe that $\textbf{s}^{{}^{\prime\prime}}$ is the orthogonal projection of $\textbf{s}^{{}^{\prime}}$ onto $\mathcal{H}_{v}$.

[TABLE]

Since $\textbf{s}^{{}^{\prime}}-\textbf{s}^{{}^{\prime\prime}}=(\beta_{v}^{*}-\beta_{v})\boldsymbol{\nu}^{v}$, and $\boldsymbol{\nu}^{v}$ is normal to the plane boundary of $\mathcal{H}_{v}$, it follows that the projection step (8) projects the point perpendicularly onto $\mathcal{H}_{v}$. We show below that the projection does not break any additional hyperplane constraints.

Proposition 1**.**

If $\langle\textbf{s}^{{}^{\prime}},\boldsymbol{\nu}^{w}\rangle\leq\beta_{w}$, then $\langle\textbf{s}^{{}^{\prime\prime}},\boldsymbol{\nu}^{w}\rangle\leq\beta_{w}$.

Proof.

[TABLE]

Since $\boldsymbol{\nu}^{w}$ and $\boldsymbol{\nu}^{v}$ are non-negative, and $\beta_{v}^{*}>\beta_{v}$, we have $(\beta_{v}^{*}-\beta_{v})\langle\boldsymbol{\nu}^{v},\boldsymbol{\nu}^{w}\rangle\geq 0$, and consequently, $\langle\textbf{s}^{{}^{\prime\prime}},\boldsymbol{\nu}^{w}\rangle\leq\beta_{w}$. ∎

Hence, if a point breaks just one hyperplane constraint and no other, the projection step (8) projects the point back on $\mathcal{S}$.

Consider an example. If the interference constraint is

[TABLE]

the projection step (8) is equivalent to

[TABLE]

where $s=s_{1}+s_{2}+s_{4}$.

III-C Convergence

Let us define

[TABLE]

We have the following theorem for the convergence of the distributed algorithm.

Theorem 1**.**

If $\max_{i,j,f}\theta^{f}\mu_{ij}\leq c_{2}$, the algorithm defined by the update equation (6) followed by the projection (7) results in a sequence of points $\{\textbf{s}_{n}\}$ such that

[TABLE]

where $c_{3}=\frac{\alpha\beta|\mathcal{K}|^{2}c_{2}^{2}}{2}$ with $\beta=4+\frac{1}{|\mathcal{K}|}$.

Proof.

See [20]. ∎

We describe the algorithm below.

III-D Algorithm Description

The algorithm proceeds in review cycles. At every slot $t$ that is the beginning of a review cycle, the nodes calculate the number of slots till the next review slot by

[TABLE]

where $a_{1}$ and $a_{2}$ are constants. At the beginning of a review cycle, the nodes calculate the variables $\zeta_{ij}^{f}$ for all $i$, $j$ and $f$, and use these till the end of the review cycle. We will now describe how the $\zeta_{ij}^{f}$ variables are calculated at each node.

The vector s is initialized to all ones. The calculation proceeds cyclically. The node which has the flow corresponding to the first component of the vector s will do the update

[TABLE]

Here $w(1)=\theta^{f(1)}x_{i(1)}^{f(1)}$, with $\theta=1$ if the QoS constraint of flow $f(1)$ was satisfied in the previous review cycle; otherwise, it is set to be equal to a value $\hat{\theta}$. The node then calculates the inner products

[TABLE]

where $\boldsymbol{\nu}^{l},\boldsymbol{\nu}^{2}$, correspond to the two interference constraints that the update step may break. If one of these constraints is broken, the update can be projected back in a single step. If both are violated, we will have to go for the iterative projection method. For projection on a plane characterized by $\langle\textbf{s},\boldsymbol{\nu}^{i}\rangle=\beta_{i}$, the node calculates $\beta_{ex}=\frac{\beta_{i}^{*}-\beta_{i}}{N_{v}}$ where $N_{v}$ is the number of links in that interference set. The node communicates this value to all links in its interference set. All these nodes, as well as the current node, update their values as

[TABLE]

This is the projection step. Once the required number of projections is over, the node then passes its $s(1)$ to the node which has the next component of the vector s, and that node updates its value of $\textbf{s}(1)$. The next node now repeats the update and projection steps, and passes its update to its neighbour. This process is repeated cyclically, i.e, we repeat step (9) with 1 replaced by 2, and then by 3 and so on, across the nodes till a predetermined stopping time is reached. At the end of the stopping time, we set all the negative components of s to zero. For each interference set $I$, we check its constraint

[TABLE]

If not, we apply the update

[TABLE]

This will ensure compliance with the constraints. The complete algorithm is given below, as Algorithm 1, which uses in turn, Algorithms 2, 3 and 4. The last algorithm creates the schedule by scheduling flows on a link for a fraction of time equal to the corresponding $\textbf{s}(k)$.

IV Simulation Results

We consider a 10 node network, with connectivity as depicted in Fig. 3(a), on a unit area, and Rayleigh distributed channel gains with parameter proportional to the inverse of the square of the distance between the nodes. The source-destination pairs are from node 0 to node 9, node 1 to node 7, node 5 to node 7, node 2 to node 8 and node 4 to node 9 with fixed routes being $0\to 1\to 3\to 7\to 9$, $0\to 4\to 9$ and $0\to 2\to 6\to 8\to 9$ for the first flow, $1\to 3\to 7$ for the second, $5\to 7$ for the third, $2\to 6\to 8$ for the fourth and $4\to 9$ for the last. A packet is of size one bit. Nodes transmit with unit power.

We will first study the performance of the algorithm with the number of iterations of the distributed algorithm as parameter. We fix $\alpha=0.0001$, and the arrival process is Poisson with rate 3.3 corresponding to the flows from nodes 0 to 9, 1 to 7, 2 to 8, 4 to 9, and 5 to 7 respectively. The safety stock value is set to be 5 for all queues, and the simulation runs for $10^{5}$ slots. The constants $a_{1}$ and $a_{2}$ in Algorithm 1 are set to 1.

In Fig. 3(b) we plot the variation of mean delay of three flows in the network while we vary the number of iterations of the distributed algorithm. One iteration is equivalent to the completion of the update and project step at all the nodes. Since mean delay is directly proportional to mean queue length, it is evident that as the number of distributed iterations increases, the system has a lower mean queue length. From the simulations, around 5 rounds of iterations seem to be sufficient, and there is no major improvement in mean delay after that. There is, however, a marginal increase in the delay when the iterations increase further, to around 15. This is probably owing to the error accumulation as a result of the finite truncation of the iterative steps. Another parameter of interest is the number of rounds of iterative projection, $N\_{rep}$. From simulations, it seems that 2 to 4 rounds are sufficient.

We consider the case where we are trying to provide end-to-end mean delay guarantees to two flows: those destined to nodes 7 and 8 (Table I). The arrival rate is 3.3 packets/slot for all arrivals. We study two cases, with $\hat{\theta}$ equal to 6 and 7. Using a higher weight, we are able to give tighter delay guarantees. However, a lower weight puts less strain on the other flows. Also, we see that as the delay constraint becomes tighter, the delay of the non QoS flow decreases. This is because while a given priority weight $\theta^{f}$ reserves resources for a QoS flow, if the delay required is smaller, the flow will have a smaller mean queue length, which will result in higher weight being given to non QoS flows in review periods where the delay criterion is satisfied, since the optimization function (2) is proportional to the queue length. Here $T_{s}=8$ and $N\_rep=10$.

In Table II, we demonstrate how to provide hard delay guarantee for flow 7 and mean delay guarantee for flow 8. The weights $\hat{\theta}$ for flows 7 and 8 are 2 and 1.5. For flow 7, the packet is dropped at the destination if its deadline is not met. We have set a target of $2\%$ for such packets. We see that packets of flow 7 meet this target for the different deadlines fixed. The mean delay requirements of flow 8 are also met.

V Conclusion

We have developed a distributed algorithm to provide Quality-of-Service requirements in terms of end-to-end mean delay guarantees and hard deadline guarantees to flows in a multihop wireless network. The algorithm optimizes, in a distributed fashion, a function with distributed weights given to pseudo draining times, with the weights varied dynamically to provide priority for flows in the network, and consequently, meeting their respective delay constraints. We use iterative gradient ascent and distributed iterative projection methods in order to compute the optimal point in a distributed manner. By means of simulations we establish the efficacy of the algorithm in providing the required delay demands. We also see via simulations that the algorithm converges quickly.