We present a We consider the problem of simultaneous scheduling and resource allocation of an incoming flow of requests for a set of computing nodes (or perhaps edge-servers, but this is too specific ) holistic solution to the intricate problem of scheduling and resource allocation of a set of edge-servers. By representing each server as a node, we model the overall system as a multi-queue scheme. Inspired by congestion control approaches in networks and communications, we propose an AIMD-like (additive increase multiplicative decrease) admission control policy that we show to be stable  irrespective of the total number of nodes and AIMD parameters. The admission policy allows us to establish an event-driven discrete model, triggered by a locally identifiable enabling condition. Subsequently, we propose a decentralized resource allocation strategy via a simple nonlinear state feedback controller, guaranteeing global convergence to a bounded set in finite time. Last, we reveal the connection of these properties with Quality of Service specifications, by calculating the local queuing time by a simple formula consistent with Little's Law.

§ INTRODUCTION

Edge I would write directly Remote, distributed computing is a new paradigm.... computing is a new distributed computing paradigm emerging to address the growing demand for I would write 'growing demand for extensive, real-time computations' computing at the edge as a result of the growing number of end-users (e.g., smart devices, sensors) connected to the edge of the Internet. Although this important technology opens new opportunities for more sophisticated applications (see, e.g., <cit.> these are perhaps too specific we need something more general...) I would put three surveys, one in offloading in edge computing, one in cloud robotics, one in edge computing. I think these are actual papers, if you can find these great, if not let me know I will include. This emerging technology sets several research challenges, especially in the context of resource allocation and control of edge-servers due to factors, such as vital latency constraints, limited capacity of edge-servers, inherent decentralized structure.

I think this paragraph should be first; lets explain the state of the art first: a grouping in terms of models including ones with sysid, a grouping between deterministic and stochastic considerations of workload, and a grouping between separate admission control  / resource allocation or both.
Feedback control has been a powerful mathematical tool for tackling management problems in the context of modern computer systems, <cit.>. Based on some solid dynamical model, control theory allows analytical derivation of formal guarantees and certificates. However, modelling computer systems is a formidable task by itself, thus, many works rely on application-specific models obtained via system identification methods. See for example <cit.>. In contrast, following a queueing system modelling approach, our method does not rely on any identification algorithm this is a bit too agressive, one can argue that queuing models do not take into account local server dynamics that could be captured by a more refined model. we can note that there are advantages for each approach, and we follow a more abstract modeling agnostic to specificities of each node. We might lose accuracy, but gain scalability, and vice versa. Notable works avoiding application-specific modelling can be found in <cit.>.

The control problem we consider in this paper consists of $1)$ the scheduling of a stream of requests demanding a combination of resources (e.g., CPU time, memory, disc space) but we do not do that, right? perhaps we should not mention that and $2)$ the resource allocation of a set of edge-servers associated with a specific application. Representing each server as a node and associating each node with a queue, we model the entire scheme as a multi-queue system. We assume that there is no interaction between nodes and servers are independent from each other. The set of independent nodes is coupled by a central node from which requests are dispatched to individual nodes. Queues in this work are consistent with the First Come First Served (FCFS) selection discipline.
I think we need first to mention some other works and how they are deadling iwth this.

Our approach to scheduling and resource allocation is motivated by the Additive Increase Multiplicative Decrease (AIMD) algorithm, a celebrated method in network management. The AIMD algorithm was originally introduced in <cit.> for tackling congestion phenomena in computer networks in a robust and decentralized manner requiring minimum interaction between nodes. Since then, it has become fundamental building block of the Transmission Control Protocol (TCP) widely used across the Internet.An excellent and comprehensive study of the AIMD algorithm with several extensions and applications can be found in <cit.>.

In our setting, we study how an AIMD-inspired simple admission control policy can be utilized for general scheduling problems. A typical AIMD model results in an event-driven discrete controller which is triggered by a capacity event associated, e.g., with bandwidth constraints. Berman et al. in <cit.> and Shorten et al. in <cit.> show that such a control scheme can be formulated as positive system, thus, stability and convergence properties can be derived exploiting the Perron–Frobenius Theorem. A first challenge we face is that a positive system formulation is not possible in our case due to the absence of a capacity constraint in a scheduling task. Instead, we consider a queue clearance event and manage to show stability via a significant result in Linear Algebra (cf. <cit.>) involving the eigenproblem of rank-one perturbations of symmetric matrices (Theorems <ref> and <ref>). This formulation leads to a new admission control algorithm with AIMD structure which is stable irrespective of the AIMD tuning and the number of nodes, and inherits all attractive features of the standard AIMD algorithm (e.g., fairness among nodes, tunable convergence rate) <cit.>. To the best of our knowledge, this paper presents the first admission control policy with AIMD dynamics for scheduling tasks this is risky, we should be a bit more gentle.

As a result of the simplicity of the AIMD scheduling policy proposed, we formulate a resource allocation strategy defined as a decentralized globally stabilizing nonlinear feedback controller. Following a set-theoretic approach, well, this is not so clear, we can mention invariance and cite the book... <cit.>, we prove that under the proposed resource allocation law, individual queues are bounded, and, further, converge in finite time to a well-defined interval. This effectively permits a priori analysis of Quality of Service (QoS) metrics, such as queueing time. Overall, scheduling and resource allocation lie in the same control loop leading to a simple decentralized system which is stable, scalable, and locally configurable.

Main limitations of our method are the deterministic approach to modelling workload and the unconstrained resource allocation control this is a bit abrupt, we have to explain . Unlike typical results on scheduling of queueing systems, <cit.>, we assume a multi-queue model with deterministic arrival rate. This is a strict assumption which, although simplifies our problem considerably, it permits the derivation of deterministic performance certificates. We stress that a relaxation of our results towards non deterministic workloads as well as the incorporation of constraints will be considered in an extended version of this paper.

The remaining of the paper is organized in four sections. In Section <ref>, notation used in the paper is given. Section <ref> contains definitions and assumptions which are useful later in the paper. The main results of the paper are presented in Section <ref>, along with an illustrative numerical example. Finally, Section <ref> discusses our main results and future research directions.

§ NOTATION

