format: text

text:
# Source Routing and Scheduling in Packet Networks Partially supported by DIMACS funding. A preliminary version of this paper appeared in the Proceedings of the 42th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2001.

## 1 Introduction

Two of the most important problems in the control of packet-switched networks are routing and scheduling. The goal of routing is to assign a path to a packet from its source to its destination. The goal of scheduling is to deal with the contention that occurs when two or more packets wish to cross a link simultaneously. Each link must have a scheduler that resolves this contention by deciding which packet to advance.

The scheduling problem typically assumes that the paths of the packets are given as part of the input. The goal is then to schedule the packets along their paths in such a way that they all reach their destinations in a short time. Much recent work has focused on the Adversarial Queueing Model, e.g. . We follow their convention and assume that all packets are unit size and each link processes one packet per time step. In this Adversarial Queueing Model, the adversary chooses the injection time, source, destination, and route for each packet injected. A sequence of injections is called $`(w,r)`$-admissible for a window size $`w`$ and injection rate $`r<1`$, if in any time interval of $`Tw`$ the total number of packets injected into the network whose paths pass through any link $`e`$ is at most $`Tr`$. These paths are also called $`(w,r)`$-admissible. Previous work has examined the performance of a number of simple scheduling protocols in this model. A packet scheduling protocol is said to be universally stable if it guarantees bounded buffer sizes and packet transmission delays for any $`(w,r)`$-admissible injections. In  it was proved that several natural protocols (Longest-In-System, Shortest-In-System, Furthest-To-Go) are universally stable, whereas several others (First-In-First-Out, Last-In-First-Out, Nearest-To-Go) are not.

In this paper we study both routing and scheduling. The adversary no longer specifies the route of each packet; it merely specifies the source and destination. However, we are guaranteed that $`(w,r)`$-admissible paths for the injections do exist. The problem is now two-fold. We first need to find some $`(W,R)`$-admissible paths, possibly for a different window size $`W`$ and a different $`R<1`$. These admissible paths combined with a universally stable scheduling scheme, such as the ones in  or the one presented in Section 3 of this paper, result in a universally stable protocol for routing and scheduling.

### 1.1 Source Routing for Stability

#### Our result.

In Section 2 of the paper we present the first online algorithm for assigning admissible routes to packets. If the adversary can assign $`(w,r)`$-admissible routes, then our algorithm finds a set of $`(W,R)`$-admissible routes where $`R(r,1)`$ is of our choice and $`Ww`$ is determined by the choice of $`R`$. Hence, if the parameter of merit is the window size $`w`$, then our algorithm is a $`W/w`$-approximation algorithm (modulo a small increase in the rate). Moreover, our algorithm is online in that it assigns routes to packets as soon as they are injected into the network. Hence it can also be regarded as a $`W/w`$-competitive algorithm for this problem. This is the first approximation algorithm/competitive algorithm for this problem. Once the routes are chosen, we can use any “good” scheduling protocol in the Adversarial Queueing Model.

Our algorithm is based on the $`\epsilon `$-approximation algorithm for fractional maximum multicommodity concurrent flow given by Garg and Könemann , which in turn builds upon the work of Plotkin, Shmoys, and Tardos  and Young . In the maximum multicommodity concurrent flow problem, the demands for each commodity remain constant as the algorithm progresses. In our setting, the demands between source-destination pairs correspond to the packets injected by the adversary, which can change over time. Even though the algorithm of Garg and Könemann  is an offline algorithm that assigns fractional paths to a fixed set of commodities, in our setting we are able to convert it into an online algorithm that assigns an integral path to each packet as soon as it is injected.

#### Implementation under Internet routing paradigms.

At a high level, our algorithm works as follows. Each link maintains a measure of congestion that represents how many packets have been routed through it in the recent past. Packets are then routed on shortest paths with respect to this congestion measure. Hence we need a mechanism for distributing congestion information from the links to the source nodes. We also need a mechanism by which a source node can inform a link whenever it routes a packet through that link.

The first requirement could be satisfied by something akin to the OSPF (Open Shortest Path First) link state flooding protocol. (See e.g. .) This is a protocol that is used for flooding link state information to the nodes in a network so that packets may be routed along shortest paths. The second requirement may be satisfied by the MPLS (Multi-Protocol Label Switching) protocol that is gaining increasing acceptance in the Internet. (See e.g. .) With this protocol a source node can compute an explicit route to each destination and then distribute a label for the route to each of the links that comprise the route. In combination with this label distribution the source can also specify how much traffic it is going to send on the route.

In Section 2 we first assume that this control information is transmitted instantaneously and does not contribute to the congestion in the network. We then consider a model in which the control information is transmitted in-band through the network and must contend with the data traffic.

#### Relation to previous work.

Routing and scheduling as a combined problem has been studied in the past. For example, Aiello et al. presented a distributed algorithm  motivated by the Awerbuch-Leighton multicommodity flow algorithm . In  Gamarnik gave a solution based on an approximation algorithm for static routing. However, both these algorithms require a dependence between how a packet is routed and how it is scheduled. Hence, their routing schemes only work in association with their specific scheduling schemes, but not with generic scheduling algorithms. Neither routing algorithm can be used to provide packets with admissible paths at injection time. Using networking terminology, these routing algorithms correspond to active routing , where intermediate routers need to actively participate in determining routes for each individual packet. In contrast, our algorithm corresponds to source routing, where the entire path of a packet is known at the source.

### 1.2 Deterministic Distributed Scheduling with Polynomial Delays

In Section 3 of the paper we study the scheduling problem in isolation assuming that $`(w,r)`$-admissible paths are given. In recent years, a number of scheduling algorithms have been proposed that guarantee network stability, i.e. the number of packets in the network remains bounded and the end-to-end delay experienced by packets remains bounded. For example, the Longest-In-System protocol that always gives priority to the packet injected into the system earliest, was shown in  to guarantee a delay bound of $`O(w/(1r)^{d_{\mathrm{max}}})`$, where $`d_{\mathrm{max}}`$ is the maximum length of a path assigned to any packet. Note however, that this bound is exponential in $`d_{\mathrm{max}}`$. It has been an open problem whether or not any deterministic, distributed scheduling protocol has a polynomial delay bound in the Adversarial Queueing Model. Indeed,  remarked that “it is of considerable interest to determine whether such a protocol exists”.

A randomized protocol based on Longest-In-System can guarantee that each packet experiences a delay of $`poly(w,1/(1r),d_{\mathrm{max}},\mathrm{log}m)`$ with high probability , where $`m`$ is the number of links in the network. In essence, for most of the time the protocol is successful and keeps all delays small. However, even if the failure probability is small, if the algorithm is run for an extended period of time then the algorithm is likely to make some random choices that are bad. This causes packets to violate the delay bound. Moreover, if one packet violates the delay bound then other packets injected along the same path at similar times are also likely to violate the delay bound. Hence, all of the packets that make up a single file transfer could be excessively delayed. Although this randomized protocol can be derandomized in a centralized manner it seems hard to convert it into a deterministic, distributed protocol. This is because the “success condition” involves packets injected at multiple source nodes and hence it cannot be verified locally.

