System Stability Under Adversarial Injection of Dependent Tasks

In this work, we consider a computational model of a distributed system formed by a set of servers in which jobs, that are continuously arriving, have to be executed. Every job is formed by a set of dependent tasks (i.~e., each task may have to wait for others to be completed before it can be started), each of which has to be executed in one of the servers. The arrival of jobs and their properties is assumed to be controlled by a bounded adversary, whose only restriction is that it cannot overload any server. This model is a non-trivial generalization of the Adversarial Queuing Theory model of Borodin et al., and, like that model, focuses on the stability of the system: whether the number of jobs pending to be completed is bounded at all times. We show multiple results of stability and instability for this adversarial model under different combinations of the scheduling policy used at the servers, the arrival rate, and the dependence between tasks in the jobs.


Introduction
In this work, we consider a model of jobs formed by dependent tasks that have to be executed in a set of servers. The dependencies among the tasks of a job restrict the order and time of their execution. For instance, a task q may need some information from another task p, so that the latter must complete before q can be executed. This model embodies, for instance, the dynamics of Network Function Virtualization (NFV) systems [13,23] or Osmotic Computing (OC) [22]. In a NFV system, network services (which are job types) are specified as service chains, obtained by the concatenation of network functions. These network functions are dependent computational tasks to be executed in the NFV Infrastructure (e.g., servers distributed over the network). In an OC system, an application is divided into microservices that are distributed and deployed on an edge/cloud server infrastructure. The user requests (jobs) involve processing (tasks) in several of these microservices, as defined by an orchestrator that takes into account the dependencies between the microservices. In that line, it also encompasses a number of features of Orchestration Languages (see, for instance, [16]), which propose a way to relate concurrent tasks to each other in a controlled fashion: the invocation of tasks to achieve a goal, the synchronization between tasks, managing priorities, etc.
In our model, we consider a dynamic system in which job requests (or jobs for short) are continuously arriving. Each job contains the whole specification of its dependent tasks: the collection of tasks to be executed, the server that must execute each task, the time the execution incurs, the dependencies among tasks, etc. Instead of assuming stochastic job arrivals into the system, in our model we assume the existence of an adversary that has full control of the job requests arXiv:1910.01869v1 [cs.NI] 4 Oct 2019 arrivals, and the specification of their tasks. The only restriction on the adversary is that no server can be overloaded in the long run (some burstiness in the load is allowed).
In this adversarial framework, the objective is to achieve stability in the system. This means that the system is able to cope with the adversarial arrivals, maintaining the number of pending job requests in the system bounded at all times. (This usually also implies that all the job requests are eventually completed.) Observe that the framework assumes that the resource allocation is done by the adversary (since it chooses where tasks have to be executed and in which order). Hence, the only tool we have to achieve stability is the scheduling of tasks in the different servers.
The study of the quality of service that can be provided under worst-case assumptions in a given system (NFV or OC, for instance) is important in order to be able to honor Service Level Agreements (SLA). The positive results we obtain in this paper show that it is possible to guarantee a certain level of service even under pessimistic assumptions. These results can also be used to separate resource allocation and scheduling as long as the resource allocation guarantees that servers are not overloaded, since we prove that it is possible to guarantee stability in this case.

Related Work
For many years, the common belief was that only overloaded queues 1 could generate instability, while underloaded ones could only induce delays that are longer than desired, but always remain stable. This general wisdom goes back to the models of networks originally developed by Kleinrock [17], and based on Jackson queuing networks [14]. Stability results for more general classes of queuing networks [2,15] also confirmed that only overload generates instability. This belief was shown to be wrong when it was observed that, in some networks, the backlogs in specific queues could grow indefinitely even when such queues were not overloaded [18,19].
Motivated by this fact, there has been an effort to understand the factors that can affect the stability of a queueing network. In [8], the authors provide some results regarding some conditions that render bounded queue lengths both for a single queue and for feedforward networks. In [7], it is shown a class of networks which, although queues are served substantially more quickly that the rate at which tasks are injected, their mean service times are as small as desired. By using a simple queueing network, in [10] it was shown that conditions on the mean interarrival and service times are not enough to determine its stability under a particular policy.
It was later shown that instability could also arise in some types of Kelly networks [1,6] (a network is said to be of the Kelly type [15] when servers have the same service rates). These results in the Adversarial Queuing Theory (AQT) model aroused an interest in understanding the stability properties of packet-switched networks. This has attracted the attention of many researchers in recent years (see, for instance, the results in [4,9,20,21]).