The field of real numbers is denoted by $\mathbb{R}$. $\mathbb{R}^{n}$ denotes the $n$-dimensional vector space over the field $\mathbb{R}$, and $\mathbb{R}^{n\times m}$ denotes the set of $n\times m$ real matrices. The transpose of $\xi$ is denoted by $\xi'$. Let $x_{1},\;\ldots,\;x_{n}$ be vectors not necessarily of the same dimensions. Then, $\hat{x}=\mathrm{Col}(x_{1},\;\ldots,\;x_{n}) = [x_{1}'\;\cdots\;x_{n}']'$. Let you use both parentheses and brackets for matrices, we should pick one for consistency $a_{1},\;\ldots,\;a_{n}\in \mathbb{R}$, then, $a = (a_{1},\ldots,a_{n})\in \mathbb{R}^{n}$, and $A = \mathrm{diag}(a_{1},\;\ldots,\;a_{n})$ is a diagonal matrix, $a_{1},\;\ldots,\;a_{n}$ being its diagonal entries. We denote by $\det(A)$ the determinant of a square matrix $A$. The identity matrix of dimension $m\times m$ is denoted by $I_{m}\in\mathbb{R}^{m\times m}$ unless the dimensions are obvious in which case the subscript will be omitted. Matrix $\Xi\in\mathbb{R}^{n\times n}$ is called symmetric if $\Xi' = \Xi$. I think the last one is ok to omit Let $\lambda_{i}(\Phi)$ be the $i$th eigenvalue of matrix $\Phi\in\mathbb{R}^{m\times m}$, with $i=1,\ldots,m$. Then, the spectrum of $\Phi$ is denoted by $\sigma(\Phi) = \{\lambda_{1}(\Phi),\ldots,\lambda_{m}(\Phi)\}$. A matrix $\Phi\in\mathbb{R}^{m\times m}$ is  Schur if all its eigenvalues strictly lie inside the unit circle, i.e., $|\lambda_{i}(\Phi)|<1$, $i=1,\ldots,m$.

§ DEFINITIONS AND BASIC ASSUMPTIONS

§.§ Single-queue system

We define a request as an individual demand for computing resources provided by a server. A server is defined as the physical (or virtual) computing environment, consisting of hardware, software, and network resources, whereby a request is executed. A queue is defined as the waiting mechanism whereby a request arriving at a server is temporarily put on hold until it is selected for service from among other requests that are waiting. Here, we consider queues consistent with the First Come First Served (FCFS) selection discipline.

A queueing system a reference here? perhpas the book you mention or Cassandras? is defined as the dynamic relationship that is developed between a stream of request arrivals at and a flow of request departures from a computing device, respectively, in the presence of a queue. From a mathematical perspective, a queue acts as an integrator to the difference between arrival and departure rates. A simple queueing system is depicted in Fig. <ref> which is consistent with the following notation.

Denoting by $\mathbf{X}(t)$ and $\mathbf{Y}(t)$ the arrivals at and departures from a queue, respectively, in interval $(0,\;t)$, the number of queued requests at time $t$, $\mathbf{Q}(t)$, is defined as the difference between arrivals and departures in interval $(0,\;t)$ is this open interval in both ways?. Note that exact knowledge of $\mathbf{X}(t)$ and $\mathbf{Y}(t)$ is typically impossible in real applications, with arrivals and departures considered as stochastic processes described by appropriate probability distributions. A comprehensive overview of stochastic queueing systems can be found in <cit.>. Here, to highlight the admission and resource allocation control strategies proposed in the paper, we simplify our model structure following a deterministic approach. Specifically, we assume the following. I like that, but perhaps we are too honest in our explanation, there are many works that have assumption A2 and also assume full knowledge. for a reader not familiar it might seem that we do something differently.

(A1) The arrival rate, denoted by $\lambda(t) = \frac{\mathbf{d}}{\mathbf{d}t}\mathbf{X}(t)$, is constant.

(A2) Requests arriving at a queueing system are identical demanding a specific combination of computing resources (CPU time, memory, disk space).

We note assumption <ref>-(A1) is considered for ease of exposition of the admission and resource allocation control strategies proposed later in the paper. This can be relaxed by assuming a piecewise constant or slowly time-varying workload (arrival rate). should we mention this again? I think either here or the introduction, but not both. More realistic assumptions on the workload statistics will be considered in an extended version of this paper.  we should say that A2 is also considered by many, perhaps not only one type, but a finite number of request types, which we could do here as well (yet, without coupling the constraints), so it is not out of the blue for us.

(0,0) – ++(2cm,0) – ++(0,-1.cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-1.cm);

(2.5,-0.5cm) circle [radius=0.5cm] node[] server;

[->] (3.,-0.5) – +(20pt,0) node[right] $\mathbf{Y}(t)$;
[<-] (0,-0.5) – +(-20pt,0) node[left] $\mathbf{X}(t)$;

at (1cm,-1.35cm) $\mathbf{Q}(t)$;

A simple queueing system.

§.§ Queueing time

Queueing time (also termed waiting time or latency reference here?) is the main performance metric of a queueing system, including edge-computing applications, expressing the time that a request is expected to be queued before processed. Given the knowledge of arrivals at and departures from a queue in interval $(0,\;t)$, we define queueing time as

\begin{equation}\label{eq:queueingTime}
T_{q}(t) =\frac{\int_{0}^{t}\mathbf{Q}(s)\mathbf{d}s}{\mathbf{X}(t)},
\end{equation}

where $\mathbf{Q}(t) =  \mathbf{X}(t) - \mathbf{Y}(t)$. Note that the integral in the numerator on the right side of (<ref>) expresses the aggregate queueing time of all requests arriving in $(0,\;t)$ measured in $\textnormal{requests}\times\textnormal{seconds}$. By averaging the aggregate queueing time and the request arrivals, respectively, by the length of interval $(0,\;t)$ as $T_{q}(t) =\frac{\int_{0}^{t}\mathbf{Q}(s)\mathbf{d}s/t}{\mathbf{X}(t)/t}$, it is easy to see that definition (<ref>)  is in agreement with Little's Law, which states that the average number of queued requests $\int_{0}^{t}\mathbf{Q}(s)\mathbf{d}s/t$ is equal to the product of average arrival rate $\mathbf{X}(t)/t$ and queueing time $T_{q}(t)$. Detailed description of Little's Law can be found in <cit.>.

§.§ Event-driven discretization and event generator

An event generator is introduced as the mechanism indicating time instants at which a well-defined (triggering) condition $\mathcal{C}_{\varepsilon}$ is satisfied. Condition satisfaction can be written as