#### Our result.

In Section 3 we present the first deterministic, distributed scheduling protocol with a polynomial delay bound. It guarantees that all packets reach their destination within $`poly(w,1/(1r),m)`$ steps of their injection. We start by presenting a randomized protocol in which the “success condition” can be verified at the source nodes independently. This allows us to derandomize the protocol in a distributed fashion.

### 1.3 The Effects of Combining Source Routing with Scheduling

In the final part of the paper we consider the following question: Is it possible for unstable scheduling protocols to become stable if paths can be chosen by a routing algorithm as opposed to being dictated by the adversary? We first present a network and a sequence of packet injections such that regardless of how the routes for these packets are chosen, many greedy protocols (including FIFO) remain unstable. Thus, we cannot hope to achieve stability using FIFO even if we have the freedom to choose routes. However, we also present an example in which the ability to select the routes does make a difference. We show that in a “ring” with multiple parallel links, if we are allowed to choose the routes intelligently then we can ensure that all greedy scheduling protocols are stable. However, if the adversary dictates the routes then many scheduling protocols (including FIFO) are unstable.

### 1.4 Other Related Work

Much traditional work on routing focuses on the problem of routing flows online, e.g. . Each flow requests a bandwidth from a source to a destination and we must choose a path for each accepted flow without violating any link capacity. The goal is to maximize the on-line acceptance rate. However, this work does not consider packet-level behavior.

The problem of choosing routes for a fixed set of packets was studied by Srinivasan and Teo  and Bertsimas and Gamarnik . For example,  presents an algorithm that minimizes the congestion and dilation of the routes up to a constant factor. This result complemented the paper of Leighton, Maggs and Rao  which showed that packets could be scheduled along a set of paths in time $`O(`$congestion$`+`$dilation$`)`$.

## 2 Source Routing for Stability

For convenience we use the following weaker notion of admissibility in this section. We say that a set of packet paths is weakly $`(w,r)`$-admissible if we can partition time into windows of length $`w`$ such that for each window in the partition and each link $`e`$, the number of paths that pass through $`e`$ and correspond to packets injected during the window is at most $`wr`$. However, this distinction is not important due to Lemma 1. Moreover, all of the delay bounds that have been derived in the past for the Adversarial Queueing Model apply to weakly $`(w,r)`$-admissible paths.

###### Lemma 1

If a set of paths is $`(w,r)`$-admissible then it is also weakly $`(w,r)`$-admissible. Conversely, weak $`(w,r)`$-admissibility implies $`(w^{},r^{})`$-admissibility for some $`w^{}w`$ and $`r^{}[r,1)`$.

Proof: Suppose the injections are weakly $`(w,r)`$-admissible. We show that they are $`(w^{},r^{})`$-admissible for $`r^{}=(1+r)/2`$ and $`w^{}=4wr/(1r)`$. For any $`Tw^{}`$, let $`T`$ be in the range of $`[nw,(n+1)w)`$ where $`n`$ is an integer at least $`4r/(1r)`$. Due to weak admissibility and our choices of $`n`$, $`T`$ and $`r^{}`$, the number of injections during $`T`$ steps for any link $`e`$ is at most,

$$(n+2)rwnw(1+r)/2Tr^{}.$$

The other direction is trivial.

We assume an adversary that injects weakly $`(w,r)`$-admissible packets into the network111In fact, as will be seen later, we only need to assume that the adversary can choose fractional paths that are weakly $`(w,r)`$-admissible.. Our aim is to choose weakly $`(W,R)`$-admissible routes for these packets where $`R(r,1)`$ is of our choice and $`Ww`$ is determined by the choice of $`R`$.

### 2.1 The Basic Routing Protocol

We first assume that control information is communicated instantaneously. Whenever a source node chooses a route for a packet, this information is instantaneously transmitted to all the links on the route. Whenever the congestion on a link changes, this fact is instantaneously transmitted to all the source nodes. Later on we relax these assumptions. As mentioned in the Introduction, the algorithm is based on the Garg-Könemann offline approximation algorithm for fractional maximum concurrent flow. However, in our setting we can convert it into an online algorithm that chooses integral paths for the packets.

#### Protocol.

We route every packet injected along the path whose total congestion is the smallest under the current congestion function $`c()`$, i.e. we route along shortest paths with respect to $`c()`$. Initially, the congestion along every link is set to $`\delta `$ where $`\delta `$ is defined in (2). For every link $`e`$ along the chosen route, its congestion $`c(e)`$ is updated to $`c(e)(1+\mu /w)`$ where $`\mu `$ is defined in (1). We reset the congestion of every link to its initial value of $`\delta `$ at the beginning of each phase. A phase terminates in $`t`$ windows of $`w`$ steps, where $`t`$ is an integer defined in (3). Figure 1 illustrates the procedure for one phase. The values of $`\mu `$, $`\delta `$ and $`t`$ are defined as follows. Let $`m`$ be the number of links in the network. For any $`R(r,1)`$ of our choice, let

$`\mu `$ $`=`$ $`1\left({\displaystyle \frac{r}{R}}\right)^{1/3}`$ (1)
$`\delta `$ $`=`$ $`\left({\displaystyle \frac{1r\mu }{m}}\right)^{1/r\mu }`$ (2)
$`t`$ $`=`$ $`{\displaystyle \frac{1r\mu }{r\mu }}\mathrm{ln}{\displaystyle \frac{1r\mu }{m\delta }}+1`$ (3)
Our objective is to show,

###### Theorem 2

For all packets injected during one phase, at most $`twR`$ of their routes chosen by our procedure go through the same link. In other words these routes are weakly $`(tw,R)`$-admissible.

#### Analysis.

To prove Theorem 2 let us examine an integer program formulation for routing the set of packets injected during a window of $`w`$ time steps. Let $`P_j`$ be the set of possible routes for the $`j`$th packet, and let variable $`x_j(p)\{0,1\}`$ indicate whether or not route $`pP_j`$ is chosen for packet $`j`$. The following linear relaxation of the integer program (LP) has an optimal solution $`\lambda 1`$ since the injections are $`(w,r)`$-admissible. We present both the primal and the dual.

$$\begin{array}{ccc}& \text{Primal}& \\ & \mathrm{max}\lambda & \\ \hfill s.t.& & \\ & _{pP_j}x_j(p)\lambda & j\hfill \\ & _j_{p:ep,pP_j}x_j(p)rw& e\hfill \\ & x_j(p)0& j,pP_j\hfill \end{array}$$

$$\begin{array}{ccc}& \text{Dual}& \\ & \mathrm{min}_erwc(e)& \\ \hfill s.t.& & \\ & _{ep}c(e)z(j)& j,pP_j\hfill \\ & _jz(j)1& \\ & c(e)0& e\hfill \\ & z(j)0& j\hfill \end{array}$$