Our Work
In this paper, we introduce a model to analyze queuing systems of computational jobs formed by dependent tasks. We call this model Adversarial Job Queueing (AJQ). The main contribution of the AJQ model is a novel approach for modeling tasks and their dependencies in the computational job system which is much richer than the modelling capabilities of AQT. As mentioned, a job is composed by a set of tasks, each described by some parameters, like the server in which the task must be executed or the time that the task needs to be completed. Additionally, each task depends on other tasks of the same job (i. e., subsets of tasks that must be completed before the given task starts). The rich variety of task dependencies that we allow is, as far as we know, unique of our formalism, and makes AJQ very adaptive to model a variety of complex scenarios (including AQT as a special case). For instance, our model allows imposing that a task q cannot start until a set P of other tasks of the same job are completed. This expresses a scenario in which task q aggregates the results obtained by the tasks in P . One example of this configuration is a MapReduce computation [11], in which the reduce task has to wait for all the map tasks to complete. This dependence in which the task q needs all the tasks in set P to complete is called an AND dependence. However, our formalism allows for more expressiveness by means of the OR dependence, in which several AND dependencies are combined. In this case, a task q has several sets P 1 , P 2 , . . . , P l , and it waits for any set P i to be completed. This configuration appears, for instance, when several redundant tasks are used, so that the output of any of them is equally valid as input for q [12].
As mentioned, tasks are processed in servers. When tasks are active (ready to be executed) at a server but not being processed yet, they are maintained in a queue at the server. It is assumed that each server has an infinite buffer to store its own queue of active tasks. We use a bounded adversarial setting in our model. In this setting, we assume that an adversary injects jobs in the system, choosing the time and the characteristics of each injected job, with certain limits. This leads to worst-case system analyses. A desirable property under this model is that each server's service rate matches its injection rate for an arbitrarily long period of time, which implies the stability of the system, since the number of jobs at any time is bounded.
In the rest of this paper, we define the model more formally and provide some results regarding both the stability and instability under different assumptions. From the point of view of the dependencies between tasks, we show that if they are feed-forward (see below) then the system is stable. From the point of view of the scheduling policies (i. e., how a server decides which task to execute next), we observe that, since AJQ is more general than AQT (once we do the appropriate matching between jobs and packets, and between links and servers) unstable scheduling policies in AQT are easily translated into policies that are unstable in AJQ. On the other hand, we show that some stable scheduling policies in AQT remain stable in AJQ. For instance, we prove that LIS, which gives priority to older tasks/packets (and is stable in AQT for any rate below 1), is stable in AJQ if the injection rate of jobs is below a certain value that depends on the tasks processing time and activation delay. Finally, we show that there are other policies that are stable in AQT but unstable in AJQ.