\begin{equation}
\mathcal{C}_{\varepsilon}(t_{k}) = \texttt{true},
\end{equation}

where $t_{k}$ denotes the time instant at which the $k$th event occurs (is generated). Note that time events can be modelled by casting the continuous time as an autonomous state variable, namely,

\begin{equation}
t(k+1) = t(k) + T(k),
\end{equation}

where $T(k)$ is the time-varying sampling period.

We emphasize that the facilitation of an aperiodic model (with respect to time) derivation will be the result of two main design strategies, namely,

$1)$ the introduction of a batch queue into the system,

$2)$ the adoption of an AIMD admission control policy.

This strategic choice is now exemplified via a simple tandem queueing system.

§.§ Tandem queueing system with AIMD dynamics

We consider the two-queue system (also termed tandem queueing system) shown in Fig. <ref>, where $\lambda(t)$ is a piece-wise differentiable function representing workload, $\delta(t)$ is the number of queued requests waiting at queue $Q_{1}$ to be dispatched to queue $Q_{2}$ at an admission rate $u(t)$, while $w(t)$ and $\gamma(t)$ represent queued requests and service rate, respectively.

(0,0) – ++(2cm,0) – ++(0,-.75cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-.75cm);

(2.375,-0.375cm) circle [radius=0.375cm] node[] $u(t)$;

[<-] (0,-0.375) – +(-20pt,0) node[left] $\lambda(t)$;
at (1cm, .25cm) $Q_{1}$;

at (1cm,-1.05cm) $\delta(t)$;
[xshift = 3.5cm]

(0,0) – ++(2cm,0) – ++(0,-.75cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-.75cm);

(2.375,-0.375cm) circle [radius=0.375cm] node[] $\gamma(t)$;

[<-] (0,-0.375) – +(-20pt,0);
at (1cm, .25cm) $Q_{2}$;

at (1cm,-1.05cm) $w(t)$;

A tandem queueing system.

Using this notation, the continuous-time dynamics of the two-queue system can be written in a compact form as

\begin{align}\label{eq:continousSystem_delta_w}
\begin{bmatrix} \dot{\delta}(t) \\ \dot{w}(t) \end{bmatrix} = \begin{bmatrix}
1 & -1 & 0 \\ 0 & 1 & -1
\end{bmatrix} \begin{bmatrix}
\lambda(t) \\ u(t) \\ \gamma(t)
\end{bmatrix}.
\end{align}

Before proceeding with the discretization of the model, we define a triggering condition that enables the generation of an event indicating the commencement of a new cycle. Let $u(t)$ be an admission control policy such that

\begin{equation}\label{eq:condition_delta}
\delta(t_{k}) = 0,
\end{equation}

i.e., all the requests that have been arrived at queue $Q_{1}$ by time $t_{k}$ have been admitted to queue $Q_{2}$. Hence, in this regard, $Q_{1}$ instantaneously becomes empty at $t_{k}$. To enforce that condition (<ref>) can always be satisfied at a finite time for a Lipschitz function $\lambda(t)$ however $\lambda$ is constant in ou case, no?, we design $u(t)$ as an AIMD controller as follows. Let

\begin{align}
u(t_{k}^{-}) = \lim_{\substack{t\to t_{k} \\ t< t_{k}}} u(t), \;\;
u(t_{k}^{+}) = \lim_{\substack{t\to t_{k} \\ t> t_{k}}} u(t),
\end{align}

where $t_{k}^{-}$ is the ending time of the $(k-1)$th cycle, and $t_{k}^{+}$ the starting time of the $k$th cycle. Since $\delta(t_{k}^{+}) = 0$, we let

\begin{equation}\label{eq:backoffing}
u(t_{k}^{+}) = \beta u(t_{k}^{-}),
\end{equation}

where $0 < \beta < 1$ is called the backoff parameter. While queue $Q_{1}$ remains empty, admission control $u(t^{+})$ shrinks to a fraction of $u(t^{-})$ according to (<ref>). This is called the Multiplicative Decrease (MD) phase of the cycle. By the time queue $Q_{1}$ starts growing, admission rate $u(t)$ increases in a ramp fashion as

\begin{equation}\label{eq:continuous_u(t)}
u(t) = \beta u(t_{k}^{-}) + \alpha (t-t_{k}), \; t\geq t_{k},
\end{equation}

where the slope of the ramp $\alpha >0$ is called the growth rate. Let now $t_{k+1}^{-}$ be the ending time of the $k$th cycle, i.e., $\delta(t_{k+1}) = 0$. Then, the duration of the $k$th cycle is called cycle period and is denoted by $T(k) = t_{k+1} - t_{k}$. Similarly, the interval $(t_{k}^{+},\;t_{k+1}^{-})$ is called the Additive Increase phase. Denoting is it not enough to write 'denoting time instants' $k=t_k$ $u(k) = u(t_{k})$, $w(k) = w(t_{k})$, and $\gamma(k) = \gamma(t_{k})$, $k\geq 0$, an event-driven discrete model is derived as

\begin{equation}
\begin{bmatrix}
w(k+1) \\ u(k+1) \\ \delta(k+1)
\end{bmatrix} =
\begin{bmatrix}
w(k) + (\beta u(k) + \frac{\alpha}{2}T(k) - \gamma(k))T(k) \\
\beta u(k) + \alpha T(k) \\ \delta(k)
\end{bmatrix},
\end{equation}

where $u(k)$ is an AIMD controller with triggering condition

\begin{equation}
\delta (k) = 0.
\end{equation}

Next, we generalize the AIMD admission control approach to a system with multiple queues, and examine the properties of the AIMD algorithm and its effect to the entire system dynamics.

§ MULTI-QUEUE SYSTEM

We consider a cluster of $n$ servers or should we say computing nodes... servers can have many queues.... represented by a multi-queue system, where each server is modelled by a queue combined with a (physical or virtual) computing environment. We assume that a constant workload $\lambda$ enters the system via a batch queue, which is independent of the servers. The workload is manifested as a flow of requests that are dispatched to $n$ nodes according to an admission control policy $u_{i}(t)$, $i=1,\;\ldots,\;n$, with each node representing a server. We denote the number of queued requests that have not yet been admitted at time $t$ by $\delta(t)$, and the number of admitted requests waiting to be selected for service by the $i$th node at time $t$ by $w_{i}(t)$. Service rate of the $i$th node is denoted by $\gamma_{i}$, $i=1,\;\ldots,\;n$. The entire system is depicted in Fig. <ref>. Next, we examine the aggregate dynamics of a large-scale AIMD admission controller.I would put until here in the section above, and use section IV as AIMD admission control