For any non-negative congestion function $`c()`$, let $`D=_ec(e)`$ be the total congestion of all links. For packet $`j`$ let $`q_j`$ be the least congested path in terms of $`c`$. We use $`\alpha =_j_{eq_j}c(e)`$ to represent the total congestion of these least congested paths. It can be shown that the dual is equivalent to,

$$\underset{c}{\mathrm{min}}\text{ }rwD/\alpha .$$

The congestion found at the end of window $`i`$ by our protocol (see Figure 1) defines a valid solution to this reformulated dual for window $`i`$. We exploit this connection to prove Theorem 2. The key here is to bound the total link congestion since the link congestion increases only when a path goes through it. In particular, the following three lemmas show that the total link congestion is no more than 1 at the end of a phase. Let $`c_i(e)`$, $`D_i`$ and $`\alpha _i`$ represent the values of $`c(e)`$, $`D`$ and $`\alpha `$ at the end of the $`i`$th window.

###### Lemma 3

$`D_i/\alpha _i1/rw`$ for $`1it`$.

Proof: Since the injections are $`(w,r)`$-admissible, the primal LP for window $`i`$ has $`\mathrm{max}\lambda 1`$. Since the congestion $`c_i`$ found by our protocol defines a dual solution, our lemma follows from duality.

###### Lemma 4

$`D_i\frac{D_{i1}}{1r\mu }`$.

Proof: It suffices to show $`D_iD_{i1}+\alpha _i\mu /w`$ since $`D_i/\alpha _i1/rw`$ by Lemma 3. Let $`c_{ij}`$ be the congestion function after routing the $`j`$th packet injected during the $`i`$th window and let $`D_{ij}`$ be defined in terms of $`c_{ij}`$. Suppose path $`p_j`$ is chosen for the $`j`$th packet injected during the $`i`$th window. By definition we have,

$`D_{ij}`$ $`=`$ $`{\displaystyle \underset{e}{}}c_{ij}(e)`$
$`=`$ $`{\displaystyle \underset{ep_j}{}}c_{i,j1}(e)+{\displaystyle \underset{ep_j}{}}c_{i,j1}(e)(1+\mu /w)`$
$`=`$ $`D_{i,j1}+{\displaystyle \underset{ep_j}{}}c_{i,j1}(e)\mu /w.`$
Now we repeatedly apply the recurrence above. We also observe that the congestion function $`c`$ only increases. Hence, if $`q_j`$ is the least congested path for $`j`$ under $`c_i`$ then $`_{ep_j}c_{i,j1}(e)`$ is necessarily no more than $`_{eq_j}c_i(e)`$. (We emphasize that $`p_j`$ and $`q_j`$ may be two different paths. The path $`p_j`$ is least congested with respect to $`c_{i,j1}`$ and $`q_j`$ is least congested with respect to $`c_i`$.) We have,

$`D_i`$ $`=`$ $`D_{i1}+{\displaystyle \underset{j}{}}{\displaystyle \underset{ep_j}{}}c_{i,j1}(e)\mu /w`$
$``$ $`D_{i1}+\alpha _i\mu /w.`$
###### Lemma 5

$`D_t1`$.

Proof: By definition $`D_0=m\delta `$ where $`m`$ is the number of links in the network. By applying Lemma 4, we have,

$`D_t`$ $``$ $`{\displaystyle \frac{m\delta }{(1r\mu )^t}}`$
$`=`$ $`{\displaystyle \frac{m\delta }{1r\mu }}\left(1+{\displaystyle \frac{r\mu }{1r\mu }}\right)^{t1}`$
$``$ $`{\displaystyle \frac{m\delta }{1r\mu }}e^{\frac{r\mu (t1)}{1r\mu }}`$
$``$ $`1.`$
The second inequality follows from $`1+xe^x`$ for $`x0`$. The last inequality follows from the definition of $`t`$ in (3).

We are now ready to prove Theorem 2.

Proof of Theorem 2: Consider any link $`e`$. For every $`w`$ paths routed though $`e`$, the congestion of $`e`$ is increased by a factor at least $`1+\mu `$. Initially, $`c_0(e)=\delta `$. Since $`D_t1`$, $`c_t(e)1`$. Hence, the total number of paths that are routed through $`e`$ in a phase is at most $`w\mathrm{log}_{1+\mu }1/\delta `$. It suffices to show that this quantity is no more than $`wtR`$.

$`{\displaystyle \frac{w\mathrm{log}_{1+\mu }1/\delta }{wtR}}`$ $``$ $`{\displaystyle \frac{\mathrm{ln}1/\delta }{\mathrm{ln}(1+\mu )}}{\displaystyle \frac{r\mu }{1r\mu }}{\displaystyle \frac{1}{\mathrm{ln}\frac{1r\mu }{m\delta }}}{\displaystyle \frac{1}{R}}`$
$`=`$ $`{\displaystyle \frac{r}{R}}{\displaystyle \frac{\mu }{\mathrm{ln}(1+\mu )(1r\mu )^2}}`$
$``$ $`{\displaystyle \frac{r}{R}}(1\mu )^3`$
$`=`$ $`1.`$
The first inequality and the first equality follow from the definitions of $`t`$ and $`\delta `$ respectively. The second inequality follows from the fact that $`r<1`$ and $`\mathrm{ln}(1+\mu )\mu \mu ^2/2`$. The last equality follows from the definition of $`\mu `$. Our proof is complete.

### 2.2 Routing with Less Frequent Updates

In this section we show that Theorem 2 still holds even if the congestion function $`c`$ is updated less frequently. In particular, we only update the congestion at the end of each window, not for each packet injection. Hence the source nodes only need to communicate with the links at the end of each window. For this new protocol we redefine $`\mu `$ to be

$`{\displaystyle \frac{1}{m}}\left(1\left({\displaystyle \frac{r}{R}}\right)^{1/3}\right).`$ (4)
Suppose $`N_i(e)`$ packets are routed through link $`e`$ during the $`i`$th window, then we update $`c(e)`$ to $`c(e)(1+N_i(e)\mu /w)`$. See Figure 2.

We prove that Theorem 2 remains true. We first show that Lemma 4 still holds. As before, we show $`D_iD_{i1}+\alpha _i\mu /w`$. For any packet $`j`$ injected during the $`i`$th window, let $`p_j`$ be the path chosen for $`j`$.

$`D_i`$ $`=`$ $`{\displaystyle \underset{e}{}}c_i(e)`$
$`=`$ $`{\displaystyle \underset{e}{}}c_{i1}(e)(1+N_i(e)\mu /w)`$
$`=`$ $`D_{i1}+{\displaystyle \underset{e}{}}c_{i1}(e)N_i(e)\mu /w`$
$`=`$ $`D_{i1}+{\displaystyle \underset{j}{}}{\displaystyle \underset{ep_j}{}}c_{i1}(e)\mu /w`$
$``$ $`D_{i1}+\alpha _i\mu /w`$
Hence $`D_t1`$. Now, for every $`mw`$ paths routed through $`e`$, the congestion on $`e`$ is increased by a factor at least $`1+m\mu `$. Therefore the congestion on any link at the end of a phase is at most,

