Anne Bouillard
email: anne.bouillard@nokia-bell-labs.com

Stability and performance guarantees in networks with cyclic dependencies

With the development of real-time networks such as reactive embedded systems, there is a need to compute deterministic performance bounds. This paper focuses on the performance guarantees and stability conditions in networks with cyclic dependencies in the network calculus framework. We first propose an algorithm that computes tight backlog bounds in tree networks for any set of flows crossing a server. Then, we show how this algorithm can be applied to improve bounds from the literature fir any topology, including cyclic networks. In particular, we show that the ring is stable in the network calculus framework.

Introduction

With the development of critical embedded systems, it becomes a necessity to compute worstcase performance guarantees. Network calculus is a (min,plus)-based theory that computes global performance bounds from a local description of the network. These performances are the maximum backlog at a server of end-to-end delay of a flow. Examples of applications are switched network [START_REF] Cruz | Quality of service guarantees in virtual circuit switched networks[END_REF], Video-on-Demand [START_REF] Mcmanus | Video-on-demand over ATM: Constant-rate transmission and transport[END_REF]... More recently, it has been very useful for analysis large embedded networks such as AFDX (Avionics Full Duplex) [START_REF] Boyer | The PEGASE project: precise and scalable temporal analysis for aerospace communication systems with network calculus[END_REF].

In most applications, such as AFDX, only feed-forward topologies are used. One reason is the difficulty of deriving good deterministic performance bounds in networks with cyclic dependencies. However, allowing cycles in networks would result in a better bandwidth usage and more flexible communications [START_REF] Amari | AeroRing: Avionics Full Duplex Ethernet Ring with High Availability and QoS Management[END_REF]. As a consequence, there is a strong need to design efficient methods for computing precise deterministic bounds.

Recent works ( [START_REF] Bouillard | Tight Performance Bounds in the Worst Case Analysis of Feed Forward Networks[END_REF]11,[START_REF] Bondorf | Improving cross-traffic bounds in feed-forward networks -there is a job for everyone[END_REF]) have focused on computing tight performance bounds in feedforward networks, but the stability of a network is still an open problem in network calculus.

The most classical method for computing performance guarantees in cyclic networks is to use the fix-point or stopped-time method. It has first been presented in [START_REF] Cruz | A calculus for network delay, part II: Network analysis[END_REF]. A sufficient condition for stability is obtained as the existence of a fix point in an equation derived from the network description.

The theoretical aspects of the stability in deterministic queueing networks have also been studied in the slightly different model named adversarial queueing network (see [START_REF] Borodin | Adversarial queuing theory[END_REF] for a precise presentation). An injection rate per server (the rate at which data crossing this server is sent into the network) is given instead of one arrival rate per flow. Stability is stated in function of the topology as a minor-exclusion conditions in [START_REF] Àlvarez | A characterization of universal stability in the adversarial queuing model[END_REF], in function of a service policy in [START_REF] Andrews | Universal-stability results and performance bounds for greedy contention-resolution protocols[END_REF] or of the injection rate in [START_REF] Lotker | New stability results for adversarial queuing[END_REF].

Fewer works concern the stability in Network calculus. The most classical result is the stability of the ring, which is proved in [START_REF] Tassiulas | Any work-conserving policy stabilizes the ring with spatial re-use[END_REF] for work-conserving links and generalized in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF].

Instability results are provided in [START_REF] Andrews | Instability of FIFO in the permanent sessions model at arbitrarily small network loads[END_REF][START_REF] Andrews | Instability of fifo in session-oriented networks[END_REF]. In [START_REF] Andrews | Instability of FIFO in the permanent sessions model at arbitrarily small network loads[END_REF], the authors even show that the FIFO policy can be unstable at arbitrary small utilization rates. Some works, such as [START_REF] Rizzo | Stability and delay bounds in heterogeneous networks of aggregate schedulers[END_REF], have focused on finding sufficient condition for the stability in FIFO networks.

Another direction of research has consisted in breaking the cyclic dependencies in order to ensure the stability. Removing arcs could disconnect the network, but forbidding some paths of length 2, as in the turn-prohibition method, [START_REF] Starobinski | Application of network calculus to general topologies using turn-prohibition[END_REF][START_REF] Pellegrini | Scalable cycle-breaking algorithms for gigabit ethernet backbones[END_REF], can ensure both stability and connectivity.

Contributions

In this paper, we study the problem of stability in networks with cyclic dependencies in the network calculus formalism, using recent the developments in [11] for tandem networks. Our main contributions are the following:

• we generalize the recent algorithm of [11], that computes exact worst-case delays in a tandem network. We adapt it to compute the worst-case backlog of a server for any subset of flows crossing that server in tree networks. As a matter of fact, the algorithm in [11] can be deduced from this new algorithm, while the reverse is not true. As a by-product, we improve the results of [START_REF] Bondorf | Boosting sensor network calculus by thoroughly bounding cross-traffic[END_REF] about sink-tree networks;

• this new algorithm is used to compute new stability sufficient conditions in networks as mathematical programs. In particular, we demonstrate the stability of the ring in the network calculus framework. A weaker result had already been proved in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF] and [START_REF] Tassiulas | Any work-conserving policy stabilizes the ring with spatial re-use[END_REF], but our weaker assumption close a long-standing conjecture.

The rest of the paper is organized as follows: in Section 2, we recall the network calculus basics. Then in Section 3, we present generic mathematical programming methods to compute sufficient condition for the stability of networks. Next in Section 4, we give our algorithm that computes exact worst-case backlog in tree networks. We finally combine these results to compute new stability sufficient conditions in Section 5, and we compare them through numerical experiments in Section 6.

Network calculus framework and model

We denote by N the set of non-negative integers {0, 1, . . .} and for all n ∈ N, we set N n = {1, . . . , n}. For x ∈ R, we set (x) + = max(x, 0). We write R + for the set of non-negative reals.

While our model is in line with the standard definitions of networks calculus, we present only the material that is needed in this paper. A more complete presentation of the network calculus framework can be found in the reference books [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF][START_REF] Chang | Performance Guarantees in Communication Networks[END_REF].

Flow and server model

Data flows Flows of data are represented by non-decreasing and left-continuous functions that model the cumulative processes. More precisely, if A represents a flow at a certain point in the network, A(t) is the amount of data of this flow that crossed this point in the time interval [0, t), with the convention A(0) = 0. More formally, let

F = {f : R + → R | f (0) = 0, f non-decreasing and left-continuous}.
A system S is a non-deterministic relation between input and output flows, where the number of inputs is the same as the number of outputs: S ⊆ F m × F m and there is a one-to-one relation between the inputs and the outputs of the system, such that to each input flow corresponds one and only one output flow that is causal -no data is created or lost inside the systemmeaning that for (

(A i ) m i=1 , (B i ) m i=1 ) ∈ S, ∀i ∈ N m , A i ≥ B i . The vector ((A i ) m i=1 , (B i ) m i=1 ) is an (admissible) trajectory of S if ((A i ) m i=1 , (B i ) m i=1 ) ∈ S. If m = 1, i.
e., the system has exactly one incoming and one outgoing flow, then we will also refer to it as a server.

Arrival curves

The notion of arrival curve is quite simple: The amount of data that arrived during an interval of time is a function of the length of this interval. More formally, let α ∈ F. A flow is constrained by the arrival curve α, or is α-constrained if