(0,0) – ++(2cm,0) – ++(0,-.75cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-.75cm);

(2.55,-0.375cm) circle [radius=0.55cm] node[] $\sum u_{i}(t)$;

[-] (3.1, -.375cm) – (3.37, -.375cm) – (3.37, -.375cm +1.5cm);
[dashed]  (3.37, -.375cm) – (3.37, -.375cm -2cm);
[very thick, dotted]  (4.75, -1.25cm) – (4.75, -1.75cm);

[<-] (0,-0.375) – +(-20pt,0) node[left] $\lambda$;

at (1cm,-1.05cm) $\delta(t)$;
[xshift = 4.4cm, yshift = 1.5cm]

(0,0) – ++(2cm,0) – ++(0,-.75cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-.75cm);

(2.375,-0.375cm) circle [radius=0.375cm] node[] $\gamma_{1}$;

[<-] (0.,-0.375) – +(-30pt,0) node[anchor = south west] $u_{1}(t)$;

at (1cm,-1.05cm) $w_{1}(t)$;

[xshift = 4.4cm, yshift = 0cm]

(0,0) – ++(2cm,0) – ++(0,-.75cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-.75cm);

(2.375,-0.375cm) circle [radius=0.375cm] node[] $\gamma_{2}$;

[<-] (0.,-0.375) – +(-30pt,0) node[anchor = south west] $u_{2}(t)$;

at (1cm,-1.05cm) $w_{2}(t)$;

[xshift = 4.4cm, yshift = -2.cm]

(0,0) – ++(2cm,0) – ++(0,-.75cm) – ++(-2cm,0);
ıin 1,...,4
(2cm-ı*10pt,0) – +(0,-.75cm);

(2.375,-0.375cm) circle [radius=0.375cm] node[] $\gamma_{n}$;

[<-] (0.,-0.375) – +(-30pt,0) node[anchor = south west] $u_{n}(t)$;

at (1cm,-1.05cm) $w_{n}(t)$;

A multi-queue system with AIMD admission control policy.

§.§ AIMD admission control

The number of queued (unadmitted) requests at the beginning of the $(k+1)$th event is given by

\begin{equation}\label{eq:deltak+1}
\delta(k+1) = \delta(k) + \lambda T(k) - \int_{t_{k}}^{t_{k+1}} \sum u_{i}(t) \mathbf{d}t.
\end{equation}

We recall that at each event $k, \; k+1,\;\ldots$, we have

\begin{equation}\label{eq:triggeringcondition}
\delta(k) = \delta(k+1) = \cdots = 0.
\end{equation}

The AIMD formulation of the admission controller  yields an exact formula of the cycle period $T(k)$ permitting a closed form of the aggregate admission control system. To this purpose, during the AI phase, the $i$th admission rate ramps up as follows,

\begin{equation}\label{eq:u_i(t)}
u_{i}(t) = \beta_{i}u_{i}(t_{k}) + \alpha_{i}(t-t_{k}), \; i = 1,\ldots,n,
\end{equation}

which is a continuous-time controller for $t \in [t_{k},\;t_{k+1})$. Based on condition (<ref>), the event-based dynamics of the $i$th admission controller is written as:

\begin{equation}\label{eq:u_ik+1}
u_{i}(k+1) = \beta_{i}u_{i}(k) + \alpha_{i}T(k), \; i = 1,\ldots,n.
\end{equation}

In view of the triggering condition (<ref>) and using (<ref>) in (<ref>), we get

\begin{equation}
\lambda T(k) = \sum_{i=1}^{n} (2\beta_{i}u_{i}(k) + \alpha_{i}T(k)) \frac{T(k)}{2}\footnote{the integral on the right side of \eqref{eq:deltak+1} is the sum of areas of $n$ trapezoids due to the AIMD dynamics of $u_{i}$, i = 1,\ldots, n.},
\end{equation}

\begin{equation}\label{eq:lambda}
\lambda = \sum_{i=1}^{n} (\beta_{i}u_{i}(k) + \frac{\alpha_{i}}{2}T(k)),
\end{equation}

from which, the cycle period is defined as

\begin{equation}\label{eq:eventPeriod}
T(k) = \frac{\lambda - \sum_{i=1}^{n}\beta_{i} u_{i}(k) }{\sum_{i=1}^{n}\frac{\alpha_{i}}{2}}.
\end{equation}

From (<ref>), we may write that

\begin{equation}
u_{i}(k+1) = \beta_{i}u_{i}(k) +\alpha_{i} \frac{\lambda - \sum_{i=1}^{n}\beta_{i} u_{i}(k) }{\sum_{i=1}^{n}\frac{\alpha_{i}}{2}}.
\end{equation}

Letting now

\begin{align}
U(k) &= \mathrm{Col}(u_{1}(k),\ldots,u_{n}(k)),\\
\bar{\alpha} &= \frac{1}{\sum_{j=1}^{n}\alpha_{j}}\mathrm{Col}(\alpha_{1},\ldots,\alpha_{n}),\\
B &= \diag(\beta_{1},\ldots,\beta_{n}),\\
\beta & = (\beta_{1},\ldots,\beta_{n}),
\end{align}

the aggregate admission control system is written as

\begin{equation}\label{eq:U(k+1)}
U(k+1) = \Phi U(k) + 2\bar{\alpha}\lambda,
\end{equation}

where $\Phi = B - 2\bar{\alpha} \beta'$, with $\bar{\alpha}'\mathbf{1}=1$. Next, we show that system (<ref>) is stable, thus, the $i$th AIMD admission controller $u_{i}(k)$ converges to a unique equilibrium point $u_{i}^{\ast}$. We first present the following result, which appears in several works in the context of Linear Algebra, see, e.g., <cit.>, <cit.>.

Let $C = D + \rho zz'$, where $D\in\mathbb{R}^{n\times n}$ is diagonal, $\rho\in\mathbb{R}$, and $z\in\mathbb{R}^{n}$. Let $d_{1}\leq d_{2}\leq \ldots \leq d_{n}$ be the eigenvalues of $D$, and $c_{1}\leq c_{2}\leq \ldots \leq c_{n}$ be the eigenvalues of $C$. Then,