Model
In this section, we define the Adversarial Job Queueing (AJQ) model. The AJQ model is designed to analyze systems of queueing jobs. The three main components of an AJQ system (S, P, A) are: • a set S = {s 1 , s 2 , . . . , s n } of n servers, • an adversary A who injects jobs in the system, and • a scheduling policy P , which is the criteria used by servers to decide which task to serve next among the tasks waiting in their queues.
The system evolves over time continuously (unlike AQT, which assumes discrete time). In each moment, the adversary may inject jobs to the system while the servers process those jobs. In each moment as well, some tasks may be waiting to be executed, others may be in process, and others may be completed. A job is considered completed when all its tasks are completed. When a job is completed, all its tasks disappear from the system.
Each job K, f K consists of a finite set K of tasks and a function f K that determines dependencies among the tasks. (For simplicity we will denote the job K, f K by its task set K.) Let K = {k 1 , k 2 , k 3 , . . . , k l K } be a job, where each k i is a task of K. The integer l K denotes the number of tasks of K. Each task k i is defined by three parameters The parameter s K i ∈ S is the server in which k i must be executed. The parameter d K i ≥ 0 is the activation delay of k i . The parameter t K i > 0 is the processing time of k i , i. e., the time server s K i takes to execute task k i .
Let (S, P, A) be an AJQ system. Let T max := max i,K {t K i } and T min := min i,K {t K i } be the maximum and minimum time, respectively, required to complete a task of any job K injected in the system. We assume that these two quantities are bounded and do not depend on the time. Let D min := min i,K {d K i } and D max := max i,K {d K i } be the minimum and maximum activation delay, respectively, among all tasks of any job injected in the system. Since, d K i ≥ 0 it follows that D min ≥ 0. On the other hand, we assume that D max is a constant that may depend on the parameters of the system, but it does not change over time. Finally, we use L = max K {l K } to denote the maximum number of tasks (length) of a job, which we assume is also a constant that does not depend on the time.
Feasibility. Let P(K) be the power set of K, i. e., the set of all subsets of K. Furthermore, let P 2 (K) be the second power set of K, i. e., the set of all subsets of P(K). Given a job K, a feasibility function f K : K → P 2 (K) determines which tasks of K are feasible, which means that they are ready to be executed, once the activation delay has passed. Let f K (k i ) be equal to {A 1 , A 2 , . . . , A i }. The sets A x for 1 ≤ x ≤ i are called feasibility sets for k i . Then, the task k i is feasible at a time t if there exists a feasibility set A x for k i such that all tasks in A x have been completed by time t. Otherwise, k i is blocked, and still has to wait for some other tasks of K to complete before becoming feasible.
The activation delay d k i of a task k i represents a setup cost, expressed in time, that k i must incur once it becomes feasible and before it can start to be processed. If t is the time instant at which k i becomes feasible, then k i will incur its activation delay during time interval [t, t + d k i ]. Hence, it cannot be executed during such interval, in which we say that task k i is a delayed feasible task (or only delayed task). When k i completes its activation delay at time t + d k i , it can be served, and since that moment will be referred to as an active feasible task, or simply active task. Equivalently, a feasible task is active if it has been feasible for at least d k i time. A job with at least one feasible (resp., active) task will be referred to as a feasible (resp., active) job. Table 1: This table shows the feasibility function of two different jobs J and K defined over the same set of tasks {1, 2, 3, 4, 5}. Column f J (·) shows the feasibility function of job J, while column f K (·) shows the feasibility function of job K. Job J is not doable, since tasks 2, 3, 4 and 5 cannot be assigned a layer. On the other hand, job K is doable. Indeed, the number of each task in job K corresponds to its layer.
Tasks  Table 2: This figure shows the skeleton of jobs J and K presented in Table 1, which are the same.
With the feasibility function, a task cannot start being served until some given state of the tasks in the same job holds. Hence, the feasibility function can be used, for instance, to force the execution sequence of the tasks of a job. It enhances the modeling capabilities of the AJQ model by allowing the coexistence of AND dependencies and OR dependencies, as mentioned.
Doability. Let K be a job and k i be a task of K. We say that k i is an initial task of K if ∅ ∈ f K (k i ). Observe that all initial tasks k i are automatically feasible at the time the job K is injected, and they become active d K i time later. We assign a layer λ(K, i) to the tasks k i of a job K as follows. All initial tasks have layer λ(K, i) = 1. For any j > 1, a task k i is assigned layer λ(K, i) = j if it is not feasible when all tasks of layers 1, ..., j − 2 are completed, but it becomes feasible when additionally the tasks of layer j − 1 are completed. Let λ K ≤ l K denote the number of layers of job K. If a task k i has layer λ(K, i) = , then there is a feasibility set A Observe that the above definition does not guarantee that all tasks of a job will be assigned a layer. In fact, it is not hard to create jobs that have tasks dependencies (e.g., cyclic dependencies) that prevent some tasks from being assigned a layer. Table 1 shows an example of a job whose tasks get layer numbers and an example with tasks that cannot be assigned a layer number.
We want every job to be potentially completed. Therefore, we impose some restrictions over every feasibility function. Definition 1. Let K be a job and f K : K → P 2 (K) be its feasibility function. We say that K is doable if every task k i of K can be assigned a layer.
It is worth mentioning that, deciding whether a job is doable or not as defined can be computed in polynomial time with respect to the size of the job (that takes into account the number of tasks and the size of the feasibility function). Indeed, layer 1 can be computed by checking which tasks have the empty set as a feasibility set. Then, a simple recursive algorithm computes all tasks in layer i using all the tasks in layers 1, 2, . . . , i − 1.
We show in the next proposition, that the condition of doable job is necessary for a job to be completed, and that it is also sufficient if it is the only job injected in a system and the scheduling policy is work conserving. Proposition 1. Let (S, P, A) be a system where the adversary A injects only one job K and P is work conserving. Then, K can be completed if and only if K is doable.
Proof. On one hand, if K is doable, K can be completed, since until that happens, there will always be at least one feasible task not completed. To see this, assume by contradiction that there is a moment before K is completed such that no task is feasible. Consider any task k i among those that have not been completed yet with the smallest layer (since K is doable, all tasks have a layer). Therefore, k i has a feasibility set that is a subset of the completed tasks. Hence, k i is feasible, which is a contradiction. Then, since there are always feasible tasks, their activation time is bounded, there are no other jobs in the system, and P is work conserving, eventually all tasks of K will become active, be scheduled and processed, and complete.
On the other hand, assume that job K is not doable but completes all its tasks in system (S, P, A). Then, all tasks in K become feasible at some point in time, even those that are not assigned a layer. Consider the first task k i that becomes feasible among those that have no layer (break ties randomly). If this happens at time t, let U be the set of tasks that completed by time t, and let = max kj ∈U λ(K, j). Then, from the procedure to assign layers to tasks, k i would have been assigned a layer λ(K, i) ≤ + 1, which is a contradiction.
Topologies. Let K be a job, and k i and k j be two tasks of K. We say that k i depends on k j if there exists a feasibility set A It is worthwhile to mention that a skeleton does not define the feasibility function of a job. The two jobs presented in Table 1 are different jobs on the same set of tasks and with the same skeleton (see Figure 2). Nevertheless, one of the two jobs in Table 1 is doable and the other is not. Hence, the skeleton does not even differentiate between doable and not doable jobs.
The topology of a job K is the directed graph obtained by mapping the skeleton of K into the set of servers, where each task k i is mapped into its corresponding server s K i . Definition 3. Given a system (S, P, A), the topology of the system is the directed graph obtained by overlapping the topology of all jobs injected by A in the system.  Figure 7.
Scheduling policy. We assume that each server has an infinite buffer to store its own queue of tasks. Every active task waits in the queue of its corresponding server. In each server, a scheduling policy P specifies which task of all active tasks in its queue to serve next. We assume that scheduling policies are greedy/work conserving (i. e., a server always decides to serve if there is at least one active task in its queue). Examples of policies are First-In-First-Out (FIFO) which gives priority to the task that first came in the queue, or Last-In-First-Out (LIFO) which gives priority to the task that came last in the queue. Other policies will be defined later in the document.
Adversary. We assume that there is a malicious adversary A who injects doable jobs into the system. In order to avoid trivial overloads, the adversary is bounded in the following way. Let N s (I) be the total load injected by the adversary during time interval I in server s (i. e., N s (I) = t K i over all jobs K injected during I and tasks k i such that s K i = s). Then, for every server s and interval I the adversary is bounded by: where 0 < r ≤ 1 is called the injection rate, and b > 1 is called the burstiness allowed to the adversary. Observe that (1) implies max i,K {t K i } ≤ b, since jobs are injected instantaneously. An adversary that satisfies (1) is called a bounded (r, b)-adversary, or simply an (r, b)-adversary.
As mentioned, the system formed by an (r, b)-adversary A injecting doable jobs in the set of servers S using the scheduling policy P is called an AJQ system (S, P, A).
The number of active tasks in the queue of server s at time t is denoted Q s (t).
Definition 4. Let (S, P, A) be an AJQ system. We say that the system (S, P, A) is stable if there exists a value M such that Q s (t) ≤ M for all t and for all s ∈ S, where M may depend on the system parameters (adversary, servers, and jobs characteristics) but not on the time.
Definition 5. Let P be a policy. If a system (S, P, A) is stable against any (r, b)-adversary A with rate r < 1, then we say that the policy P is universally stable.
In the next sections, we provide some results regarding both the stability and instability in the AJQ model.