∀s, t ∈ R + with s ≤ t : A(t) -A(s) ≤ α(t -s).
A typical example of such arrival curve are the pseudo-linear token-bucket functions: α b,r : 0 → 0; t → b + rt, if t > 0. The burstiness parameter b can be interpreted as the maximal amount of data that can arrive simultaneously and the rate r as a maximal long-term arrival rate.

Service curves The role of a service curve is to constrain the relation between the input of a server and its output. Let A be an cumulative arrival process to a server and B be its cumulative departure process. Several types of service curves have been defined in the literature, and the main types are the simple and strict service curves, which we now define.

We say that β is a simple service curve for a server S if

∀(A, B) ∈ S : A ≥ B ≥ A * β, with the convolution A * β(t) = inf 0≤s≤t A(s) + β(t -s). An interval I is a backlogged period for (A, B) ∈ F × F if ∀u ∈ I, A(u) > B(u). The start of the backlogged period of an instant t ∈ R + is start(t) = sup{u ≤ t | A(u) = B(u)}.
As both A and B are left-continuous, we have A(start(t)) = B(start(t)), and (start(t), t] is always a backlogged period.

We say that β is a strict service curve for server S if

∀(A, B) ∈ S : A ≥ B and ∀ backlogged periods (s, t] : B(t) -B(s) ≥ β(t -s). (1)
We define S(β) as the set of functions (A, B) satisfying Equation [START_REF] Àlvarez | A characterization of universal stability in the adversarial queuing model[END_REF]. The name strict service curves implies a difference to simple service curves. Works on the comparisons between the different types of service curves can be found in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF][START_REF] Bouillard | Comparison of different classes of service curves in network calculus[END_REF]. In this article, we will mainly deal with strict service curves, but will make use of the convolution A * β used to define simple service curves.

A typical example of a service curve are the rate-latency functions: β R,T : t → R • (t -T ) + , where T is the latency until the server has to become active and R is its minimal service rate after this latency.

Note that a server S may not be deterministic, as the function β only corresponds to a guarantee on the service offered. Among this non-determinism, we will focus on two modes of operation:

• Exact service mode: During a backlogged period (s, t], the service is exact if for all u ∈ (s, t] we have B(u) = A(start(t)) + β(u -start(t)). (In this case, start(u) = start(t).)

• Infinite service mode: During an interval of time (s, t], the service is infinite if ∀u ∈ (s, t] : B(u) = A(u), i.e., the server serves all data instantaneously.

For a system S ∈ F m × F m with m inputs and outputs, we say that S offers a strict service curve β if the aggregate system is, that is, if

∀ ((A i ) i∈Nm , (B i ) i∈Nm ) ∈ S, i∈Nm A i , i∈Nm B i ∈ S(β).
We assume no knowledge about the service policy in this system (except that it is FIFO per flow).

Performance guarantees

Backlog In this article, we focus on the worst-case backlog of a flow or a set of flow at a given server of a network. Let (A, B) ∈ F 2 be an admissible trajectory of a server. The backlog of the server at time t is b(t) = A(t) -B(t)}. The worst-case backlog is then b max = sup t≥0 b(t). Graphically this is the maximal vertical distance between A and B.

We denote (t) = t -start(t), the length of the backlogged period upt to t and max = max t (t), the maximum length of a backlogged period.

We denote b max (α, β) (resp. max (α, β)) the maximum backlog (resp. the maximum length of a backlogged period) that can be obtained for a flow that is α-constrained crossing S(β). For example, we have

• b max (γ b,r , β R,T ) = b + rT if r ≤ R, = +∞ otherwise; • max (γ b,r , β R,T ) = b+RT R-r ) if r < R, = +∞
otherwise. For a system with m inputs and outputs, it is also possible to compute the maximal backlog for a set of flows crossing this server. If I ⊂ N m , the backlog of flows in

I at time t is b I (t) = i∈I F (in) i (t) -i∈I F (out) i (t).
If the system offers a strict service curve β and flow i is

α i -constrained, then b I (t) ≤ b I,max = ( i∈I α i ) (β - j / ∈I α j ) + (0),
where f g(t) = sup u≥0 f (t + u) -g(u) is the (min,plus)-deconvolution. In the case of leakybucket arrival curves and rate latency service curve,

b I,max = b I + r I R -r I (b I + r I T ) + r I T, (2)
with r I = i∈I r i , and similarly for r I , b I and b I .

Stability We will also be interested in the stability of a network. Let us first define the stability for server:

Definition 1 (Server stability). Consider a server offering a strict service curve β and a flow crossing it, with arrival curve α.

• This server is said unstable if its worst-case backlog is unbounded;

• This server is said critical if its worst-case backlog is bounded, but the lengths of its backlogged periods are not bounded;

• This server is said stable if the length of its backlogged periods is bounded.

If the service curve is rate-latency β R,T and the arrival curve token-bucket γ b,r , then a server is unstable if R < r, critical is R = r and stable if R > r.

Note that this definition only involves r and R. The stability is insensitive to b and T , that only influence the size of the backlog and backlogged period.

Network model

Consider a network composed of n servers numbered from 1 to n and crossed by m flows named f 1 , . . . , f m , such that

• each server j guarantees a rate-latency strict service curve β (j) = β R j ,T j ;

• each flow crosses the network along a path π = π i (1), . . . , π i ( i ) , where i ≥ 1 is the length of the path. Each flow is constrained by the arrival curve α i = γ b i ,r i .

For a server j, we define Fl(j) = {i | ∃ , π( ) = j} the set of flows crossing server j.

We denote by N this network. Its induced graph is the directed graph whose vertices are the servers and the set of arcs is

A = {(π i (k), π i (k + 1)) | i ∈ N m , k ∈ N i -1 }.
We assume, without loss of generality, as we will focus on the performances in one server, that the network is connected has a unique final strictly connected component. Moreover, we assume that for all j ∈ N n-1 , there exists j > j such that (j, j ) ∈ A (up to renumbering the servers, this is also without loss of generality).

Classes of networks:

• if A = {(j, j + 1) | j ∈ N n-1 }, then the network is called an tandem networks;

• if the output degree of each vertex except node n is 1, then the network is called a tree network;

• if the graph network has no cycle, the network is called feed-forward;

• otherwise, it has cyclic dependencies.

Network stability

Definition 2 (Local stability). Consider a network N . It is said locally stable if all its servers are stable using the initial arrival curves:

∀j ∈ N n , max ( i j α i , β (j) ) < ∞.
Definition 3 (Global stability). A network is globally stable if for all its servers, the length of the maximal backlogged period is bounded.

We call the linear model when arrival curves are leaky-bucket and the service curve ratelatency. Our aim is to give sufficient properties for the global stability for networks with cyclic dependencies (the underlying graph has cycles). Lemma 1. If a network is globally stable, then it is locally stable.

Proof. We prove this by contra-position: suppose that the network is not locally stable. Then, there exists a server j that is not stable considering the original arrival process. Consider the following trajectory: every server acts as an infinite server except server j. Then the arrival processes into server j are exactly those that are injected into the network, and server j is not stable: the length of its backlogged period cannot be bounded. But they cannot either in this behavior of the network. So the network is not globally stable.

Sufficient conditions of network stability

When the network is feed-forward, it is possible to compute the performance of the network by 1. applying Equation (2) at every server and for I = {i} for each flow f i crossing that server and 2. propagating the constraints in the topological order of the servers. This is not possible when there are cyclic dependencies, because of the inter-dependencies between the backlogs computed when applying Equation [START_REF] Amari | AeroRing: Avionics Full Duplex Ethernet Ring with High Availability and QoS Management[END_REF].