i) $d_{1}\leq c_{1} \leq d_{2}\leq c_{2} \leq \ldots \leq d_{n} \leq c_{n}$ if $\rho>0$,

ii) $c_{1}\leq d_{1} \leq c_{2}\leq d_{2} \leq \ldots \leq c_{n} \leq d_{n}$ if $\rho < 0$.

If $d_{1},\ldots,d_{n}$ are distinct and all the elements of $z$ are nonzero, then $c_{1},\ldots,c_{n}$, namely the eigenvalues of $C$, strictly separate the eigenvalues of $D$.

We are in a position to state the first main result, namely, the stability of the AIMD scheduling policy

Let vectors $\alpha = (\alpha_{1},\;\ldots,\;\alpha_{n})$, $\beta = (\beta_{1},\;\ldots,\;\beta_{n})$, where $0\leq \alpha_{i}\leq 1$, $0 < \beta_{i} < 1$, $\forall i = 1,\;\ldots,\;n$, and $\mathbf{1}'\alpha = 1$, with $\mathbf{1}= (1,\;\ldots,\;1)$. Let also $B = \diag(b_{1},\ldots,b_{n})$. Then,

\begin{equation}
\Phi = B - 2\alpha \beta',
\end{equation}

is a Schur matrix.

Matrix $\Phi$ can also be written as

\begin{equation}
\Phi = (I-2A)B,
\end{equation}

where $A = \alpha \mathbf{1}'$ is a rank-one matrix with $\sigma(A) = \{\mathbf{1}'\alpha, 0 ,\ldots, 0\}$, and $\mathbf{1}'\alpha = 1$ by definition. In the sequel, we denote by $\sigma(\Phi) = \{\phi_{1},\ldots,\phi_{n}\}$ the spectrum of $\Phi$. Clearly, $\sigma(B) = \{\beta_{1},\ldots,\beta_{n}\}$. Also, it is easy to show that $\sigma(I-2A) =\{-1,\;1,\ldots,1\}$. We can also write that $\det(\Phi) = \phi_{1}\phi_{2}\ldots\phi_{n}$, and $\det(\Phi) = \det(B)\det(I-2A)$. Thus,

\begin{equation}\label{eq:phi12nbeta12n}
\phi_{1}\phi_{2}\cdots\phi_{n} = -\beta_{1}\beta_{2}\cdots\beta_{n}.
\end{equation}

Let now $\hat{A} = \diag(\alpha_{1},\ldots, \alpha_{n})$, and

\begin{equation}
\hat{\Phi} = B^{\frac{1}{2}}\hat{A}^{-\frac{1}{2}}\Phi\hat{A}^{\frac{1}{2}}B^{-\frac{1}{2}}.
\end{equation}

Clearly, matrices $\Phi$, $\hat{\Phi}$ are similar, thus, having identical eigenvalues. Note also that $\hat{\Phi}$ can be written as

\begin{equation}
\hat{\Phi} = B - 2 zz',
\end{equation}

which is clearly a symmetric matrix, where

\begin{equation}
z = \begin{bmatrix}
\sqrt{\alpha_{1}\beta_{1}} & \sqrt{\alpha_{2}\beta_{2}} & \cdots & \sqrt{\alpha_{n}\beta_{n}}
\end{bmatrix}.
\end{equation}

Without loss of generality, let $b_{1}\leq \ldots \leq b_{n}$, and $\phi_{1}\leq \ldots \leq \phi_{n}$. Then,  from Theorem <ref>, and since all elements of $z$ are nonzero, we may write that

\begin{equation}\label{eq:phileqbeta}
\phi_{1} \leq \beta_{1} \leq \phi_{2} \leq \beta_{2} \leq \ldots \leq \phi_{n} \leq \beta_{n}.
\end{equation}

From (<ref>) and (<ref>), we can conclude that $0<\phi_{2},\;\phi_{3},\;\dots,\;\phi_{n}<1$, and $\phi_{1}$ is a negative real number. From (<ref>), we have that

\begin{equation}\label{eq:phi2phin}
\phi_{2}\phi_{3}\cdots\phi_{n} \geq \beta_{1}\beta_{2}\cdots\beta_{n-1}.
\end{equation}

However, due to (<ref>), (<ref>) implies that

\begin{equation}
|\phi_{1}| \leq \beta_{n},
\end{equation}

i.e., $-\beta_{n}\leq \phi_{n}<0$. Thus, all the eigenvalues of $\hat{\Phi}$ (hence $\Phi$), strictly lie inside the unit circle (specifically on the real axis between $-1$ and $1$). This proves the theorem.

The main consequence of this section are summarized next.

1) AIMD parameters $\alpha_{i}$, $\beta_{i}$, $i=1,\ldots,n$, can locally be selected at each individual node. Thus, system (<ref>) represents a decentralized admission control policy.

2) In view of Theorem <ref>, the aggregate system (<ref>) is stable.

3) Since $\Phi$ in (<ref>) is a Schur matrix, the $i$th AIMD admission rate converges to

\begin{equation}
u_{i}^{\ast} = \frac{\alpha_{i}}{1-\beta_{i}}T^{\ast},
\end{equation}

where $T^{\ast} = \lambda(\sum_{j=1}^{n}(\frac{\alpha_{j}\beta_{j}}{1-\beta_{j}}+\frac{\alpha_{j}}{2}))^{-1}$.

§.§ Resource allocation control design

I would put this as a separate section “Resource allocation controller design”
Resource allocation in a queueing system pertains to a strategy ensuring that system servers provide incoming requests with adequate computing resources so that the number of queued requests is not increasing indefinitely as more requests are added to the system. Stabilizing the overall system, minimizing queueing and idle times, providing a tradeoff between server utilization and application performance, and maximizing system throughput and output are essential objectives of resource allocation strategies in queueing systems. Here, we focus on stability as a fundamental qualitative property, which if not present, then it may be impossible for a queueing scheme to achieve any other desirable objective. we should note if you haven't done below that the resource allocation policy never overprovisions resources, i.e., the queue never stays at zero

We follow a bottom-up approach for designing a decentralized resource allocation control strategy as follows. Let $(\alpha_{i},\;\beta_{i})$, $\gamma_{i}$ denote the AIMD parameters, and the service rate, respectively, associated with the $i$th node. Recall that, for $\tau\in[0,\;T(k)]$,