Stability and Instability of Scheduling Policies
From the point of view of the scheduling policies (i. e., how a server decides which task to choose from the set of active tasks pending to be executed), in this section we show stability of the policy that gives priority to the task (job) that has been for the longest period of time in the system. On the other hand, we show that other well-known scheduling policies are not stable.       Table 7: This figure shows the topology of job R (described in Figure 3 and Table 4) in solid lines, the topology of job M (described in Figure 5 and Table 6) in dashed lines, and, with all the lines, the topology of a system in which only these two jobs are injected by the adversary.

Stability of LIS
The LIS (Longest-In-System) scheduling policy gives priority to the task (and hence the job) which has been in the system for the longest time. In this subsection, we show that any system (S, LIS, A) is stable, for any (r, b)-adversary A with r < T min /(T max + D max ). We start by showing a bound on the time that a job spends in the system until it is done.
Consider a job K = {k 1 , k 2 , . . . , k l K } injected at time T 0 . Let T i be the first time in which all tasks in the i-th layer of K are completed. The time T λ K is the time when K is done. Let T be some time in the interval [T 0 , T λ K ]. We denote by g T the injection time of the oldest job that is still in the system at time T . We define Lemma 1. Let (S, LIS, A) be an AJQ system where A is an (r, b)-adversary with r < T min /(T max + D max ). Then, Proof. Let K be a job. Let k * be the last task to be processed in the i-th layer of K. Hence, k * is complete at time Solving the recurrence, we obtain: Which proves the lemma.
Since we are considering a case where r < T min /(T max + D max ), it holds that r(T max + D max )/T min = 1 − < 1. Hence, we rewrite the lemma as follows: Theorem 1. Let (S, LIS, A) be an AJQ system where A is an (r, b)-adversary with r < T min /(T max + D max ). Then, all jobs spend less than D max T min + rb(T max + D max ) T min − r(T max + D max ) time in the system.
Proof. It is worth mentioning that c is the only time-depending parameter in the bound given by the previous lemma. Hence, if we show that c actually does not depend on time, we will be showing the theorem. We prove it by contradiction. Assume that there is a moment in which c is strictly larger than: Hence, there has been a job in the system for a period of time strictly longer than: If we apply the previous lemma to this job, it should have been absorbed in at most: time, which is a contradiction.