The fix-point method is a generic method to compute performance guarantees in networks with cyclic dependencies. The main idea is to compute, for each server and each flow crossing it, an output arrival curve that depends on the input arrival curves at that server. A system of equations is then obtained and the solution, if it exists, gives output arrival curves for each flow after each server it crosses. This approach has been described for leaky bucket arrival curves and rate-latency service curves in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF]. The method for proving this approach is the stopped-time method.

In this section, we generalize the stopped-time method described in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF] in four directions:

• it can be applied to any arrival and service curve;

• it can be applied to any feed-forward decomposition of the network rather than a for each server individually;

• it can be applied to any group of flows rather than considering each flow individually;

• it can handle different combinations of the two cases above.

Instead of computing a fix-point, we rather present our results as the solution of an optimization problem, that enables us to include the computation of the network performance (worst-case backlog for example) in problem. In the linear model, we obtain a linear program.

With the three first points of generalization, it is also possible to solve a fix-point problem in order to obtain stability sufficient conditions. But the fourth point has no natural formalization into a fix-point problem.

We first describe the transformation of the network and flow grouping before and computing performance bounds as an optimization problem.

Network transformation

Feed-forward decomposition

Let N be a network and G N be its induced graph. This graph can be transformed into an acyclic graph by removing a set of arc A r ⊆ A.

Example 1. The toy network of Fig. 1 can be transformed into an acyclic network by removing arc (4, 2). In the next section, we will see that [erformance bounds can be efficiently computed in tree topologies. Such a decomposition can be obtained with A r = {(4, 2), (2, 1)}. With A r = A, all arcs are removed, and we obtain a graph with isolated nodes only.

Note that this transformation is not unique, and finding the minimum set of edges to remove is a NP-complete problem (it is the Minimum feed-back arc set problem in [START_REF] Garey | Computers and Intractability: A Guide to the Theory of NP-Completeness[END_REF]). The most classical solution in the literature is to remove every arc -each server is analyzed in isolation - but it might be a better choice to remove fewer arcs, and obtain a tree for example, we will see later that these topologies can be easily analyzed.

We now modify the flows in accordance to the arcs that have been removed: each flow

f i is split into several flows f i,1 , f i,2 , ..., f i,m i of respective paths in (N n , A-A r ), π i,1 = π i (1), ..., π i (k 1 ) , π i,2 = π i (k 1 + 1), ..., π i (k 2 ) ,..., π i,m i = π i (k m i + 1), ..., π i ( i ) , where (π i (k j + 1), π i (k j )) ∈ A r .
We denote i,k the length of π i,k , and call N FF the feed-forward network that is obtained.

Example 2. In the toy example of Fig. 1, if A r = {(4, 2), (2, 1)}, flow f 1 is split into f 1,1 and f 1,2 with respective paths 3, 4 and 2 , flow f 2 is split into f 2,1 and f 2,2 , with respective paths 4 and 2, 3 and flow f 3 is split into f 3,1 and f 3,2 , with respective paths 2 and 1, 3 . Flow f 4 remains unchanged (f 4,1 = f 4 ). The result of this decomposition is depicted Fig. 2.

1 3 4 2 f 3 f 2 f 3,2 f 1,2 f 2,2 f 4 f 1 Figure 2:
Feed-forward transformation of the toy network.

Flow grouping

The second step is to group flows. Instead of dealing with flows f i,k individually, we use a partition. Our goal is to compute (α ) ∈N L where α is an arrival curves of the aggregation of the flows (f s ) s∈S in S . We denote f the aggregated flow.

Let S = {(i, k) | i ∈ N m , k ∈ N m i }
This formulation might at first seem quite strange, but it takes several interesting cases into account.

Example 3. Consider again the toy example with the decomposition of Fig. 2. There is a priori no use to group flows f i,1 , as their arrival curve is already known. For the other flows, there are two natural groupings. The first is to group individually: for all , S is a singleton. The second one is to group according to the removed arcs, and have the grouping {(1, 2), (2, 2)} and {(3, 2)}. Indeed, the arrival curve of f 1,2 + f 2,2 can be less than the sum of the arrival curves of each individual flow, so hopefully, better performances can be computed with this decomposition.

Stability and performances as an optimization problem

If N is stable, then there exists an arrival curve α for the aggregated flow f . We make the following assumptions:

(A 1 ) For all ∈ N L , there exists a non-decreasing function H : F L → F that computes an arrival curve in N FF for the aggregation of flows (f i,k-1 ) (i,k)∈S at the end of their respective path π i,k-1 in function of α 1 , . . . , α L , the respective arrival curves of all aggregated flows f .

(A 2 ) There exists a non-decreasing function G : F L → R + that computes a performance P in N as a function of (α ) L =1 , arrival curves for the aggregate flows f .

(A 3 ) (H ) L =1 and G implicitly depend on the arrival curves (α i ) m i=1 and on the service curves (β j ) n j=1 . These functions are assumed to be non-decreasing with α i , i ∈ N m and nonincreasing with β j , j ∈ N n .

Assumptions (A 1 ) and (A 2 ) are ensured when N FF is feed-forward. It corresponds to choosing a method for computing performances in feed-forward networks. Assumption (A 3 ) and the fact that H and G are non decreasing are made without loss of generality since with greater arrival curves and smaller service curves induce more admissible trajectories, hence larger worst-case performances.

Since the minimum of two arrival curves for a flow is also an arrival curve for that flow, when N is stable, we can consider that α is the minimum arrival curves for f . Then it holds ∀ ∈ N L , α ≤ H (α), where (α ) L =1 = α. We can write this latter inequality as a vector expression:

α ≤ H(α), (3)
where H = (H ) L =1 . The next theorem shows the reverse: if the solutions of Equation ( 3) are bounded, then the system is stable.

Theorem 1. Set C = {α | α ≤ H(α)} be the set of solutions of Equation (3), and α 0 = sup{α | α ∈ C}. If α 0 is finite, then N is globally stable and for all ∈ N L , α 0 is an arrival curve for the aggregation of flows f i at the input of server π i,k (1) for (i, k) ∈ S .

The proof of this theorems follows exactly the same lines as the stopped-time method described in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF] or [START_REF] Chang | Performance Guarantees in Communication Networks[END_REF].

Proof. First, α 0 exists, as C contains a maximum element: if α 1 and α 2 are two elements in C, then for all

∈ N L , α 1 ≤ H (α 1 ) ≤ H (α 1 ∨ α 2 ) and similarly, α 2 ≤ H (α 1 ∨ α 2 ), so α 1 ∨ α 2 ≤ H (α 1 ∨ α 2 ), and α 1 ∨ α 2 ∈ C.
We use the stopped-time method. Consider that the arrivals to the network stop at time τ > 0: for each flow f i , an arrival curve is then α τ i : t → α i (t ∧ τ ). The total amount of data for each flow f i is also bounded by α i (τ ), so the network is globally stable.

Let α τ = (α τ, ) ∈N L be the family of the minimal arrival curve of the aggregated flows f i at server π i,k (1) for (i, k) ∈ S then

α τ ≤ H τ (α τ ) ≤ H(α τ ),
where H τ is obtained the same way as H, but replacing α i by α τ i . The first inequality comes from the stability of N for the stopped process, and the second from Assumption (A 3 ).

For all τ > 0, α τ ∈ C, so α 0 ≥ α τ , and α 0 is a family of arrival curves that is valid for all τ > 0. Then it is valid for the whole unstopped process, and the system is stable if α 0 is finite.

One-stage optimization problem

We are now ready to give a mathematical programming problem that computes worst-case performances upper bounds for arbitrary networks:

Maximize G(α) such that α ≤ H(α). (4)
Theorem 2. Under Assumptions (A 1 ), (A 2 ) and (A 3 ), the solution of the optimization problem of Equation ( 4) is an upper bound of the performance P of the network.

Proof. As H and G are non-decreasing, α 0 maximizes G among all the elements such that α ≤ H(α).

This formulation is in fact equivalent to the fix-point method that can be found in the literature, and that can be deduced from Theorem 1. Indeed, the proof of that theorem ensures the existence of a greatest fix-point. As α 0 is that fix-point, then the performances can be directly computed as G(α 0 ). This result is often used when there exists a unique fix-point to the equation α = H(α), which is also the largest solution of α ≤ H(α). Our formulation enables to apply the fix-point method in cases the uniqueness is not ensured.

Two-stage optimization problem

The formulation as an optimization problem can be generalized, by making advantage of two decompositions. For example, one could have a feed-forward transformation of the network so that N FF is a tree. Following example 3, there are two natural ways to group flows. First considering singletons only, which defines functions G and H 1 ; second grouping flows according to the arc that has been removed, which define functions H 2 .

So the following mathematical program is obtained:

Maximize G(α) such that α ≤ α 1 , α ≤ α 2 α s 1 ≤ α 2 ≤ u∈S α u 1 , ∀s ∈ S α 1 ≤ H 1 (α 1 ), α 2 ≤ H 2 (α 2 ) (5)
Theorem 3. Under Assumptions (A 1 ), (A 2 ) and (A 3 ), the solution of the optimization problem of Equation ( 5) is an upper bound of the performance P of the network.

Proof. Let α 1 be the vector of the smallest arrival curves for the individual flows, and α 2 for the aggregated flows. If s ∈ S , then α s ≤ α , as flow f s is part of the aggregated flow f , and α is less than the sum of the arrival curves of all the aggregated flows. Hence,

α s 1 ≤ α 2 ≤ u∈S α u 1 is satisfied.
The problem of Eq [START_REF] Andrews | Universal-stability results and performance bounds for greedy contention-resolution protocols[END_REF] has no natural equivalent as a fix-point equation, and can be directly generalized for more than two stage, and different decompositions. We will see that this optimization problem is slightly improved in the linear model.

Worst-case backlog in tree networks

In this section, we focus on tree networks and give an algorithm to compute exact worst-case backlog in the linear model. The algorithm is a generalization of the one given in [11] with the following differences:

1. our algorithm computes a worst-case backlog at a server; 2. it can be applied to compute the worst-case backlog at a server for any set of flows crossing this server;

3. it is valid for any tree topology.

The two algorithms and their proof are based on the same ideas, so we skip the detailed proof here. The complete proof is in Appendix A.

Let us first give some additional notations used in the algorithm to describe a tree network. First, its induced graph is a tree directed to vertex n, whose output degree 0. Each other vertex j has output degree 1. We denote by j • its successor and assume that j < j • and set n • = n + 1 by convention. The set of predecessor of a vertex is

• j = {k | k • = j}.
There exists at most one path between two vertices j and k, denoted j k. Finally, if there exists a path from j to k, •j k is the predecessor of k of this path.

Suppose that we are interested in computing the worst-case backlog at server n for some flows crossing it. We denote by I ⊆ N m those flows of interest.

• r k j = i∈Fl(j)\I,π i ( i )=k r i is the arrival rate at server j for all flows ending at server k and crossing server j that are not of interest;

• r * j = i∈I∩Fl(j) r i is the arrival rate of the flows of interests that cross server j.

Algorithm 1: Worst-case backlog algorithm

1 begin 2 ξ n n ← r * n /R n -r n n ; 3 Q = queue( • n); 4 while Q = ∅ do 5 j = Q[0]; 6 k ← n; 7 while ξ k j • > (r * j + ∈k • n ξ j • r j )/(R j - ∈j k r j ) do 8 ξ k j ← ξ k j • ; 9 k ← •j k; 10 for from j to k do 11 ξ j ← (r * j + ∈k • n ξ j • r j )/(R j - ∈j k r j ); 12 Q ← enqueue(dequeue(Q, j), • j);
13 for j from 1 to n do ρ j ← r * j + ∈j n ξ j r j ; 1) ; Theorem 4. Consider a tree network with n servers offering rate-latency strict service curves β R j ,T j , and m flows with leaky-bucket arrival curves γ b i ,r i . Let I be a subset of flows crossing server n. Then there exists (ρ j ) j∈Nn and (ϕ i ) i∈Nn such that the worst-case backlog at server n for flows in I is

14 for i from 1 to m do 15 if i ∈ I then ϕ i ← 1 ; 16 else ϕ i ← ξ π i ( i ) π i (
B = n j=1 ρ j T j + m i=1 ϕ i b i , (6)
where the coefficients ρ j and ϕ i depend only on r i and R j and are computed by Algorithm 1. This algorithm runs in time O(n 2 + m).

If there is only one flow for each possible source/destination pair, then m ≤ n 2 /2 and the algorithm runs is O(n 2 ).

Sketch of the proof. The proof of the theorem is based on the construction of an admissible trajectory (i.e. cumulative functions for each flow, at the input/output of each server in the path of this flow, that respect the input and output constraints given by the arrival and service curves) whose backlog at server n is maximal for the flows in I (we call it a worst-case trajectory).

Similar to the proof in [11], the proof is in two steps. First, we show that there exists a worst-case trajectory that satisfy some properties. The second step is to construct a worst-case trajectory among the trajectories having those properties.

Properties of a worst-case trajectory: suppose that the worst case backlog is obtained at time t n+1 = t n • . There exists a worst-case trajectory that satisfy the following properties.

1. The service policy is SDF (shortest-to-destination-first).

2. For each server j, there is a unique backlogged period [t j , t j • ], where the service offered is as small as possible.

3. The arrival function of flow f i entering the system at server j is maximal from t j , the start of the backlogged period of server j for all t > t j and 0 otherwise.

4. Data from the flows of interest in I crossing server j are instantaneously served at time t j • and are all in server n at time t n+1 .

These properties are straightforward generalizations from [11] to trees.

Worst-case trajectory with the properties: Once the set of trajectories has been restricted to the one satisfying the four properties above, the only optimization remaining is choosing the dates t j . Indeed, if dates t j are fixed, the four properties above exactly determines the trajectory. Intuitively, the larger the backlog transmitted to the next server, the larger the backlog at server n. The maximization of the transmitted backlogs is done by a backward induction, from the root of the tree (server n) to the leaves that is detailed in Appendix A. This optimization is then translated into Algorithm 1.

Worst-case delay

The worst-case delay of a flow can be deduce from the worst-case backlog when I is reduced to this flow.

Corollary 1. Suppose that flow 1 crosses server n. Then the worst-case delay of flow 1 starting at server j and ending at server n is

∆ = B -b 1 r 1 + ξ n j b 1 r 1 ,
where B and ξ n j are the worst-case backlog and coefficient obtained from Algorithm 1 when I = {1}.

Proof. Suppose the flow of interest is f 1 , with starting at server π 1 (1) = j and ending at server π 1 ( 1 ) = n. We are interested in computing the worst-case delay of this flow. From [11], the worst case delay is obtained for the bit of data b 1 . We can then do the following modification: assume there are m + 1 flows. Flows f 2 to f m remain unchanged, flow f 1 has arrival curve t → b 1 and flow f 0 has arrival curve t → r 1 t. The flow on interest is now flow f 0 . The worstcase backlog is obtained at time t n+1 , and is r 1 (t n+1 -t j ). It is maximal when t n+1 -t j is, and then is the worst-case delay for the first bit is data of flow f 0 , which is equivalent to bit of data b 1 of the original network.

Let B be the worst-case backlog obtained with Algorithm 1 with the original network. With the modified network, the backlogs becomes B = B -b 1 + ξ n j b 1 , as the new flow f 1 is not of interest (in the transformation, ϕ 1 changes from 1 to ξ n j ), then the worst-case delay is B /r 1 , which corresponds to the desired result.

Application to sink-trees Sink-trees are tree topologies where the destination of every flow is the root (node n). In this special case, each iteration of the external loop (lines 5-13) can be performed in constant time (there is only one test to perform). Moreover, the number of flows is at most the number of servers. As a consequence, the algorithm can be performed in O(n). This type of topology has been studied in the context of Sensor Network Calculus. In [START_REF] Bondorf | Boosting sensor network calculus by thoroughly bounding cross-traffic[END_REF], the authors give a close-form formula for the maximum backlog at the root and the end-to-end delay of a flow of interest.

Concerning the maximum backlog, this corresponds in our algorithm to the case where every flow is a flow of interest, so φ i = 1 for each flow i and ρ j = r * j . It is easy to see that the formula is the same as in [START_REF] Bondorf | Boosting sensor network calculus by thoroughly bounding cross-traffic[END_REF]Theorem 14]. Concerning the end-to-end delay of a flow, we show on a simple example that our approach leads to tighter delays. Consider the toy example with two servers in tandem described in Figure 3. The worst-case delay bound from [6, Theorems 18 and 15] is