$`{\displaystyle \frac{mw\mathrm{log}_{1+m\mu }1/\delta }{wtR}}`$ $``$ $`{\displaystyle \frac{\mathrm{ln}1/\delta }{\mathrm{ln}(1+m\mu )}}{\displaystyle \frac{r\mu }{1r\mu }}{\displaystyle \frac{1}{\mathrm{ln}\frac{1r\mu }{m\delta }}}{\displaystyle \frac{1}{R}}`$
$`=`$ $`{\displaystyle \frac{r}{R}}{\displaystyle \frac{m\mu }{\mathrm{ln}(1+m\mu )(1r\mu )^2}}`$
$``$ $`{\displaystyle \frac{r}{R}}(1m\mu )^3`$
$`=`$ $`1,`$
with the revised definition of $`\mu `$ in (4).

### 2.3 Implementation Using In-band Signaling

In the previous sections we assumed that sources can communicate with the links on their chosen routes via instantaneous setup messages. In turn, we also assumed that the links can instantaneously broadcast their congestion to the sources. In this section, we first extend our result in Section 2.2 to the case where each of these communications takes $`\tau `$ time steps. We then give an upper bound on $`\tau `$ for which the communication may be carried out in-band using packets transmitted through the network.

Assume without loss of generality that $`w>2\tau `$ (since admissibility for a small window implies admissibility for a large window). Each source only updates the link congestion at the end of every window. Since the congestion does not change during a window, all the packets for a given source-destination pair $`(s,t)`$ are routed along the same path $`p`$. At the end of window $`[w(i1),wi)`$ a control packet is sent along path $`p`$ that contains the number of $`(s,t)`$-packets injected during window $`[w(i1),wi)`$. This packet takes time $`\tau `$ to traverse the path. Hence, at time $`wi+\tau `$, each link can update its congestion due to all the packets injected during $`[w(i1),wi)`$. Then by time $`wi+2\tau w(i+1)`$ this new congestion can be distributed via control packets to all the sources.

Note that at the end of window $`[wi,w(i+1))`$, every link has updated its congestion according to the injections in window $`[w(i1),wi)`$. The exact form of this update is as follows. Let $`N_i(e)`$ be the number of packets routed through $`e`$ that were injected during $`[w(i1),wi)`$. Let $`c_i(e)`$ be the congestion of $`e`$ at the end of window $`[w(i1),wi)`$. We update $`c_i(e)`$ by,

$$c_{i+1}(e)=c_i(e)+c_{i1}(e)N_i(e)\mu /w,$$

for

$`\mu ={\displaystyle \frac{1}{2m}}\left(1\left({\displaystyle \frac{r}{R}}\right)^{1/3}\right).`$ (5)
To show that Theorem 2 remains true, we observe,

$`D_{i+1}`$ $`=`$ $`{\displaystyle \underset{e}{}}c_{i+1}(e)`$
$`=`$ $`{\displaystyle \underset{e}{}}c_i(e)+c_{i1}N_i(e)\mu /w`$
$`=`$ $`D_i+{\displaystyle \underset{e}{}}c_{i1}(e)N_i(e)\mu /w`$
$`=`$ $`D_i+{\displaystyle \underset{j}{}}{\displaystyle \underset{ep_j}{}}c_{i1}(e)\mu /w`$
$``$ $`D_i+\alpha _{i,i+1}\mu /w.`$
Here $`\alpha _{i,i+1}`$ is the sum of the congestion along the paths chosen for packets injected during $`[w(i1),wi)`$ with respect to $`c_{i+1}(e)`$. This is sufficient to imply $`D_t1`$. Note also that for every $`2mw`$ (non-control) packets routed through a link, the congestion function of the link increases by at least a factor $`1+2m\mu `$. The remainder of the analysis follows through for the revised definition of $`\mu `$ in (5).

To ensure that the transmission time of the control packets is upper bounded, the scheduling protocol always gives priority to control packets. Observe that a total of at most $`n^2+mn`$ control packets can be sent out during one window, where $`m`$ is the number of links and $`n`$ is the number of nodes in the network. If we let $`\tau =n^3+mn^2`$, the transmission of a control packet takes at most $`\tau `$ time steps. Without loss of generality we assume that $`w2\tau `$ and $`w(1r)/2n^2+mn`$. The latter condition ensures that together with the control packets the injections are $`(w,(1+r)/2)`$-admissible.

## 3 A Scheduling Protocol with Polynomial Delay Bounds

In this section we assume that $`(w,r)`$-admissible paths are known (either given by the adversary or computed as in Section 2). Hence, in order to achieve network stability we can use any of the scheduling protocols that are known to be stable for Adversarial Queueing. However, the best previous delay bounds known for distributed, deterministic protocols are exponential in the maximum packet path length. In this section we present a deterministic, distributed scheduling protocol with a polynomial delay bound.

In  a randomized protocol was presented for which the delay bound is $`O(\frac{d_{\mathrm{max}}}{\epsilon }\mathrm{log}m)`$ with high probability, where $`\epsilon =1r`$ and $`d_{\mathrm{max}}`$ is the length of the longest simple path in the network. This protocol is hard to derandomize because its success depends on a condition that can only be checked globally. In this section we first present a new randomized protocol and then show how to derandomize it in a distributed manner. The key idea of this protocol is that the conditions that determine the “success” of the protocol only depend on packets that share the same initial link. This allows derandomization in a distributed manner.

Our new randomized protocol is defined in terms of two parameters $`M`$ and $`T`$ which are defined below. We partition time into intervals of length $`M`$, which we call $`M`$-intervals. We save up all packets that are injected into the network during each $`M`$-interval and then schedule these packets during the next $`M`$-interval. We give each packet a deadline for every link on its path. Our goal is to make sure that no more than $`T`$ packets have a deadline for link $`e`$ during any time interval of length $`T`$. If this condition holds then we are able to bound the end-to-end delay experienced by a packet.

#### Randomized protocol.

For a packet $`p`$ injected during an $`M`$-interval $`[(\gamma 1)M,\gamma M)`$ for an integral $`\gamma `$, let us suppose its path is $`e_0,e_1,\mathrm{},e_{d_p}`$. We define a deadline $`\tau _k^p`$ for $`p`$ at link $`e_k`$ as follows. We choose the initial deadline $`\tau _0^p`$ uniformly at random from $`[\gamma M+T,(\gamma +1)Md_{\mathrm{max}}T)`$. We then define the remaining deadlines inductively by $`\tau _{k+1}^p=\tau _k^p+T`$. Our protocol always gives priority to the packet with the smallest deadline at each link. We define $`M`$ and $`T`$ such that,