\begin{equation}
u_{i}(\tau) = \beta_{i}u_{i}(k) + \alpha_{i}\tau,
\end{equation}

is the rate at which requests are admitted to the $i$th node, while

\begin{equation}
w_{i}(\tau) = w_{i}(k) + \beta_{i}u_{i}(k)\tau + \frac{\alpha_{i}}{2}\tau^{2} - \gamma_{i}(k) \tau,
\end{equation}

is the number of queued requests waiting in the $i$th node, during the $k$th cycle, respectively. We define by

\begin{equation}
y_{i}^{k}(\tau) = w_{i}(\tau) + \hat{\gamma}_{i}(k)\tau,\;\;  z_{i}^{k}(\tau) = \hat{\gamma}_{i}(k)\tau,
\end{equation}

with $\hat{\gamma}_{i}(k)\geq 0$, the we can afford (36) in two lines total number of requests that have been admitted by time $\tau$, and the number of requests that can be served at most by time $\tau$, respectively. By letting $\gamma_{i}(k) = \hat{\gamma}_{i}(k)$, I don't get the hat in gamma,  and selecting $z_{i}^{k}$ to be the line tangent to $y_{i}^{k}(\tau)$ at point $t_{z}^{k}\in[0,\;T(k)]$, as shown in Fig. <ref>, we effectively guarantee that the maximum number of requests that can be served, during the $k$th cycle, never exceeds the actual number of admitted requests, avoiding, thus, server under-utilization. Next, we propose a resource allocation design leading to a feedback controller $\hat{\gamma}_{i}(k)$ with the following properties:i am wondering if you can have two more figures; one where gamma is bigger but line intersects two points (overprovisiioning- wnew is smaller, and one where gamma is smaller and gamma does not intersect- wnew bigger than w current. Then one can really see why what you choose this gamma) but lets leave this last if it is too much trouble.

1) $\hat{\gamma}_{i}(k)$ is globally stabilizing,

2) $\hat{\gamma}_{i}(k)$ can be constructed by means of local information only.

[->] (0, 0) – (4, 0) node[right] time;
[->] (0, 0) – (0, 4) node[above] $y_{i}^{k}(\tau),\;
(0, 0) node[below] $O$;
(0, .9) node[left] $w_{i}(k)$;

(2.7, 0) node[below] $T(k)$;
[thick, dotted] (1.35, 1.8) – (1.35, 0);
(1.35, 0) node[below] $t_{z}^{k}$;

[very thick, scale=1, domain=0:1.8, smooth, variable=, black, name path = A] plot (1.5*, .9+ .2*(5.5556**));
[very thick, scale=1, domain=0:1.8, smooth, variable=, black, name path = B]  plot (1.5*, .2*(10*));
[thick, dotted] (2.7,0) – (2.7,.9+ 3.6);

[of=A and B]black!30!white;

[fill] (0, .9) circle [radius=0.05cm];
[fill] (1.35, 1.8) circle [radius=0.05cm] node[right, yshift = .cm] $B$;
[fill] (2.7,.9+ 3.6) circle [radius=0.05cm] node[right] $\Gamma$;
[fill] (2.7,.0+ 3.6) circle [radius=0.05cm] node[right] $\Delta$;
(3.1, .9+3.6) – (3.3, .9+3.6);
(3.1, .+3.6) – (3.3, .+3.6);
[->] (3.2, .9+3.6) – (3.2, .+3.6);
[<-] (3.2, .9+3.6) – (3.2, .9+3.6);
(3.2, .45+3.6) node[right] $w_{i}(k+1)$;
(1.25, 3.25) node[above] $y_{i}^{k}(\tau)$;
[->] (2.05, 3) – (1.45, 3.35);
(2.35, 2.3) node[above] $z_{i}^{k}(\tau)$;
[dashed, name path = C] (0, .9) – (2.7,.9+ 3.6);
(-.08, 1.) node[anchor = north west] $A$;

Arrivals and departures in the $i$th node during the $k$th cycle.

We first find the intersection point $B$, as shown in Fig. <ref>, where

\begin{align}
y_{i}^{k}(t_{z}^{k}) & = z_{i}^{k}(t_{z}^{k}), \label{eq:functions_eq} \\
\diff{y_{i}^{k}}{t_{z}^{k}} & = \diff{z_{i}^{k}}{t_{z}^{k}}. \label{eq:deriv_eq}
\end{align}

From (<ref>), we get

\begin{equation}\label{eq:tzk1}
t_{z}^{k} = \frac{\hat{\gamma}_{i}(k) - \beta_{i}u_{i}(k)}{\alpha_{i}},
\end{equation}

while, after a few calculations, using (<ref>) in (<ref>), we have

\begin{equation}\label{eq:hatgammaik}
\hat{\gamma}_{i}(k) = \beta_{i}u_{i}(k) + \sqrt{2\alpha_{i}w_{i}(k)},
\end{equation}

which is a nonlinear, discrete-time state-feedback controller. Finally, using (<ref>), (<ref>) becomes

\begin{equation}
t_{z}^{k} = \sqrt{\frac{2w_{i}(k)}{\alpha_{i}}}.
\end{equation}

we are now i position to state the second main result of our work, namely, ....

\begin{equation}\label{eq:wi(k+1)theorem}
w_{i}(k+1) = w_{i}(k) +(\beta_{i}u_{i}(k) + \frac{\alpha_{i}}{2}T(k) - \gamma_{i}(k))T(k),
\end{equation}

with $ w_{i}(0) = w_{i,0}$, why this notation here?  be the queue dynamics of the $i$th node, where $\alpha_{i}$, $\beta_{i}$ are the AIMD parameters, $T(k)$ is the cycle period, and

\begin{equation}\label{eq:feedback_gamma_i}
\gamma_{i}(k) = \beta_{i}u_{i}(k) + \sqrt{2\alpha_{i}w_{i}(k)},
\end{equation}

is a feedback resource allocation policy. Then, the following are true.

i.) System in Theorem 1 you do not have dots in i.) (<ref>)-(<ref>) is nonnegative for all $w_{i}(k)\geq 0$.