γ b,r β2R,T βR,T γ b,r
D 1 = 2T + 2b + rT R .
With our algorithm, we compute ξ 2 2 = r 2R-r and ξ 2 1 = r R , so the worst-case delay is, from Corollary 1,

D 2 = 2T + b R + b + rT 2R -r .
As R > r, D 2 < D 1 . This is quite intuitive, as the cross-traffic arrives at server 2, and then is served at rate 2R.

Arrival curve for the departure processes Corollary 2. With the same notations as in Theorem 4, the arrival curve of the departure functions from server n for flows in

I is γ B, i∈I r i .
This is a direct consequence of Theorem 4 and of Lemma 2.

Lemma 2. Consider a system and flows crossing that system being globally constrained by the arrival curve γ b,r . If the maximal backlog of these flows in this system is less than B, then the arrival curve for the departure process of these flows is constrained by γ B,r .

Proof. Let F (in) be the sum of the arrival processes of the flows of interest and F (out) the sum of departure processes. Fix s < t, and transform F (in) from time s: for each flow of interest, the arrival process becomes maximal: a burst arrives at time s, and then data arrival at rate r.

Call F this process. We have F (s) -F (out) (s) ≤ B, by hypothesis, and

F (out) (t) ≤ F (in) (t) ≤ F (s) + r(t -s). So F (out) (t) -F (out) (s) ≤ F (s) + r(t -s) -F (out) (s) ≤ B + r(t -s).

Stability and performance bounds in cyclic networks

In this section, we combine the results of the two previous sections. We first restrict to the linear model, and in the last paragraph, we show how those results could be extended to more general cases.

One-stage optimization problem

We first investigate the one-stage optimization problem of Equation ( 4). Given a network, several transformations are possible, and we give here three of them. Due to the linear model, the optimization problem boils down to a linear program: there exist a non-negative matrix M ∈ R L,L , a non-negative column-vector N ∈ R L , a non-negative line-vector Q ∈ R L and a non-negative constant C such that performance P can be compute as

Maximize Qb + C such that b ≤ M b + N . (7)
A stability condition is given by the following theorem:

Theorem 5. If the spectral radius of M is strictly less than 1, then N is stable.

As a consequence, depending on the decomposition we will obtain different stability conditions. In the following, we only explicit the construction of M and N . Vector Q and constant C can be computed by similar methods.

Server decomposition

In the literature, the most usual decomposition is into elementary servers (A r = A) and elementary flows (no grouping). With our notation,

S = {(i, k) | i ∈ N m , 1 ≤ k ≤ i } and π i,k = π i (k) , and L = |S| = i∈Nn i .
The decomposition of S is into singletons, and if S = {(i, k)}, we simply denote by α i,k the smallest arrival curve of f i,k .

From classical results (see [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF]Sec. 6.3.2] for example), for all k < i ,

α i,k+1 ≤ α i,k (β j - s∈S j \{(i,k)} α s ) + , (8)
and α i,1 = α i , which gives for leaky-bucket and rate-latency curves, and under stability assumption, that α i,k = γ b i,k ,r i and from Equation ( 8),

b i,k+1 ≤ b i,k + r i R j -p∈Fl(j)\{i} r p ( s∈S j \{(i,k)} b s + R j T j ).
Parameters T j , R j and r i are fixed and b s are variables, this equation gives the coefficients of M and N , that we denote M SD and N SD in the following.

Tree decomposition

In this paragraph, we use the decomposition into a tree instead of decomposing the network into elementary servers.

Suppose that arcs A r have been removed such that the remaining network is a tree networks. In this case, as a tree has exactly n -1 arcs, so L = |S| ≤ i∈Nn i -n + 1.

Consider a = (j 1 , j 2 ) ∈ A r and f i,k a flow such that j 1 = π i,k ( i,k ) and j 2 = π i,k+1 [START_REF] Àlvarez | A characterization of universal stability in the adversarial queuing model[END_REF]. An arrival curve for flow f i,k+1 can be computed from the others: from Lemma 2, an arrival curve for flow f i,k+1 is γ b i,k+1 ,r i where b i,k+1 is the maximum backlog for flow i at server j 1 computed with Algorithm 1. As b i,k+1 is linear in the bursts of the other flows, there exists (ϕ i,k+1 s ) s∈S and (ρ i,k+1 j

) n j=1 such that b i,k+1 ≤ s∈S ϕ i,k+1 s b s + {j|j j 1 } ρ i,k+1 j T j ,
where the exponent i, k+1 emphasizes the fact that the backlog computed is the burst parameter of α i,k+1 .

As a consequence, with M TD and N TD playing the role of M and N above, we have (M TD ) s,s = ϕ s s and (N TD ) s = {j|j j 1 } ρ s j T j . Example 4. Consider the tree decomposition of Figure 2 is obtained.

To find the other equations, we apply Algorithm 1 and with the notations above,

     b 1,2 = b 1,1 + ϕ 1,2 2,1 b 2,1 + ϕ 1,2 1,2 b 1,2 + Cst 1 b 2,2 = b 2,1 + ϕ 2,2 1,1 b 1,1 + ϕ 1,2 1,2 b 1,2 + Cst 2 b 3,2 = b 3,2 + ϕ 3,2 1,2 (b 1,2 + b 2,2 + b 4,1 ) + ρ 3,2 2 T 2 . (9)
Note that the expression of b 3,2 only depends on the behavior of server 2. Indeed, Algorithm 1 only explores a server and its descendants, but server 2 has none. Also, note that from Algorithm 1, two flows following the same path have the same linearity coefficient: ϕ 3,2 1,2 = ϕ 3,2 2,2 = ϕ 3,2 4,1 . As the backlog bounds computed with Algorithm 1 are tight, the stability condition with matrix M TD is better than that with matrix M SD .

Arc grouping