Scheduling Policies that are Unstable
Here, we show that a number of well-known policies such as First-In-First-Out (FIFO), Nearest-To-Go (NTG), Furthest-From-Source (FFS), and Last-In-First-Out (LIFO), are unstable, even for arbitrarily small injection rates. While the meaning of FIFO and LIFO in the context of AJQ is clear (and similar as in AQT), we need to define NTG and FFS.
For a task k i of job K the distance from source is the distance between the layer of k i and layer one (λ(K, i) − 1), and the distance to go is the distance between the number of layers of K and k i 's layer (λ K − λ(K, i)). Hence, FFS gives priority to the task with largest distance from source and NTG gives priority to the task with smallest distance to go. Theorem 2. FIFO, NTG, FFS, and LIFO are unstable for every r > 0.
Proof. First, we highlight that, given a system (G, P, A) in AQT, it can be modeled as a system (S, P, A ) in AJQ as follows: • For each link l in G, there is a unique server s l in S, which we call its equivalent server.
• The scheduling policy P is the same both in AQT and in AJQ.
• For each packet p injected by A, the adversary A injects a job K such that: -For each link l in the path of packet p, there is a task k l in K to be executed in server s l .
-If l is the first link in the path of p, then k l is the initial task of job K.
-If the path of packet p traverses link l immediately before it traverses link l then task k l only depends on task k l . -The processing time of each task is 1 and its activation delay is 0.
Clearly, if (G, P, A) is unstable for a given injection rate then (S, P, A ) will be also unstable for the same injection rate (i. e., all the unstable scheduling policies in AQT are also unstable in AJQ).
By using the results in [6], we have that NTG, FFS, and LIFO are unstable (in AQT) for every r > 0, and by using the result in [3] (in AQT) we have that FIFO is also unstable for every r > 0. Therefore, the theorem directly follows.