$`T`$ $`=`$ $`{\displaystyle \frac{36m}{\epsilon ^3}}\mathrm{log}(2Mm^2),`$ (6)
$`M`$ $``$ $`\mathrm{max}\{{\displaystyle \frac{1\epsilon /2}{\epsilon /6}}(d_{\mathrm{max}}+1)T,w\}.`$ (7)
These properties are satisfied for,

$$M=O\left(\frac{d_{\mathrm{max}}m}{\epsilon ^4}\mathrm{log}\frac{m}{\epsilon }+w\right).$$

When a packet meets its deadlines, it reaches its destination within $`2M`$ steps.

#### Analysis.

Our objective is to show that all packets injected during a given $`M`$-interval meet all their deadlines with a constant probability. Lemma 6 gives a sufficient condition for all deadlines to be met. For any packet $`p`$ and link $`e`$ let $`X_{[t,t+T)}^{p,e}=1`$ if $`e`$ is the $`k`$th link on packet $`p`$’s path and $`\tau _k^p`$ lies in the time interval $`[t,t+T)`$. Let $`X_{[t,t+T)}^{p,e}=0`$ otherwise.

###### Lemma 6

If $`_pX_{[t,t+T)}^{p,e}T`$ for all $`t`$ and all links $`e`$, then all packets meet all their deadlines.

Proof: Suppose not. Let $`p`$ be a packet that misses its $`k`$th deadline $`\tau _k^p`$ and suppose that no deadline earlier than $`\tau _k^p`$ is missed. Then $`p`$ has arrived at its $`k`$th link $`e_k`$ by time $`\tau _k^pT`$. (This is true regardless of whether $`e_k`$ is the initial link of $`p`$ or not.) By our assumption that $`\tau _k^p`$ is the first deadline that is missed, all the packets with deadlines for $`e_k`$ that are earlier than $`\tau _k^pT+1`$ meet those deadlines. Therefore, the only packets that block packet $`p`$ in the interval $`[\tau _k^pT+1,\tau _k^p]`$ have deadlines in the interval $`[\tau _k^pT+1,\tau _k^p]`$. By the assumption in the statement of the lemma there are at most $`T1`$ such packets (excluding $`p`$). Therefore packet $`p`$ is served by link $`e_k`$ at time $`\tau _k^p`$ or earlier. This is a contradiction.

Given Lemma 6 we show,

###### Lemma 7

Consider packets injected during an $`M`$-interval, $`[(\gamma 1)M,\gamma M)`$. The number of deadlines from these packets on any link $`e`$ during any interval $`[t,t+T)`$ is at most $`T`$ with a constant probability.

Proof: We use a Chernoff bound to prove the number of deadlines is small. Let $`S_{e_0,e}^\gamma `$ be the set of packets injected into the network during the interval $`[(\gamma 1)M,\gamma M)`$ that have $`e_0`$ as their initial link and that have link $`e`$ on their path. The expected number of deadlines is,

$$E\left[\underset{pS_{e_0,e}^\gamma }{}X_{[t,t+T)}^{p,e}\right]\frac{|S_{e_0,e}^\gamma |}{M(d_{\mathrm{max}}+1)T}T.$$

When $`|S_{e_0,e}^\gamma |`$ is large, the expectation is large and the argument is straightforward. However, for small $`|S_{e_0,e}^\gamma |`$ a direct application of the Chernoff bound may not suffice. To rectify this, let us define a new quantity,

$$\beta _{e_0,e}^\gamma =\frac{M}{M(d_{\mathrm{max}}+1)T}\mathrm{max}\{|S_{e_0,e}^\gamma |/M,\epsilon /3m\}.$$

The quantity $`\beta `$ has the following properties.

1. $`\beta _{e_0,e}^\gamma \epsilon /3m`$;
2. $`_{e_0}\beta _{e_0,e}^\gamma \frac{M}{M(d_{\mathrm{max}}+1)T}((1\epsilon )+m\epsilon /3m)\frac{1\epsilon /2}{12\epsilon /3}(12\epsilon /3)1\epsilon /2.`$

The second property follows from the requirement of $`M`$ in (7) and the admissibility of the paths. Our lemma follows if we show that the following holds with constant probability,

$`{\displaystyle \underset{pS_{e_0,e}^\gamma }{}}X_{[t,t+T)}^{p,e}\left(1+\epsilon /2\right)\beta _{e_0,e}^\gamma T,e_0,e\text{ and }[t,t+T).`$ (8)
If the above holds, the number of deadlines on link $`e`$ in the interval $`[t,t+T)`$ is at most $`(1+\epsilon /2)_{e_0}\beta _{e_0,e}^\gamma T`$, which is less than $`T`$ due to the second property of $`\beta `$. We have,

$`Pr\left[{\displaystyle \underset{pS_{e_0,e}^\gamma }{}}X_{[t,t+T)}^{p,e}>(1+\epsilon /2)\beta _{e_0,e}^\gamma T\right]`$ $``$ $`{\displaystyle \frac{_pE[(1+\epsilon /2)^{X_{[t,t+T)}^{p,e}}]}{(1+\epsilon /2)^{(1+\epsilon /2)\beta _{e_0,e}^\gamma T}}}`$ (9)
$``$ $`\mathrm{exp}(\epsilon ^2\beta _{e_0,e}^\gamma T/12)`$
$``$ $`{\displaystyle \frac{1}{2Mm^2}}.`$
The first inequality is due to a Chernoff bound. The second inequality holds since $`E[_{pS_{e_0,e}^\gamma }X_{[t,t+T)}^{p,e}]`$ $`\beta _{e_0,e}^\gamma T`$ and $`1+xe^x`$ for $`x0`$. The third inequality follows from the definition of $`T`$ in (6) and the fact that $`\beta _{e_0,e}^\gamma \epsilon /3m`$. By taking a union bound over all links $`e_0`$, $`e`$ and all intervals $`[t,t+T)[\gamma M,(\gamma +1)M)`$, we have that the number of deadlines from all packets on $`e`$ during $`[t,t+T)`$ is at most $`T`$ with probability at least $`1/2`$.

#### Remarks.

To prove Lemma 7 a condition weaker than (8) would be sufficient. It would suffice to show that the number of deadlines on any $`e`$ during any $`[t,t+T)`$ is at most $`(1+\epsilon /2)_{e_0}\beta _{e_0,e}^\gamma T`$. Indeed, this would even allow $`T`$ and $`M`$ to be a factor of $`m`$ smaller, as in . However, such a weaker condition only allows derandomization in a centralized manner.

We emphasize that the condition (8) depends only on sets of packets that are injected into one particular initial link. Therefore we can choose the deadlines for a packet simply by considering the other packets that are injected at the same initial link. Hence, we can carry out a derandomization independently at each initial link and obtain a distributed, deterministic protocol. This is in contrast to the randomized protocol of  in which the success condition depends on packets that are injected across all initial links in the network.