Despite the fact that Algorithm 1 computes the worst-case backlog bound for each flow, M TD having spectral radius less than one is only a sufficient condition for the network stability. Indeed, the linear system is obtained by running Algorithm 1 independently |S| times, but worstcase bounds for flows s and s ending at the same server do not happen at the same time. Indeed, consider two flows with respective arrival curve γ b 1 ,r 1 and γ b 2 ,r 2 crossing a server offering a strict service curve β R,T . Then the worst-case delay for flow 1 is

B 1 = b 1 + r 1 R-r 2 (b 2 + RT ), for flow 2 is B 2 = b 2 + r 2 R-r 1 (b 1 + RT ) and the worst-case backlog in the server is B = b 1 + b 2 + (r 1 + r 2 )T . Obviously, B < B 1 + B 2 .
In this paragraph, our strategy is to group flows according to the removed arcs. Suppose that the network is stable and denote by B a the worst-case backlog at arc a = (j 1 , j 2 ) ∈ A r , that is the maximal backlog at server j 1 of flows having j 1 , j 2 as a sub-path. We denote

S a = {(i, k) ∈ S | π i,k ( i,k ) = j 1 and π i,k+1 (1) = j 2 } and S a = {(i, k+1) ∈ S | π i,k ( i,k ) = j 1 and π i,k+1 (1) = j 2 }.
With Algorithm 1, one can compute an upper of bound B a for each a ∈ A r : ∃ϕ a s and ρ a j such that

B a ≤ s∈S ϕ a s b s + {j|j j 1 } ρ a j T j .
The next step is to refine this equation so that (B a ) a∈A r appear in the right-hand term instead of (b s ) s∈S . We know from the proof of Theorem 4 that the worst-case backlog is maximized when the cross-traffic is maximal. Consider arc a = (j 1 , j 2 ) ∈ A r . For all s ∈ S a , the arrivals of f s will all be maximized from time t j 2 . At this time, the backlog in server j 1 is at most B a and the backlog of each flow transmitted to server j 2 is x s with s∈S a

x s ≤ B a . From time t j 2 on, data of flow f s necessarily arrives at rate r s : if it could arrive faster, the backlog would not have been maximized.

As a consequence, for all a = (j 1 , j 2 ) ∈ A r , if B a is the worst-case backlog at server j s , for flows f s , s ∈ S a , there exists (x s ) s∈S a such that s∈S a

x s ≤ B a and

B a ≤ s∈S ϕ a s x s + {j|j j 1 } ρ a j T j ≤ a ∈A max s∈S a ϕ a s s∈S a x s + m i=1 ϕ a (i,1) b i + {j|j j 1 } ρ a j T j ≤ a ∈A max s∈S a ϕ a s B a + m i=1 ϕ a (i,1) b i + {j|j j 1 } ρ a j T j .
As a consequence, with M AG and N AG playing the role of M and N above, we have (M AG ) a,a = max s∈S a ϕ a s and (N AG ) a = m i=1 ϕ a (i,1) b i + {j|j j 1 } ρ a j T j .

Example 5. We compute backlog bounds for arcs a 1 = (4, 2) and a 2 = (2, 1) and obtain.

B a 1 ≤ N a 1 AG + (ϕ a 1 1,2 ∨ ϕ a 1 2,2 )B a 1 + ϕ 3,2 B a 2 B a 2 ≤ N a 2 AG + ϕ a 2 1,2 B a 1 .
A sufficient condition for the stability is then given by (ϕ

a 1 1,2 ∨ ϕ a 1 2,2 ) + ϕ 3,2 ϕ a 2 1,2 < 1.
It is not possible to compare the stability bound with M AG with M TD or M SD : there are examples where the stability bound will be better, for the unidirectional ring for example, and some examples where it will be worse, like for the bidirectional ring. In the next section, we present those two examples that illustrate the advantages and limits of this latter approach.

Examples

Stability of the unidirectional ring

Consider a ring with n nodes. Its induced graph is

G with A = {(i, i + 1), i ≤ n -1} ∪ {(n, 1)}.
The transformation into a tree gives a tandem networks by removing arc (n, 1). Flows are decomposed in either one flow or two flows. Grouping flows that cross this arc enables to show the stability of the unidirectional ring. Theorem 6. The unidirectional ring is stable under local stability condition.

Proof. We consider matrix M AG and take A r = {(n, 1)}. With I the set of flows that circulate through arc (n, 1), S (n,1) = {(i, 2) |i ∈ I}. When computing the worst-case backlog at arc a, the flows of interests are flows f (i,1) for i ∈ I and

B a ≤ max s∈Sa ϕ a s B a + C,
where C is a constant there is no need to explicit in this proof. So it remains to show that for all s ∈ S a , ϕ a s < 1. As (i, 2) ∈ S a is not a flow of interest, ϕ (i,2) = ξ

π i ( i ) 1
. Observe from Algorithm 1 how ξ j are computed: because of the local stability,

R n > r n n + r * n , so ξ n n < 1. Now assume that ξ k j • < 1 (lines 7-11). Either ξ k j = ξ k j • < 1, or ξ j = (r * j + ∈k • n ξ j • r j )/(R j - ∈j k r j ) ≤ (r * j + ∈k • n r j )/(R j - ∈j k r j ) < 1
, as from local stability condition. As a consequence, for all j and , ξ j < 1 and max s∈Sa ϕ a s < 1, and B a ≤ C(1 -max s∈Sa ϕ a s ) -1 , ensuring the stability of the network. This result has already been proved under stronger assumptions: in [START_REF] Tassiulas | Any work-conserving policy stabilizes the ring with spatial re-use[END_REF] when servers are constant-rate servers and in [START_REF] Boudec | Network Calculus: A Theory of Deterministic Queuing Systems for the Internet[END_REF] when servers have a maximal service rate. Our method is not specific to the ring topology, so we can hope to improve the stability conditions for more general topologies.

The bi-directional ring

An example where grouping according to the arcs is not be efficient is the bi-directional ring with n servers. Suppose the network is crossed by 2n flows of length n: π 1 = 1, 2, . . . , n , π n+1 = n, n -1, . . . , 1 , π i = i, i + 1, . . . , n, 1 . . . , i -1 and π n+i = i, i -1, . . . , 1, n . . . , i + 1 for i = 2, . . . , n. The tree decomposition is obtained by keeping arcs {(i, i + 1), i ≤ n -1} and the path obtained after the decomposition are the one obtained for the unidirectional ring for f 1 , . . . , f n , and flows of length 1 for the other paths.