Topological Stability
In this section we show stability for systems with feed-forward topology. We say that a system has feed-forward topology if it is possible to enumerate the servers from 1 to n, so that every directed arc in the topology of the system goes from a server with a smaller label to a server with a larger label. Theorem 3. Let (S, P, A) be an AJQ system with feed-forward topology. Then, for any policy P and any (r, b)adversary A with injection rate r ≤ 1, the system (S, P, A) is stable.
Proof. Let (S, P, A) be an AJQ system with feed-forward topology. Without loss of generality, assume that the ordering of the set of servers that makes the system feed-forward is s 1 , s 2 , . . . , s n . For simplicity, we only use the position j to denote server s j . Let τ j (t) be the time that server j would need to completely serve (drain) all its pending tasks present in the system at time t if they were all active and no new task were injected: where K(j, t) is the set of pairs (K, i) such that K was injected by time t, s K i = j, and task k i has not been completed in server j. We define a potential function Φ(·) as follows: where τ j (0) denotes the time server j requires to process all its tasks present in the system before the adversary starts injecting jobs in the system. For 2 ≤ j ≤ n, Φ(j) is defined as: To prove this theorem, we show that for all 1 ≤ j ≤ n and for all t, τ j (t) ≤ Φ(j). We use induction on j, the position of the servers in the ordering of S.
Case j = 1: Consider some time T . We prove that τ 1 (T ) ≤ Φ(1). First, assume that for all time t ∈ [0, T ] there is at least one active task in the queue of server 1. Then, server 1 has been continuously working during the interval [0, T ].
The time required to process all its queue at time T is the time it would need to process the tasks present at time 0 in its queue, plus the time required to process the load injected by the adversary during that interval, minus the load processed during that interval. In the form of an equation, the previous amount of time is: Otherwise, there exists some time t ∈ [0, T ] such that there is no active task in the queue of server 1 at time t. Let t * be the largest of such times. Note that, in that case, all tasks injected in server 1 before time t * , and present at time t * , were injected after time t * − D max , since every task injected before that time is active at time t * . Therefore, by restriction (1), it holds: Then, the time required to process all its queue at time T is the time it would need to process the tasks present at time t * , plus the time required to process the load injected by the adversary during the interval [t * , T ], minus the load processed during the same interval of time. In the form of an equation, the previous amount of time is: Case j > 1: The inductive hypothesis is τ i (t) ≤ Φ(i) for all for all t and for all 1 ≤ i < j. By inductive hypothesis then, the amount of tasks in servers i < j is at most , the number of tasks they can trigger in server j is at · L, and the processing time for all those tasks is at most Consider again some time T . We consider two cases equivalent to those considered in the case j = 1. First, server j has at least one active task in its queue during all the interval [0, T ]. Therefore, server j has processed tasks during all that time. In that case, server j would need all the time required to process the tasks present at time 0 in its queue, plus all the time required to process the tasks triggered by tasks in previous servers, plus all the time required to process the load injected by the adversary during the interval [0, T ], minus the load processed during that interval. Which, in the form of an equation is: Assume now that there is some time t ∈ [0, T ] such that there is no active task in the queue of server j at time t. Let t * be the largest such time. An analysis equivalent to the one presented in the case j = 1 shows that τ j (t * ) ≤ D max + b. Therefore, if we compute τ j (T ) equivalently to the previous cases, we obtain: Hence, the time required by server j to drain its queue is bounded by Φ(j), a function that does not depend on time.
In conclusion, at any time, there are at most Φ(j)/T min tasks in the queue of server j, and the system is stable.
We showed that a feed-forward topology is a sufficient condition for stability in a system. Nevertheless, this condition is not necessary. Indeed, as we have shown before, for any system (G, P, A) in the AQT model, there is an equivalent system (S, P, A ) in the AJQ model. We know that, in the AQT model, any system with a ring network (i. e., a directed cycle) is stable with any scheduling policy and against any adversary. Therefore, the equivalent system in the AJQ model will also be stable. Nevertheless, such AJQ system has a topology that is not feed-forward.