#### Derandomization.

We use the method of conditional expectations to derandomize the protocol for each $`M`$-interval. (See e.g. .) In summary,

###### Theorem 8

Our derandomized protocol is distributed and guarantees a delay bound of $`2M=poly(m,w,1/\epsilon )`$ for every packet.

Proof: Let $`S_{e_0,e}^\gamma =\{p_0,p_1,\mathrm{},p_{\mathrm{}}\}`$. For $`i\mathrm{}`$, let $`g(\delta _0,\delta _1,\mathrm{},\delta _i)`$ be equal to

$`{\displaystyle \underset{e,t}{}}Pr[{\displaystyle \underset{pS_{e_0,e}^\gamma }{}}X_{[t,t+T)}^{p,e}>(1+\epsilon /2)\beta _{e_0,e}^\gamma T|\tau _0^{p_0}=\delta _0,\mathrm{},\tau _0^{p_i}=\delta _i],`$
where $`t`$ is summed over the range $`[\gamma M,(\gamma +1)MT)`$. By a calculation similar to the Chernoff calculation of (9), the value of $`g(,\mathrm{},)`$ is upper bounded by the following function $`h`$,

$`h(\delta _0,\delta _1,\mathrm{},\delta _i)`$ $`=`$ $`{\displaystyle \underset{e,t}{}}{\displaystyle \frac{_p\mathrm{exp}(\frac{\epsilon }{2}E[X_{[t,t+T)}^{p,e}|\tau _0^{p_0}=\delta _0,\mathrm{},\tau _0^{p_i}=\delta _i])}{(1+\epsilon /2)^{(1+\epsilon /2)\beta _{e_0,e}^\gamma T}}}.`$
For fixed $`\delta _0,\mathrm{},\delta _{i1}`$, the definition of conditional expectation implies that there exists an initial deadline $`\delta _i`$ for the packet $`p_i`$ such that $`h(\delta _0,\delta _1,\mathrm{},\delta _{i1})h(\delta _0,\delta _1,\mathrm{},\delta _{i1},\delta _i)`$. If we always choose the initial deadline so that this inequality is satisfied then,

$`g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})`$ $``$ $`h(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}}))`$
$``$ $`h(\mathrm{})`$
$``$ $`\mathrm{exp}(\epsilon ^2\beta _{e_0,e}^\gamma T/12),`$
The third inequality follows from (9). We have chosen the parameters $`M`$ and $`T`$ so that $`\mathrm{exp}(\epsilon ^2\beta _{e_0,e}^\gamma T/12)`$ is less than $`1`$. In addition, since $`g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})`$ involves no randomness every term of $`g`$ is either $`0`$ or $`1`$. The above inequalities imply that $`g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})`$ is less than $`1`$ and so condition (8) fails with probability zero. Hence, with probability one all deadlines are met and all packets reach their destinations in time $`2M`$.

It remains to show that we can calculate $`h(\delta _0,\mathrm{},\delta _i)`$. If $`ji`$ then,

$$E[X_{[t,t+T)}^{p_j,e}|\tau _0^{p_0}=\delta _0,\mathrm{},\tau _0^{p_i}=\delta _i]$$

is equal to $`0`$ or $`1`$ depending on whether or not the initial deadline $`\delta _j`$ causes packet $`p_j`$ to have a deadline for link $`e`$ during $`[t,t+T)`$. If $`j>i`$ then,

$$E[X_{[t,t+T)}^{p_j,e}|\tau _0^{p_0}=\delta _0,\mathrm{},\tau _0^{p_i}=\delta _i]=E[X_{[t,t+T)}^{p_j,e}],$$

which is equal to the probability, over all possible choices of the initial deadline, that packet $`p_j`$ has a deadline for link $`e`$ during the interval $`[t,t+T)`$. (Recall that the initial deadline has at most $`M`$ choices and all subsequent deadlines are chosen deterministically.) This probability is solely dependent on whether or not the path for packet $`p_j`$ passes through link $`e`$. Hence, for fixed $`\delta _0,\mathrm{},\delta _{i1}`$ we can choose the value of $`\delta _i`$ that minimizes $`h(\delta _0,\delta _1,\mathrm{},\delta _{i1},\delta _i)`$.

## 4 Instability in Combined Routing and Scheduling

In  it was shown that if the packet routes are given by the adversary then the FIFO and Nearest-to-Go (NTG) scheduling protocols can be unstable even if the packet paths are admissible. (FIFO always gives priority to the packet that arrived at the link earliest. NTG always gives priority to the packet that has the smallest number of hops remaining to its destination.) However, the examples given in  do not lead to instability if we are allowed to route packets on paths other than the ones chosen by the adversary.

We therefore have a natural question. If we are allowed to choose the routes, can we guarantee that FIFO and NTG are stable? In this section we show that the answer to this question is negative. We present examples in which regardless of how we choose the routes, the FIFO and NTG scheduling protocols create instability.

###### Theorem 9

There exists a network $`G`$ such that FIFO creates instability under some $`(w,r)`$-admissible injections regardless of how packets are routed.

Proof: Network $`G`$ is shown in Figure 3. We break the packet injections into phases. We inductively assume that at the beginning of phase $`j`$ a set $`S`$ of $`s`$ packets with destination $`u_0`$ is in the queue of $`e_0`$. We show that at the beginning of phase $`j+1`$ more than $`s`$ packets with destination $`u_1`$ are in the queue of $`e_1`$. By symmetry this process repeats indefinitely and the number of packets in the network grows without bound. For the basis of the induction, we inject a large burst of packets at source node $`v_0`$ with destination node $`u_0`$, which is allowed by a large window $`w`$. From now on all the injections are at rate $`r`$ with burst size one. In general the sequence of injections in phase $`j`$ is as follows.

* For the first $`s`$ steps, we inject a set $`X`$ of $`rs`$ packets at node $`v_0`$ with destination $`u_1`$. These packets are completely held up at $`e_0`$ by the packets in $`S`$. We also hold up packets in $`S`$ at $`f_0`$ by injecting $`rs`$ packets at $`w_0`$ with destination $`u_0`$. These newly injected packets get mixed with those of $`S`$ into the set $`S^{}`$. At the end of the first $`s`$ steps, $`rs`$ packets from $`S^{}`$ are at $`f_0`$. Note that packets in $`X`$ will be routed through either $`f_0`$ or $`f_0^{}`$.
* For the next $`rs`$ steps, we inject a set $`Y`$ of $`r^2s`$ packets at node $`v_0`$ with destination $`u_1`$. These packets are held up at $`e_0`$ by the packets in $`X`$. We also inject packets at $`w_0`$ with destination $`u_0^{}`$ at rate $`r`$. These packets delay the packets from $`X`$ that are routed through $`f_0^{}`$. Hence, at most $`rs/(r+1)`$ packets of $`X`$ cross $`f_0^{}`$. (This only happens if packets in $`X`$ are routed through $`f_0^{}`$, which is not necessarily the case.) Note that no packet from $`X`$ crosses $`f_0`$ in these steps, since the packets in $`S^{}`$ have priority. Hence, at the end of these $`rs`$ steps, a set $`X^{}X`$ of at least $`r^2s/(r+1)`$ packets are still at $`w_0`$.
* For the next $`\left|X^{}\right|+\left|Y\right|`$ steps the packets in $`X^{}`$ and $`Y`$ move forward, and merge at $`v_1`$. Meanwhile, we inject packets at $`v_1`$ with destination $`u_1`$ at rate $`r`$. We end with at least $`r(\left|X^{}\right|+\left|Y\right|)`$ packets at $`v_1`$ with destination $`u_1`$. This number is at least $`r^3s+r^3s/(r+1)`$.