With this decomposition, we can never ensure stability: let us look at the coefficient ϕ a a that are computed. Consider arc a = (2, 1) for example. Among the flows of interest are the flows f a (i,k) of path 2 , with k = 1, so ϕ a (i,k) = 1. This means that (M AG ) (

= 1, and the similarly, (M AG ) (j,j-1),(j+1,j) = 1 and (M AG ) (1,n),(2,1) = 1. There is a cycle of coefficients 1 in the matrix: the spectral radius of M AG is at least 1.

More generally, grouping according to the arcs will never ensure the stability if in matrix M AG it is possible to find a cycle with weights one on all its arcs. As a consequence, intermediate solution between no grouping of flows and grouping among the arcs might lead to better solutions. For example, in the case of the bi-directional ring, a better solution would be to group flows for the removed arc (n, 1) only, and not group the other flows.

Two-stage optimization problem

We have seen in through the examples of the previous paragraph that different stability conditions and performance bounds can be found, depending on how the network is decomposed. Following the approach of Equation ( 5), it is possible to combine the optimization problems:

Maximize Qb + C such that b ≤ b, s∈Sa b s ≤ B a b ≤ M TD b + N TD , B ≤ M AG B + N AG .
This formulation slightly differs from the one in Equation ( 5): constraint 'b s ≤ B a ∀s ∈ S a " has been replaced by " s∈Sa b s ≤ B a ". Indeed, by a reasoning similar to that of Paragraph 5.1.3, we can fix a = (i, j) ∈ A r . If the worst-case backlog at server i for flows crossing a is B a this means that when this worst-case happens, there is no data of these flows in the rest of the network (which would deny the maximality of B a ). Consider a flow f s , s ∈ S a . Its amount of data in arc a is x s , and its arrival rate r s . Data cannot arrive faster than r s , so from the time of worst-case backlog, flow f s is γ xs,rs -constrained.

General arrival and service curves

Beyond the linear model, it should be possible to obtain tighter bounds by using more general arrival and service curves. For example, stair-case functions, or piece-wise linear arrival curves and service curves. A first remark is that the stability conditions given here only depend on the arrival and service rates, then, in the case it is possible to refine these results to more general curves (as it is for the SD method), no better stability condition can be inferred. Indeed, a general curve can usually be lower and upper-bounded by two token-bucket curves, inducing a lower and an upper-bound of the network by two linear models with the same stability condition.

The second remark is that it would still be possible to improve the performance bounds. To our knowledge, there is no evidence in the literature that the equation α = H(α) has a unique fix-point in the general case. One safe solution is to compute the greatest fix-point by iterations methods. The first step of this approach is to find an upper bound of that greatest fix-point. This can be done by computing the fix point of that equation in the linear model (by bounding the arrival and service curves by linear curves), and the second step is to iterate from that point for refining the performance bounds. At each iteration, the performance bound obtained is an upper bound of the performance of the network.

Comparison and numerical experiments

The different approaches have been implemented in Python and run on a basic laptop. We will not comment on the computational time as all those algorithms are polynomial, and the number of constraints of our linear programs are linear in the size of the networks.

We call SD the server decomposition method, TD the tree decomposition method, AG the arc grouping method and 2S 2-stage method.

We compare those methods on three examples: the unidirectional ring, the bidirectional ring and a 3-ring network.

In the experiments we assume that the utilization rate of the network is U = min n j=1 U j . flows have uniform parameters: b i = 1kb, r i = 1kb.s -1 for all i ∈ N m , and T j = 10ms for all j ∈ N n . Only the service rate will vary in function of an utilization rate: the utilization rate of server j is U j = i∈Fl(j) r i R j , and

The unidirectional ring

We now consider the example of the unidirectional ring described in Section 5.2.1 with n = 10.

Figure 4 shows the backlog guarantee at server n of flow 1 for uniform traffic: servers all have the same service rate R = 10/U kbs -1 . The stability conditions are U < 0.18 for SD and U < 0.62 for SD, so our methods greatly improves the stability region. We notice that AG is better than TD, so AG and 2S compute the same bounds.

Fig. 5 (left) shows the ratio between the stability bounds with SD and with TD as the number of servers increases on the ring. The ratio grows linearly.

Fig 6 shows the backlog guarantee of flow 1 at server n when the servers have different service rates: every service rate is R = 20/U kbs -1 , except R 9 = R 10 = 10/U kbs -1 .

In this case, TD is better than AG for U < 0.68, and around the stability limit given by TD, we observe 2S increases faster as the backlog computed with TD grows to infinity. Then 2S and AG compute of course the same bound. Figure 7 shows the worst-case backlog bound of flow 1 at server n computed by the elementary decomposition and tree transformation. As expected, the stability condition with TD (U < 0.24) is improved from SD (U < 0.19). The improvement is approximately 25%. Fig. 5 (right) shows the improvement ratio when the number of servers grows. In this case, the improvement seems logarithmic, and for n = 30, it is approximately 33%. T D method suffers from having half the flows decomposed in flows of length 1.

A three-ring example

The bidirectional cycle is not realistic, as in many network are full-duplexed, but there might be several cycles in network. Fig. 8 shows an example of a network composed of three cycles, and flows circulate along one of the three cycles. Three servers (those depicted) are common to two cycles. Fig. 9 shows the backlog of a flow when each cycle is made of 10 servers, and flows have length 10, except for one cycle, where we use shorter flows to avoid the problem presented in Paragraph 5.2.2. We can observe that the stability region more than doubles from the SD (U < 0.34) to the TD method (U < 0.73). The improvement using grouping is smaller (U < 0.77), but still sensible.

Conclusion

In this article, the recent results from feed-forwards networks can be adapted to improve the performance guarantees and stability conditions of networks with general topology.

Many problems remain open and directions to investigate: finding the transformation of the network that would lead to better guarantees, adapt recent results for example [START_REF] Bondorf | Improving cross-traffic bounds in feed-forward networks -there is a job for everyone[END_REF] that can be applied for general arrival and service curves. Future works will also include the adaptation to service policies, like the FIFO of static priority policies.

More A.2 Inductive step -computation of B j from B j+1

Suppose that B j+1 (x j+1 , . . . , x n , x * ) = C j+1 + x * + n k=j ξ k j x k . B k j (x j j , . . . , x n j , x * ) is computed the following way: it takes time δ to serve flows ending at servers j, . . . , k, and data from any other flow is instantaneously transmitted to server j + 1. This quantity of data is x j+1 = b j + x j + r j δ for > k where δ satisfies k =j (x j + b j + r j δ) = R j (δ -T j ) + , i.e., δ = T j + k =j Q j / R j -k =j r j with Q k j = b k j + x k j + r k j T j . For > k, the amount of data transmitted to server j + 1 by flows (not of interest) ending at server k ≤ j is

x j+1 = Q j + r j k =j Q j R j -k =j r j .
Then the backlog at server n can be expressed from B j+1 : B k j (x j j , . . . , x n j , x * ) =B j+1 (0 . . . , 0, x k+1 j+1 , . . . , x n j+1 , b * j + x * + r * j δ).

=C j+1 + b * j + x * + r * j T j + k =j Q j R j -k =j r j + >k ξ j+1 Q j + r j k =j Q j R j -k =j r j =C j + x * + r * j k =j Q j R j -k =j r j + >k ξ j+1 Q j + r j k =j Q j R j -k =j r j =C j + x * + k =j r * j + >k ξ j+1 r j R j -k =j r j Q j + >k ξ j+1 Q j
with C j = C j+1 + b * j + r * j T j . Note the other scenarios should have been taken into account, when part of the flows ending at server k is served and another part is transmitted to server j + 1. It can be easily proved that these "mixed" scenarios cannot lead to strictly larger worst-case backlog (see Lemma 4 in [11] for a proof). Lemma 3. There exists k such that B j = B k j (that is, for all x j , . . . , x n , x * , we have B j (x j , . . . , x n , x * ) = B k j (x j , . . . , x n , x * )) and for all k, ξ k j ≥ ξ k+1 j .

Proof. The proof is also by induction. We prove that ∀j, we have the equivalence

B j = B k j ⇔ ∀k > k ξ k j+1 > i≤j r * i + >k ξ j+1 r j R j -k =j r j and ξ k j+1 ≤ i≤j r * i + >k ξ j+1 r j R j -k =j r j .
Assertion (B) is proved at the same time: assuming that (B) is satisfied for server j + 1, we will prove it for server j.

The equivalence above also state that if for all k > k B j = B k j , then B n j ≤ B n-1 • either r * j + >k ξ j+1 r j R j -k =j r j (for B k j )

• or ξ k j+1 (for B j , < k). Suppose that r * j + >k ξ j+1 r j R j -k =j r j ≥ ξ k j+1 .

For ≤ k < k, the coefficient of

Q j in B k j is r * j + >k ξ j+1 r j R j -k =j r j ≤ r * j + n =k+1 r j ξ j+1 + k =k +1 r j ξ k j+1 R j -k =j r j ≤ r * j + n =k+1 r j ξ j+1 + k =k +1 r j r * j + >k ξ j+1 r j R j -k =j r j R j -k =j r j = r * j + n =k+1 r j ξ j+1 R j -k =j r j 1 + k =k +1 r j R j -k =j r j = r * j + n =k+1 r j ξ j+1 R j -k =j r j
which is the coefficient of Q j in B k j . The first inequality uses (B) for server j + 1 and the second uses Inequality [START_REF] Bouillard | Tight Performance Bounds in the Worst Case Analysis of Feed Forward Networks[END_REF].

Moreover, for k < < k, the coefficient of

Q j in B k j is ξ k j+1 ≤ ξ k j+1 ≤ r * j + >k ξ j+1 r j R j -k =j r j
, so B k j ≥ B k j and B j = B k j . The same kind of computations lead to B k-1 j > B k j if ξ k j+1 > r * j + >k ξ j+1 r j R j -k =j r j .

Set ξ k j according to the B j that is computed (that is B k j for some k). Then we still have ξ j ≥ ξ +1 j and (B) is true for server j.

1 Figure 1 :

 11 Figure 1: Toy network of Example 1.

  be the set of flows that have been created with the feed-forward transformation and S 1 , . . . , S L ⊆ S with S 1 S 2 • • • S L = S (the symbol denotes the disjoint union).

Figure 3 :

 3 Figure 3: Example of sink-tree.

Figure 4 :

 4 Figure 4: Backlog bound for the unidirectional ring and uniform servers.

Figure 5 :Figure 6 :Figure 7 :

 567 Figure 5: Ratio of stability bounds on the ring with the number of servers grows. Left: unidirectional ring; right: bidirectional ring.

Figure 9 :

 9 Figure 9: Backlog bound for the three-ring example.

jR j -n =j r j Q j and B n- 1 j= 1 j.

 11 ≤ • • • ≤ B k j . Indeed, we have the equivalence B j = B n j ⇔ ξ n j+1 > r * j R j -n =j r j ⇔ r * j R j -n =j r j < r * j +ξ n j+1 r n j R j -n-1 =j r j But B n j = C j + x * + ≤n i≤j r * i C j + x * + ≤n-1 i≤j r * i + ξ n j+1 r j R j -n-1 =j r j Q j + ξ n j+1 Q n j .So B n j ≤ B n-The next steps can be shown similarly. Let us assume thatB n j ≤ B n-1 j ≤ • • • ≤ B k j . The coefficient of Q j in B kj for all k ≤ k and > k is ξ j+1 and that of Q k j is

Finally

  j T j + k≥j ξ k j r k j T j ) + i≤n b * i + j≤k≤n ξ k j b k j .

  generally, the stability problem remains open.

	0.01	1.04843018865	1.03003970439	1.03157491266	1.03003956473
	0.015	1.05803963769		1.03516270593	1.03748103313
	1.03516241589
	0.02	1.06792652515	1.04035641182	1.04346858223	1.04035624789
	0.025	1.07810254997		1.04562232682	1.04953926172
	1.04562207545
	0.030000000000000002	1.08858010879	1.05096199835	1.05569487794
	1.05096160991 0.035 1.09937235137 0 0.1 0.2 0.3 10 0	0.4	1.05637701805 0.5 0.6	1.06193739419 0.7 0.8
	1.05637638807
	0.04	1.11049324151	1.06186902327	1.06826866547	1.06186813863
	0.045	1.12195762415		1.06743969883	1.07469068152
	1.0674387523
	0.049999999999999996	1.13378129941	1.07309077863	1.08120549712
	1.07308990444
	0.05499999999999999	1.14598110437	1.07882404752	1.08781521923
	1.07882272777
	0.05999999999999999	1.15857500368	1.08464134315	1.09452201991
	1.08463969874
	0.06499999999999999	1.17158218999	1.09054455789	1.10132813883
	1.09054244568
	0.06999999999999999	1.18502319562	1.09653564095	1.10823584836
	1.09653285715
	0.075	1.19892001688		1.10261660044	1.1152476146
	1.10261317395
	0.08	1.21329625282	1.10878950563	1.12236579679	1.10878542261
	0.085	1.22817726043		1.11505648932	1.1295929672
	1.11505155562
	0.09000000000000001	1.24359032848	1.12141975021	1.13693173532
	1.12141367639
	0.09500000000000001	1.25956487298	1.12788155553	1.14438479765
	1.12787435193
	0.10000000000000002	1.27613265718	1.13444424366	1.15195493842
	1.13443550677
	0.10500000000000002	1.29332804	1.14111022696	1.15964503295
	1.14109974331
	0.11000000000000003	1.31118825722	1.14788199468	1.16745805138
	1.14786968398
	0.11500000000000003	1.32975374069	1.15476211608	1.17539705992
	1.15474802568
	0.12000000000000004	1.34906848162	1.16175324359	1.18346523043
	1.16173672284
	0.12500000000000003	1.36918044535	1.16885811626	1.19166584179
	1.16883885349
	0.13000000000000003	1.39014204638	1.17607956324	1.20000228337
	1.17605722353
	0.13500000000000004	1.41201069407	1.18342050755	1.20847806057
	1.18339469766
	0.14000000000000004	1.43484942177	1.19088396997	1.21709679967
	1.19085420287
	0.14500000000000005	1.45872761466	1.19847307315	1.22586225209
	1.19843930476
	0.15000000000000005	1.48372185491 21	1.20619104591	1.23477830239
	1.20615250589
	0.15500000000000005	1.50991690695	1.21404122779	1.24384897182
	1.21399734712
	0.16000000000000006	1.53740687086	1.22202707381	1.25307842494
	1.22197728291