Job Properties that can Affect the Stability of the System
In this section, we show that some of the features of the injected jobs can play a key role regarding the stability of the system. Namely, we show that both the tasks' processing time and activation delays are factors that, individually, can cause instability. We also show that the feasibility function can lead, by itself, to instability.

Tasks' Processing Times
We show that the processing times of the tasks can affect the stability of the system. Namely, a stable system can be transformed into unstable by varying the processing time of some of their tasks, even if the adversary has the same rate r in both systems. Let LCT-LIS be the scheduling policy that gives priority to the task with longest processing time at the current server, breaking ties according to the longest-in-system policy.

Proposition 2.
There exists a server set S and an adversary A with injection rate r > 1/ √ 2 such that the system (S, LCT-LIS, A) is unstable.
Proof. The proof is inspired by the instability by difference in packet length proof in the continuous AQT [5] (CAQT) model. Let (G, LPL-LIS, A ) be the system used in Theorem 26 in [5] (LPL-LIS denotes the scheduling policy that gives priority to the packets with longest length, breaking ties according to the longest in system policy). Note that (G, LPL-LIS, A ) can be seen as an AQT system, except that two different packet lengths (1 and 2) are taken into account. Let us now consider a system (S, LCT-LIS, A) in AJQ, such that: • The scheduling policy is LCT-LIS.
• For each packet p injected by A , the adversary A injects a job such that all its tasks have a processing time (1 and 2) equal to the length of the injected packet.
• The rest of the system is modeled in the same fashion as in the proof of Theorem 2.
Theorem 26 in [5] shows that (G, LPL-LIS, A ) is unstable for an injection rate r > 1/ √ 2. Therefore, it is not hard to derive that (S, LCT-LIS, A) is also unstable for the same rate. Observe that if all tasks have the same processing time T , then the LCT-LIS scheduling policy becomes LIS. As shown in Theorem 1, LIS is stable for any r < T min /(T max + D max ) = T /(T + D max ). Hence, for small D max (e.g., D max = 0), we have a rate r > 1/ √ 2 for which LCT-LIS is stable if all tasks have the same processing time. Therefore, we have shown that an unstable system can be transformed into stable by only varying the processing times of some of their tasks.