ii.) The set $\mathcal{W}_{i}(k) = \{w_{i}(k)\in[0,\;\frac{\alpha_{i}}{2}T(k)^{2}],\; \forall k\geq 0\}$ why not write $\mathcal{W}_i(k)=[0, \ \ \frac{a_i}{2}T(k)^2]$ is invariant with respect to system (<ref>)-(<ref>).

iii.) For $w_{i,0}\notin\mathcal{W}_{i}(k)$, there is an integer $k^\star>0$ such that $w_{i}(k^\star) \in \mathcal{W}_{i}(k)$.we need another line in the proof because $k^\star$ is for all i's. We just say $k^\star=max_i\{ k_i^{\star}\}$

i.) Substituting (<ref>) in (<ref>), we write

\begin{equation}
w_{i}(k+1) = w_{i}(k) +\frac{\alpha_{i}}{2}T(k)^{2} - \sqrt{2\alpha_{i}w_{i}(k)}T(k),
\end{equation}

and we show that $f(w_{i}) = w_{i}(k+1)$ is convex. that is tricky because T(k) is a function of w?, or should we say convex wrt $w_i$

The dynamics $f(w_{i}) = w_{i}(k+1)$ is convex with respect to $w_i$ since it is a sum of the affine function $w_{i}(k) + \frac{\alpha_{i}}{2}T(k)^{2}$ and the convex function  $- \sqrt{2\alpha_{i}w_{i}(k)}T(k)$. Since, $f(w_{i})$ is continuously differentiable and convex for $w_{i}\geq 0$, the unique minimizer is attained setting $f'(w_{i}) = 0$, resulting to $1-\frac{\sqrt{2\alpha_{i}}T(k)}{2\sqrt{w_{i}}} = 0$, or

\begin{equation*}
w_{i}^{*} = \frac{\alpha_{i}T(k)^{2}}{2}
\end{equation*}

Taking into account that $f(w_{i}^{*}) = 0$, it holds that $f(w_{i}(k))\geq 0$ $\forall\; w_{i}(k)\geq 0$. and again, we should probably say for any $T(k)$

ii.) The condition $w_{i}(k+1)\leq w_{i}(k)$ holds when $ w_{i} + \frac{\alpha_{i}}{2}T(k)^{2} - \sqrt{2\alpha_{i}w_{i}}T(k) \leq w_{i}$, or when

\begin{equation*}
w_{i} \geq \frac{\alpha_{i}}{8}T(k)^{2}.
\end{equation*}

Let $\hat{\mathcal{W}}_{i}(k) =\left\{w\in\R: w\geq \frac{\alpha_{i}}{8}T(k)^{2}\right\}$. Since $\hat{\mathcal{W}}_{i}(k)\cap \mathcal{W}_{i}(k) =  [\frac{\alpha_{i}}{8}T(k)^{2},\;\frac{\alpha_{i}}{2}T(k)^{2}]$, we need only to verify $w_{i}(k+1) \leq w_{i}(k)$ $\forall w_{i}(k)\in [0,\; \frac{\alpha_{i}}{8}T(k)^{2})$. Since  $f(w_{i}(k))$ is convex with minimum at $\frac{\alpha_{i}}{2}T(k)^{2}$ it follows that $f(0)\geq f(w_{i}(k))$ for any $ w_{i}(k)\in [0,\;\frac{\alpha_{i}}{2}T(k)^{2}]$. Since $f(0) = \frac{\alpha_{i}}{2}T(k)^{2}$, it holds that $0\leq f(w_{i}(k))\leq \frac{\alpha_{i}}{2}T(k)^{2}$ for all $ w_{i}(k)\in \mathcal{W}_{i}(k)$.  one more sentence here to finalise the proof

iii.) Since $f(w_{i}(k))$ is a nonnegative function of $w_{i}(k)$, $\forall\;w_{i}(k)\geq 0$, we only consider $w_{i}(k)\geq \frac{\alpha_{i}}{2}T(k)^{2}$. Note that $f'(w_{i}) > 0$ $w_{i}> \frac{\alpha_{i}}{2}T(k)^{2}$, for all $k>0$. Moreove, $w_{i}(k+1) = \frac{\alpha_{i}}{2}T(k)^{2}$ if $w_{i}(k) = 2\alpha_{i}T(K)^{2}$, and $w_{i}(k+1) < \frac{\alpha_{i}}{2}T(k)^{2}$ if $w_{i}(k)\in (\frac{\alpha_{i}}{2}T(k)^{2},\; 2\alpha_{i}T(K)^{2})$. something is not clear here, what about $w_i>2a_iT(k)^2$Thus, we may conclude that there is a finite how do we conclude that? $\rho$ such that $w_{i}(\rho)\leq \frac{\alpha_{i}}{2}T(k)^{2}$, $w_{i}(\rho-1)> \frac{\alpha_{i}}{2}T(k)^{2}$ and $f'(w_{i}(\rho-1))>0$.  the last sentence is not clear

It is worth highlighting some appealing characteristics of the proposed resource allocation scheme:

1) The closed-loop system refer to the equation under the resource allocation policy $\hat{\gamma}_{i}(k)$ is globally attracted to the sets sets here from Theorem 3 in finite time.

2) Implementation of $\hat{\gamma}_{i}(k)$ is decentralised for any $i=1,..,n$ as it required only local information.

3) The stability properties of $\hat{\gamma}_{i}(k)$ are independent of the particular tuning of the AIMD parameters $\alpha_{i}$, $\beta_{i}$, $i=1,\ldots,n$.

4) The proposed resource allocation strategy $\hat{\gamma}_{i}(k)$ is scalable as its implementation is irrespective of the total number of individual nodes.

heavily changed the above, have a look

§.§ Queuing time calculation

I would put this another section
We define the total queueing time associated with requests dispatched to the $i$th node as

\begin{equation}
T_{i}(k) = T_{\delta_{i}}(k) + T_{w_{i}}(k),
\end{equation}

where $T_{\delta_{i}}(k)$ corresponds to queueing time in the batch queue, while $T_{w_{i}}(k)$ corresponds to queueing time in the $i$th node. We also define the following. We define the average admission rate associated with the $i$th node

\begin{equation}
u_{i}^{\mathbf{av}}(k) = \frac{1}{T(k)}\int_{t_{k}}^{t_{k+1}} u_{i}(t)  \mathbf{d}t,
\end{equation}

where $T(k) = t_{k+1} - t_{k}$, and $u_{i}(t)$ is given by (<ref>). Solving the integral above yields