This ends phase $`j`$. For $`r0.9`$ we have $`r^3+r^3/(r+1)>1`$. It is easy to verify that the injections during phase $`j`$ are admissible. The inductive step is complete.

Injections similar to the above can be used to prove the instability of NTG on network $`G`$ at any rate $`r>1/\sqrt{2}`$. The induction hypothesis of phase $`j`$ now does not require the packets in $`S`$ to be initially in the queue of $`e_0`$, but to cross $`e_0`$ in the first $`s`$ steps of the phase. Hence, subphase (3) is no longer required. Furthermore, after subphase (2) both sets $`Y`$ and $`X^{}`$ contain at least $`r^2s`$ packets, since single-link injections have higher priority than the packets in $`X`$. It follows that the system is unstable since $`2r^2s>s`$.

## 5 Stability of a Ring with Parallel Links

In this section we consider source routing on a ring with $`c`$ parallel links. Consider a decomposition of the network into $`c`$ disjoint single rings. We propose a deterministic on-line source-routing algorithm that routes each packet along one of these rings and guarantees that the routing is admissible. In  it was shown that the single ring is stable under any greedy scheduling policy (i.e. one that always schedules a packet whenever packets are waiting). Hence, we conclude that the ring with $`c`$ parallel links is stable under any greedy scheduling policy if our source-routing algorithm is used.

Note that the 4-ring with 2 parallel links was shown to be unstable under a greedy protocol such as FIFO when the packet paths are given by the adversary . This shows that freedom of routing can make a difference in network stability since we have a network that is unstable under FIFO if the adversary can dictate the routes but is stable under FIFO if we can choose the routes intelligently.

### 5.1 Definitions

Consider a ring with $`n`$ nodes and $`c`$ parallel directed links from node $`i`$ to node $`i+1(\text{ mod }n)`$. The parallel links connecting neighboring nodes are uniquely labeled $`1,\mathrm{},c`$. We denote the cycle of $`n`$ links labeled $`j`$ as the $`j`$th single ring. Note that, if $`jj^{}`$, the $`j`$th and the $`j^{}`$th single rings are link disjoint. We assume that the injections are $`(w,r)`$-admissible. For convenience we sometimes denote $`1r`$ by $`\epsilon `$. We propose a source-routing algorithm that finds weakly $`(W,R)`$-admissible paths along these single rings, where,

$`W`$ $`=`$ $`{\displaystyle \frac{3}{r\epsilon ^2}}\mathrm{ln}{\displaystyle \frac{nc}{\beta }},`$ (10)
$`R`$ $`=`$ $`1\epsilon ^2,`$ (11)
for some $`\beta <1`$.

### 5.2 Randomized Algorithm

Let us first study the following randomized routing algorithm. Each time a packet is injected, one of the $`c`$ single rings is randomly chosen, uniform and independently, and the packet is routed along it. Since the injections are $`(w,r)`$-admissible, in any $`W`$-interval at most $`crW`$ packets are injected that must cross the parallel links from any node $`i`$ to $`i+1(\text{ mod }n)`$. Hence, the expected number of packets routed along any link of the ring is at most $`rW`$. Using a Chernoff bound we can upper bound the probability of more than $`(1+\epsilon )rW=RW`$ packets being routed along any link in the $`W`$-interval. Let $`P=p_0,p_1,\mathrm{},p_{\mathrm{}}`$ be the set of packets injected in a $`W`$-interval. For each packet $`p_j`$, let $`X_e^{p_j}`$ be the random variable denoting whether $`p_j`$ is routed along link $`e`$. Let $`X_e`$ be the number of packets routed along link $`e`$ in the $`W`$-interval. From a Chernoff bound we have that,

$`Pr[X_e>(1+\epsilon )rW]`$ $``$ $`{\displaystyle \frac{_{p_jP}E[(1+\epsilon )^{X_e^{p_j}}]}{(1+\epsilon )^{(1+\epsilon )rW}}}`$
$``$ $`[e^\epsilon /(1+\epsilon )^{(1+\epsilon )}]^{rW}`$
$``$ $`e^{(\epsilon (1+\epsilon )\mathrm{ln}(1+\epsilon ))rW}`$
$``$ $`(e^{\epsilon ^2/3})^{rW}`$
$``$ $`{\displaystyle \frac{\beta }{nc}}.`$
The last two inequalities follow from the fact that $`\epsilon <1`$ and the definition of $`W`$ in (10), respectively. We can now bound the probability of any link having more than $`(1\epsilon ^2)W`$ packets routed along it. We use $`E`$ to denote the set of links in the ring.

$`Pr[\underset{eE}{\mathrm{max}}X_e>(1+\epsilon )rW]`$ $``$ $`{\displaystyle \underset{eE}{}}Pr[X_e>(1+\epsilon )rW]`$
$``$ $`|E|{\displaystyle \frac{\beta }{nc}}`$
$`=`$ $`\beta `$
Hence, since $`\beta <1`$, there is a positive probability of routing all the packets in such a way that no link has congestion more than $`RW`$. By choosing a very small $`\beta `$ (e.g., $`O(1/n)`$) we could show that this randomized algorithm guarantees that the routing is weakly $`(W,R)`$-admissible with high probability. This can be used to show the stability of any greedy scheduling protocol in a probabilistic sense (i.e., there is a value $`C`$ such that the probability of having more than $`kC`$ packets in the system at any given time is exponentially small in $`k`$).

However, in the rest of the section we only need $`\beta <1`$. We will derandomize the proposed algorithm, and all we need for this process to work is to have a feasible routing with the required properties. This is guaranteed for any $`\beta <1`$.

### 5.3 Off-line Routing

We will now derandomize the above algorithm so that all the packets are deterministically routed and no link has congestion more than $`(1\epsilon ^2)W`$. To do this, we use the method of conditional probabilities, as we did in Section 3. Unfortunately, to apply this method directly we need to know from the beginning the set $`P`$ of packets to be routed. We achieve this as follows. We divide time into intervals of $`W`$ steps, and hold all the packets injected in one $`W`$-interval until its last step. Then, all these packets are routed in that last step, when all of them are known.