Tasks' Activation Delays
As it has been done in the previous subsection, here we show that the activation delays of the tasks can affect the stability of the system. Let SAD-NFS be the scheduling policy that gives priority to the task with smallest activation delay at the queue of the current server, breaking ties according to the nearest from source policy regarding to an initial task in the job's skeleton. Proposition 3. There exists a server set S and an adversary A with injection rate r > 1/ √ 2 such that the system (S, SAD-NFS, A) is unstable. shows the number of queued packets at each time instant for an injection rate of 0.8 (which is slightly higher than 1/ √ 2): dashed lines correspond to servers s 1 and s 4 , and the solid line corresponds to the overall system. As it can be seen, the number of queued tasks at s 1 and s 4 oscillate in an alternating and increasing fashion, which provokes a continuous increase in the system's number of queued tasks.
Proof. The proof follows the lines of the one in Proposition 2. Let (G, SPP-NFS, A ) be the system used in Theorem 28 in [5] (SPP-NFS denotes the scheduling policy that gives priority to the packets whose previously traversed link had smallest propagation delay, breaking ties according to the nearest-from-source policy). Note that in this system the transmission time of every packet is the same in every link. Hence, (G, SPP-NFS, A ) can be seen as an AQT system, except that some links have a positive fixed propagation delay.
Let us now consider a system (S, SAD-NFS, A) in AJQ, such that: • The scheduling policy is SAD-NFS.
• For each link l in G with a propagation delay d l , all tasks executed in its equivalent server will have an activation delay equal to d l . That is, the activation delays are seen as the delays taken by packets to traverse the links (besides the times spend at the queues).
• The rest of the system is modeled in the same fashion as in Theorem 2.
Clearly, if the system (G, SPP-NFS, A ) is unstable for a given injection rate then (S, SAD-NFS, A) will be also unstable for the same injection rate. However, by using the result in [5] (Theorem 28), we have that (G, SPP-NFS, A ) is unstable for an injection rate r > 1/ √ 2. Therefore, we have that (S, SAD-NFS, A) is also unstable for the same rate.
Note that if all links in the system (G, SPP-NFS, A ) of the previous proof have zero delay it becomes an AQT system, and the (S, SAD-NFS, A) system obtained has only tasks with activation delay of 0. In that case, both SPP-NFS and SAD-NFS behave as NFS in their respective systems. Moreover, since NFS is universally stable in AQT as shown in [1], both systems (G, SPP-NFS, A ) and (S, SAD-NFS, A) are stable. Hence, we have shown that an unstable system can be transformed into stable by only varying the activation delays of some of their tasks.

Feasibility Function Among Tasks
Now, we show that the feasibility function is a factor that, by itself, can also induce instability. We say that a feasibility function is fully independent if no task in any job depends on any other task (i. e., all tasks are initial). In this case, we also say that the tasks are fully independent. Proposition 4. Let (S, P, A) be an AJQ system such that all the tasks are fully independent. Then, for any set of servers S, any policy P and any (r, b)-adversary A with injection rate r ≤ 1, the system (S, P, A) is stable.
Proof. Direct, from the injection bound of Equation (1) and the fact that P is work conserving.
Then, it is clear that if we take an unstable system and make all tasks fully independent, it will become stable.

Future Work
The AJQ model opens interesting research questions. Regarding scheduling policies, it is still unknown whether there exists a universally stable policy (i. e., a policy stable under any adversary with r < 1). Indeed, all the parameters of the model make difficult to see the existence of a universally stable policy. Regarding systems' topology, a full characterization of the topologies that produce a stable system against any bounded adversary is still open. For instance, while we argue in Section 4 that the universal stability of the ring in AQT can be propagated to AJQ, it is only for jobs that mimic the dependencies and topology of AQT. It would be interesting to know whether all AJQ systems with a ring topology are stable under bounded adversaries.
On another hand, the AJQ model can be extended transferring the resource allocation decision from the adversary to the scheduling policy. In that case, the adversary could provide, for each task, a set of servers in which it can be processed (instead of a single server, as it is done in our model). In that extended model, we would be able to study the impact of resource allocation into the stability of a system.