A Proof of Theorem 4

To avoid introducing too many notations, we first prove the result for tandem networks (A = {(i, i + 1) | i ∈ N n-1 }). We then explain how to adapt it to sink-trees.

We prove the theorem by a backward induction on the servers. Let us denote by B j (x j , . . . , x n , x * ) the backlog at time t n+1 in server n when the backlog transmitted at time t j by server j -1 to server j is x k for the flows served by server j -1 and that end at server k (k ≥ j) and x * for the flows of interest crossing server j -1.

We will use the additional notations

is the size of the burst arriving at server j at time t j belonging to flows starting at server j and ending at server k;

)=j} b i is the burst of the flows of interests starting at server j.

If we are able to compute B j for all j, the worst-case backlog is B = B 1 (0, . . . , 0). We will show by induction that:

where ξ k j only depends on the R k 's and r This inequality (B) is quite intuitive: the coefficient ξ k j roughly corresponds to quantity of data produced by a flow starting at j and ending at k the rate grows when the length of the path grows, as there is more chance to meet a slower server.

A.1 Initialization -computation of B n

B n only depends on the burst that is transmitted at time t n+1 , which we note x n n for the flows that are not of interest and x * for the flows of interest. The worst-case backlog for the flows of interests is obtained when all data from the other flows have been served and none of the flows of interests:

A.3 Adaptation to trees

Consider now a sink-tree, the above analysis is still valid, and each branch of the tree can be analysed independently: if a server has several predecessors, then the optimization will be for each of the on disjoint sets of servers and flows. The algorithm still runs in polynomial time.