\begin{equation}\label{eq:uiav(k)}
u_{i}^{\mathbf{av}}(k) = \beta_{i}u_{i}(k) + \frac{\alpha_{i}}{2} T(k).
\end{equation}

In view of (<ref>) and (<ref>), we may write that

\begin{equation}\label{eq:AIMDcondition}
\sum_{i=1}^{n} u_{i}^{\mathbf{av}}(k) = \lambda, \; \forall \; k\geq 0.
\end{equation}

In view of (<ref>), we can write that $u_{i}^{\mathbf{av}}(k)T(k)$ corresponds to the fraction of the total arrivals at the batch queue (namely, $\sum_{i=1}^{n}u_{i}^{\mathbf{av}}(k)T(k) = \lambda T(k)$) associated with the $i$th node. Using definition (<ref>), and letting $\delta_{i}(\tau) = u_{i}^{\mathbf{av}}(k)\tau - \beta_{i}u_{i}(k)\tau - \frac{\alpha_{i}}{2}\tau^{2}$, with $0 \leq \tau \leq T(k)$, be the number of queued requests waiting in the batch queue before being dispatched to the $i$th node, we may write that $T_{\delta_{i}}(k) = \frac{\int_{0}^{T(k)}\delta_{i}(\tau)\mathbf{d}\tau}{u_{i}^{\mathbf{av}}(k)T(k)}$, where, interestingly enough, integral $\int_{0}^{T(k)}\delta_{i}(\tau)\mathbf{d}\tau$ is identically equal to the unshaded area $AB\Gamma A$, in Fig. <ref>. Similarly, using definition ? I missed this one <ref>, we may write that $T_{w_{i}}(k) = \frac{\int_{0}^{T(k)}w_{i}(\tau)\mathbf{d}\tau}{\beta_{i}u_{i}(k)T(k) + \frac{1}{2}\alpha_{i}T(k)^{2}}$. It is worth noting the integral $\int_{0}^{T(k)}w_{i}(\tau)\mathbf{d}\tau$ is identically equal to the shaded area in Fig. <ref>, and $\beta_{i}u_{i}(k)T(k) + \frac{1}{2}\alpha_{i}T(k)^{2} = u_{i}^{\mathbf{av}}(k)T(k)$ due to (<ref>). Clearly, $T_{i}(k)$ is equal to the area of the trapezium $A\Gamma\Delta O$ divided by the exposition is not very clear, reformulate $u_{i}^{\mathbf{av}}(k)T(k)$, i.e., $ T_{i}^{\mathbf{tot}}(k) = \frac{(w_{i}(k)+w_{i}(k+1))\frac{T(k)}{2}}{u_{i}^{\mathbf{av}}(k)T(k)}$

\begin{equation}\label{eq:T_i(k)}
T_{i}(k) = \frac{w_{i}(k)+w_{i}(k+1)}{2u_{i}^{\mathbf{av}}(k)}.
\end{equation}

The total queueing time of node $i$ can be defined by means of local information without any information pertinent to the batch queue. Also, by defining $w_{i}^{\mathbf{av}}(k) = (w_{i}(k)+w_{i}(k+1))/2$ as the average number of queued requests over the $k$th cycle, (<ref>) becomes

\begin{equation}
T_{i}(k) = \frac{w_{i}^{\mathbf{av}}(k)}{u_{i}^{\mathbf{av}}(k)},
\end{equation}

which is clearly consistent with Little's Law.

§.§ Numerical example

We consider a flow of requests with constant flow rate, $\lambda$ [req/sec], entering a system of four servers. The $i$th server is associated with a FCFS queue the length of which is denoted by $w_{i}$, $i=1,\ldots,4$. By tuning parameters $\alpha_{i}$, $\beta_{i}$ independently, the $i$th server admits requests according to AIMD control policy $u_{i}$ given in (<ref>), and alters its service rate via discrete nonlinear feedback controller $\gamma_{i}$ defined in (<ref>). Simulation results are presented in Fig. <ref>-<ref>, the selected setup of which is shown in Table <ref>.

Simulation parameters

$\lambda$     $\alpha_{i}$     $\beta_{i}$     $u_{i}(0)$     $w_{i}(0)$     $i$

100     $i\cdot 5$ what is meant here?     $0.5$      $(i-1)5$     $(2i-1) 7.5$     $\{1,2,3,4\} \nikos{why not write $n=4$}$

Cycle Period

Maximum admission rates before each clearance event.

AIMD admission control.

Resource allocation and average admission control. Solid lines: $\gamma_{i}(k)$, dashed lines: $u_{i}^{\mathbf{av}}(k)$.

Queued requests.

Queueing time.

perhaps it is nice to add the intervals here from Theorem 3(ii)

As indicated in the figures, under the proposed admission and resource allocation control strategy, stable operation is guaranteed for all servers regardless of each individual tuning of the AIMD parameters. Also, queued requests are bounded, highlighting the stability properties of Theorem <ref>, with queueing time following a pattern consistent with the queueing profile of each individual node. We refer interested readers to <cit.> you can also put the link in the text, I think that is more appropriate. Is it not online yet? I checked and it is a dead link for further simulation scenarios.comma, where the case for ....  is also tackled, however not dicussed here (or is that too confusin for t) a script for a random arrival process with exponentially distributed inter-arrival times is also available. I think you need to comment on any figure you are putting. Is there time for more nodes, e.g., 10-15? also, can you have interesting initial conditions where we do not have so fast convergence or are we too good :)

§ CONCLUSION

We studied the problem of simultaneous scheduling and resource allocation of a deterministic flow of requests entering a system of computing nodes which is represented as a multi-queue scheme. Inspired by the well-established AIMD algorithm, we presented a new admission control policy for general scheduling problems. Using an interesting property of rank-one perturbations of symmetric matrices, we provided stability guarantees,independent of the overall system dimension and the AIMD tuning. Following a bottom-up approach, we next proposed a resource allocation strategy defined as a decentralized nonlinear feedback controller which is globally stabilizing. This effectively guarantees that individual queues are bounded converging in finite time to a well-defined interval. Finally, we associated these properties with Quality of Service specifications, by calculating the local queueing time via a simple formula consistent with Little's Law. Our method is simple, scalable, and locally configurable. It is worth noting however that further effort is required to formally address two additional challenges, namely, non deterministic workload and the presence of resource constraints. This is the object of our immediate future research efforts.