Let $`P=p_0,p_1,\mathrm{},p_{\mathrm{}}`$ be the set of packets injected in a $`W`$-interval. Let $`\gamma _{p_j}`$ denote the single ring chosen to route packet $`p_j`$. For $`i\mathrm{}`$ let,

$$g(\delta _0,\delta _1,\mathrm{},\delta _i)=Pr[\underset{eE}{\mathrm{max}}X_e>(1+\epsilon )rW|\gamma _{p_0}=\delta _0,\mathrm{},\gamma _{p_i}=\delta _i].$$

Since $`g(,\mathrm{},)`$ is difficult to calculate directly, we define another function $`h(,\mathrm{},)`$ by,

$$h(\delta _0,\delta _1,\mathrm{},\delta _i)=\underset{eE}{}\frac{_{p_jP}E[(1+\epsilon )^{X_e^{p_j}}|\gamma _{p_0}=\delta _0,\mathrm{},\gamma _{p_i}=\delta _i]}{(1+\epsilon )^{(1+\epsilon )rW}},$$

which can be easily computed. For this, it is enough so observe that, when computing $`h(\delta _0,\delta _1,\mathrm{},\delta _i)`$, for each packet $`p_j`$,

* if $`ji`$, then

+ if $`e`$ is in the $`\delta _j`$th single ring and it is in the path from the source to the destination of $`p_j`$, then $`E[(1+\epsilon )^{X_e^{p_j}}|\gamma _{p_0}=\delta _0,\mathrm{},\gamma _{p_i}=\delta _i]=1+\epsilon `$.
    + Otherwise, $`E[(1+\epsilon )^{X_e^{p_j}}|\gamma _{p_0}=\delta _0,\mathrm{},\gamma _{p_i}=\delta _i]=(1+\epsilon )^0=1`$.
* if $`j>i`$, then

+ if $`e`$ could be in the path from the source to the destination of $`p_j`$, then $`E[(1+\epsilon )^{X_e^{p_j}}|\gamma _{p_0}=\delta _0,\mathrm{},\gamma _{p_i}=\delta _i]=(1+\epsilon )^{1/c}`$.
    + Otherwise, $`E[(1+\epsilon )^{X_e^{p_j}}|\gamma _{p_0}=\delta _0,\mathrm{},\gamma _{p_i}=\delta _i]=(1+\epsilon )^0=1`$.

We have that, $`g(\delta _0,\delta _1,\mathrm{},\delta _i)h(\delta _0,\delta _1,\mathrm{},\delta _i)`$. Also, for fixed $`\delta _0,\mathrm{},\delta _{i1}`$, the definition of conditional expectation implies that the single ring $`\delta _i`$ can be chosen such that $`h(\delta _0,\delta _1,\mathrm{},\delta _{i1})h(\delta _0,\delta _1,\mathrm{},\delta _{i1},\delta _i)`$. If we always choose the single rings so that this inequality is satisfied then,

$$g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})h(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}}))h(\mathrm{})\beta .$$

In this expression, the left-hand-side involves no randomness and so it is either $`0`$ or $`1`$. However, since $`\beta <1`$, it has to be less than $`1`$ and so there must be a probability zero of failure. Hence, no link has congestion more than $`(1\epsilon ^2)W`$, and the routing is weakly $`(W,R)`$-admissible.

### 5.4 On-line Routing

Now we want to route packets as soon as they are injected. This does not allow us to directly use the above derandomization process, since we will not necessarily know the set $`P`$ by the time we need to route the first packets. This is needed to compute the different values of the function $`h(,\mathrm{},)`$. However, we will deal with this problem by making pessimistic assumptions about the packets that have not been injected yet.

First consider two packets, $`p_k`$ and $`p_l`$, such that their paths do not overlap, and the destination node of $`p_k`$ is the source node of $`p_l`$. Replace these packets by one single packet whose source node is that of $`p_k`$ and its destination node is that of $`p_l`$. Observe that, for fixed $`\delta _0,\mathrm{},\delta _i`$, if $`k>i`$ and $`l>i`$, the value of $`h(\delta _0,\mathrm{},\delta _i)`$ does not change by the replacement (see above). This can be generalized to the replacement of any number of packets.

Then, this allows us to use the following trick. Initially we assume a set $`P^{(0)}`$ of packets that consists of $`crW`$ ghost packets going from node $`i`$ to node $`i+1(\text{ mod }n)`$, for each $`i`$. The value $`h(\mathrm{})`$ is computed for this set $`P^{(0)}`$.

Now, assume that $`i1`$ packets have been already injected and routed. (That is, the values $`\delta _0,\delta _1,\mathrm{},\delta _{i1}`$ are fixed and $`h(\delta _0,\delta _1,\mathrm{},\delta _{i1})`$ is computed.) When the $`i`$th packet $`p_i`$ is injected, we remove one ghost packet from the set $`P^{(i1)}`$ for each hop that $`p_i`$ crosses. These ghost packets are replaced by the packet $`p_i`$ to obtain a new set $`P^{(i)}`$. The existence of the appropriate ghost packets is guaranteed by the initial ghost packets we put in $`P^{(0)}`$ and the fact that the injections are $`(w,r)`$-admissible. As we saw previously, this does not change the value of $`h(\delta _0,\delta _1,\mathrm{},\delta _{i1})`$. Then, route the packet $`p_i`$ (choose and fix $`\delta _i`$) so that $`h(\delta _0,\delta _1,\mathrm{},\delta _{i1})h(\delta _0,\delta _1,\mathrm{},\delta _{i1},\delta _i)`$.

By repeating this process, at the end of the $`W`$-interval we have that

$$g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})h(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}}))h(\mathrm{})\beta ,$$

where $`\mathrm{}`$ is the number of packets injected during the $`W`$-interval. We now remove all the remaining ghost packets. This process eliminates any remaining randomness in $`g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})`$, and can never increase its value, since it only removes packets. Then, since $`g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})=0`$ involves no randomness and $`\beta <1`$, $`g(\delta _0,\delta _1,\mathrm{},\delta _{\mathrm{}})=0`$ and no link has congestion more than $`(1\epsilon ^2)W`$. Hence, the routing is weakly $`(W,R)`$-admissible.

## 6 Conclusions

In this paper we have presented source routing algorithms for packet-switched networks and we have described the first distributed, deterministic scheduling protocol with a polynomial delay bound. There is much still to be explored in the study of combined routing and scheduling. For example, different packets are often associated with different delay requirements. Some of them may be delay-sensitive whereas others may be delay-tolerant. The problem of scheduling these packets on given routes in order to meet these delay requirements has been studied before. The ability to choose the routes would add an additional dimension to the problem and may even make scheduling easier.

### Acknowledgment

The authors wish to thank Adam Meyerson for helpful discussions.


text:
# Parametric electron pumping through a quantum dot in the Kondo regime

## Acknowledgments

We gratefully acknowledge the support by RGC of Hong Kong SAR under grant number HKU 7091/01P.