Blind GB-PANDAS: A Blind Throughput-Optimal Load Balancing Algorithm for Affinity Scheduling

TL;DR

This paper introduces Blind GB-PANDAS, a novel load balancing algorithm that is throughput optimal and does not require knowledge of task arrival or service rates, using exploration-exploitation to improve system stability and task completion times.

Contribution

The paper proposes Blind GB-PANDAS, the first throughput-optimal load balancing algorithm that operates without prior knowledge of service or arrival rates, using an exploration-exploitation approach.

Findings

Blind GB-PANDAS is proven to be throughput optimal under unknown distributions.

It significantly reduces mean task completion time at high loads.

Outperforms existing methods in experimental evaluations.

Abstract

Dynamic affinity load balancing of multi-type tasks on multi-skilled servers, when the service rate of each task type on each of the servers is known and can possibly be different from each other, is an open problem for over three decades. The goal is to do task assignment on servers in a real time manner so that the system becomes stable, which means that the queue lengths do not diverge to infinity in steady state (throughput optimality), and the mean task completion time is minimized (delay optimality). The fluid model planning, Max-Weight, and c-$\mu$-rule algorithms have theoretical guarantees on optimality in some aspects for the affinity problem, but they consider a complicated queueing structure and either require the task arrival rates, the service rates of tasks on servers, or both. In many cases that are discussed in the introduction section, both task arrival rates and service rates of different task types on different servers are unknown. In this work, the Blind GB-PANDAS algorithm is proposed which is completely blind to task arrival rates and service rates. Blind GB-PANDAS uses an exploration-exploitation approach for load balancing. We prove that Blind GB-PANDAS is throughput optimal under arbitrary and unknown distributions for service times of different task types on different servers and unknown task arrival rates. Blind GB-PANDAS desires to route an incoming task to the server with the minimum weighted-workload, but since the service rates are unknown, such routing of incoming tasks is not guaranteed which makes the throughput optimality analysis more complicated than the case where service rates are known. Our extensive experimental results reveal that Blind GB-PANDAS significantly outperforms existing methods in terms of mean task completion time at high loads.

Equations

$$B_{\mu }={\left[\begin{array}{ccccc}{\mu }_{1,1}& {\mu }_{1,2}& {\mu }_{1,3}& \dots & {\mu }_{1,M}\\ {\mu }_{2,1}& {\mu }_{2,2}& {\mu }_{2,3}& \dots & {\mu }_{2,M}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ {\mu }_{N_T,1}& {\mu }_{N_T,2}& {\mu }_{N_T,3}& \dots & {\mu }_{N_T,M}\end{array}\right]}_{N_T,M}.$$

$$W_m(t)=\frac{Q_m^1(t)}{{\alpha }_m^1}+\frac{Q_m^2(t)}{{\alpha }_m^2}+\cdots +\frac{Q_m^{N^m}(t)}{{\alpha }_m^{N^m}}.$$

$$m^{\ast }=\underset{m\in \mathcal{M}}{\mathrm{argmin}}\frac{W_m(t)}{{\mu }_{i,m}}.$$

$$j\in \underset{i\in \mathcal{L}}{\mathrm{argmax}}\{{\mu }_{i,m}\cdot Q_i(t)\}.$$

$$j\in\underset{i\in\mathcal{L}}{\arg\max}\ \big{\{}\mu_{i,m}\cdot C_{i}^{\prime}\big{(}Q_{i}(t)\big{)}\big{\}},$$

$$\sum _{i\in \mathcal{L}}\frac{{\lambda }_{i,m}}{{\mu }_{i,m}}<1,\forall m\in \mathcal{M}.$$

$$\displaystyle\Lambda=\big{\{}\boldsymbol{\lambda}=(\lambda_{i}:i\in\mathcal{L})\ \big{|}\ \exists\lambda_{i,m}\geq 0,\forall i\in\mathcal{L},\forall m\in\mathcal{M},s.t.$$

$$\displaystyle\ \ \ \ \ \ \ \ \ \ \lambda_{i}=\sum_{m=1}^{M}\lambda_{i,m},\ \forall i\in\mathcal{L},\ \ \ \sum_{i\in\mathcal{L}}\frac{\lambda_{i,m}}{\mu_{i,m}}<1,\forall m\in\mathcal{M}\big{\}}.$$

$${\tilde{B}}_{\mu }(t)=\left[\begin{array}{ccccc}{\tilde{\mu }}_{1,1}(t)& {\tilde{\mu }}_{1,2}(t)& {\tilde{\mu }}_{1,3}(t)& \dots & {\tilde{\mu }}_{1,M}(t)\\ {\tilde{\mu }}_{2,1}(t)& {\tilde{\mu }}_{2,2}(t)& {\tilde{\mu }}_{2,3}(t)& \dots & {\tilde{\mu }}_{2,M}(t)\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ {\tilde{\mu }}_{N_T,1}(t)& {\tilde{\mu }}_{N_T,2}(t)& {\tilde{\mu }}_{N_T,3}(t)& \dots & {\tilde{\mu }}_{N_T,M}(t)\end{array}\right].$$

$${\tilde{\alpha }}_m^n(t_2)=\frac{\tilde{n}-1}{\tilde{n}}\cdot {\tilde{\alpha }}_m^n(t_1)+\frac{1}{\tilde{n}\cdot T_m^n(t_2)}.$$

$${\tilde{W}}_m(t)=\frac{Q_m^1(t)}{{\tilde{\alpha }}_m^1(t)}+\frac{Q_m^2(t)}{{\tilde{\alpha }}_m^2(t)}+\cdots +\frac{Q_m^{N^m}(t)}{{\tilde{\alpha }}_m^{N^m}(t)}.$$

$${\tilde{m}}^{\ast }=\underset{m\in \mathcal{M}}{\mathrm{argmin}}\frac{{\tilde{W}}_m(t)}{{\tilde{\mu }}_{i,m}(t)}.$$

$$A_m^n(t)=\sum _{i\in {\mathcal{L}}_m^n}{A}_{i,m}(t),\forall m\in \mathcal{M},1\le n\le N^m.$$

$$f_m(t)=\{\begin{array}{l}-1,\text{if server m is idle,}\\ 1,\text{if server m processes a 1-local task from Qm1,}\\ 2,\text{if server m processes a 2-local task from Qm2,}\\ ⋮\\ N^m,\text{if server m processes an Nm-local task}\\ \text{ from QmNm.}\end{array}$$

$$Q_m^n(t+1)=Q_m^n(t)+A_m^n(t)-S_m^n(t),\text{ for }1\le n\le N^m-1,$$

$$Q_m^{N^m}(t+1)=Q_m^{N^m}(t)+A_m^{N^m}(t)-S_m^{N^m}(t)+U_m(t),$$

$$W_m(t+1)=\frac{Q_m^1(t+1)}{{\alpha }_m^1}+\frac{Q_m^2(t+1)}{{\alpha }_m^2}+\cdots +\frac{Q_m^{N^m}(t+1)}{{\alpha }_m^{N^m}}$$

$$\stackrel{(a)}{=}\frac{Q_m^1(t)+A_m^1(t)-S_m^1(t)}{{\alpha }_m^1}+\frac{Q_m^2(t)+A_m^2(t)-S_m^2(t)}{{\alpha }_m^2}+$$

$$\cdots +\frac{Q_m^{N^m}(t)+A_m^{N^m}(t)-S_m^{N^m}(t)+U_m(t)}{{\alpha }_m^{N^m}}$$

$$\displaystyle\hskip 7.11317pt=W_{m}(t)+\bigg{(}\frac{A_{m}^{1}(t)}{\alpha_{m}^{1}}+\frac{A_{m}^{2}(t)}{\alpha_{m}^{2}}+\cdots+\frac{A_{m}^{N^{m}}(t)}{\alpha_{m}^{N^{m}}}\bigg{)}$$

$$\displaystyle\hskip 48.36958pt-\bigg{(}\frac{S_{m}^{1}(t)}{\alpha_{m}^{1}}+\frac{S_{m}^{2}(t)}{\alpha_{m}^{2}}+\cdots+\frac{S_{m}^{N^{m}}(t)}{\alpha_{m}^{N^{m}}}\bigg{)}+\frac{U_{m}(t)}{\alpha_{m}^{N^{m}}}$$

$$\stackrel{(b)}{=}{W}_m(t)+A_m(t)-S_m(t)+{\tilde{U}}_m(t),$$

$$A_m(t)$$

$$S_m(t)$$

$${\tilde{U}}_m(t)$$

$$\text{mathbold}W(t+1)=\text{mathbold}W(t)+\text{mathbold}A(t)-\text{mathbold}S(t)+\widetilde{\text{mathbold}U}(t).$$

$$\sum _{i\in \mathcal{L}}\frac{{\lambda }_{i,m}}{{\mu }_{i,m}}<\frac{1}{1+\delta },\forall m\in \mathcal{M}.$$

$$w_m=\sum _{i\in \mathcal{L}}\frac{{\lambda }_{i,m}}{{\mu }_{i,m}},\forall m\in \mathcal{M}.$$

$$⟨\text{mathbold}W(t),\widetilde{\text{mathbold}U}(t)⟩=0,\forall t.$$

$$\displaystyle\mathbb{E}\Big{[}\sum_{t=T_{0}}^{t_{0}+T-1}\Big{(}\langle\mathbold{W}(t),\mathbold{A}(t)\rangle-\langle\mathbold{W}(t),\mathbold{w}\rangle\Big{)}\Big{|}\mathbold{Z}(t_{0})\Big{]}$$

$$\le {\theta }_{0}T\Vert \text{mathbold}Q(t_0){\Vert }_1+c_0,$$

$$\displaystyle\mathbb{E}\left[\sum_{t=t_{0}}^{t_{0}+T-1}\Big{(}\langle\mathbold{W}(t),\mathbold{w}\rangle-\langle\mathbold{W}(t),\mathbold{S}(t)\rangle\Big{)}\Big{|}\mathbold{Z}(t_{0})\right]$$

$$\le -{\theta }_{1}T\Vert \text{mathbold}Q(t_0){\Vert }_1+c_1,\forall t_0\ge 0,$$

$$\mathbb{E}\Big{[}\|\mathbold{\Psi}(t_{0}+T)\|_{1}-\|\mathbold{\Psi}(t_{0})\|_{1}\Big{|}\mathbold{Z}(t_{0})\Big{]}\leq-\theta_{2}\|\mathbold{\Psi}(t_{0})\|_{1}+MT.$$

$$\displaystyle\mathbb{E}\big{[}V(Z(t_{0}+T))-V(Z(t_{0}))\big{|}\mathbold{Z}(t_{0})=z\big{]}$$

$$\le -\theta {\mathbb{I}}_{\{z\in {\mathcal{P}}^c\}}+C{\mathbb{I}}_{\{z\in \mathcal{P}\}},$$

Full text

1 Introduction

Affinity load balancing refers to allocation of computing tasks on computing nodes in an efficient way to minimize a cost function, for example the mean task completion time [1]. Due to the fact that different task types can have different processing (service) rates on different computing nodes (servers), a dilemma between throughput and delay optimality emerges which makes the optimal affinity load balancing an open problem for more than three decades if the task arrival rates are unknown. If the task arrival rates and the service rates of different task types on different servers are known, the fluid model planning algorithm by Harrison and Lopez [2, 3], and Bell and Williams [4, 5] is a delay optimal load balancing algorithm that solves a linear programming optimization problem to determine task assignment on servers. The same number of queues as the number of task types is needed for the fluid model planning algorithm, so the queueing structure is fixed to the number of task types and does not capture the complexity of the system model, which is how heterogeneous the service rates of task types on different servers are. As an example given in [6] and [7], for data centers with a rack structure that use Hadoop for map-reduce data placement with three replicas of data chunks on the $M$ severs, the fluid model planning algorithm requires $M\choose 3$ queues, while Xie et al. [6] propose a delay optimal algorithm that uses $3M$ queues. As another extreme example, if the service rates of $N_{T}$ number of task types on all servers are the same, the fluid model planning algorithm still considers $N_{T}$ number of queues, while the First-Come-First-Served (FCFS) algorithm uses a single queue and is both throughput and delay optimal. It is true that in the last example all task types can be considered the same type, but this is just an example to enlighten the reasoning behind the queueing structure for GB-PANDAS (Generalized Balanced Priority Algorithm for Near Data Scheduling) presented in Section 2.1.

In the absence of knowledge on task arrival rates, Max-Weight [8] and c-$\mu$-rule [9] algorithms can stabilize the system by just knowing the service rates of task types on different servers. None of these two algorithms are delay optimal though. The c-$\mu$-rule is actually cost optimum, where it assumes convex delay costs associated to each task type, and minimizes the total cost incurred to the system. Since the cost functions have to be strictly convex, so cannot be linear, c-$\mu$-rule does not minimize the mean task completion time. Since these two algorithms do not use the task arrival rates and still stabilize the system, they are robust to any changes in task arrival rate as long as it is in the capacity region of the system. Both Max-Weight and c-$\mu$-rule algorithms have the same issue as the fluid model planning algorithm on considering one queue per task type which can make the system model complicated as discussed in [6]. Note that Wang et al. [10] and Xie et al. [6] study the load balancing problem for special cases of two and three levels of data locality, respectively. In the former, delay optimality is analyzed for a special traffic scenario and in the latter delay optimality is analyzed for a general traffic scenario and in both cases there is no issue on the number of queues, but as mentioned, these two algorithms are for special cases of two and three levels of data locality. Hence, a unified algorithm that captures the trade-off between the complexity of the queueing structure and the complexity of the system model is missed in the literature. Yekkehkhany et al. [11] implicitly mention this trade-off in data center applications, but the generalization is not crystal clear and needs more thinking for the affinity setup, which is summarized in this work as a complementary note on the Balanced-PANDAS algorithm.

The affinity scheduling problem appears in different applications from data centers and modern processing networks that consist of heterogeneous servers, where data-intensive analytics like MapReduce, Hadoop, and Dryad are performed, to supermarket models, or even patient assignment to surgeons in big and busy hospitals and many more. Lack of dependable estimates of system parameters, including task arrival rates and specially service rates of task types on different servers, is a major challenge in constructing an optimal load balancing algorithm for such networks [12]. All the algorithms mentioned above at least require the knowledge of service rates of task types on different servers. In the absence of prior knowledge on service rates, such algorithms can be fragile and perform poorly, resulting in huge waste of resources. To address this issue, we propose a robust policy called Blind GB-PANDAS that is totally blind to all system parameters, but is robust to task arrival rate changes, learns the service rates of task types on different servers, so it is robust to any service rate parameter changes as well. It is natural that due to traffic load changes in data centers, the service rate of tasks on remote servers change over time. In such cases, Blind GB-PANDAS is capable of updating system parameters and taking action correspondingly. Blind GB-PANDAS uses an exploration-exploitation approach to make the system stable without any knowledge about the task arrival rates and the processing rates. More specifically, it uses an exploration-exploitation method, where in the exploration phase it takes action in a way to make the system parameter estimations more accurate, and in the exploitation phase it uses the estimated parameters to do an optimal load balancing based on the estimates. Note that only the processing rates of task types on different servers are the parameters that are estimated, and the task arrival rates are not estimated. The reason is that task arrival rates change frequently, so there is not a point on estimating them, whereas the service rates do not change rapidly. Since Blind GB-PANDAS uses an estimate of the processing rates, an incoming task is not necessarily routed to the server with the minimum weighted-workload in the exploitation phase, which increases complexity in the throughput optimality proof of Blind GB-PANDAS using the Lyaponuv-based method. The throughput optimality result is proved under arbitrary and unknown service time distributions with bounded means and bounded supports that do not necessarily require the memory-less property.

As discussed in Section 2.1, the queueing structure used for Blind GB-PANDAS shows the trade-off between the heterogeneity of the underlying system model for processing rates and the complexity of the Blind GB-PANDAS queueing structure. Blind GB-PANDAS can also use a one queue per server queueing structure, where the workload on servers is of interest instead of the queue lengths, but for an easier explanation of the Blind GB-PANDAS algorithm we use multiple symbolic sub-queues for each server. The Blind GB-PANDAS algorithm is compared to FCFS, Max-Weight, and c-$\mu$-rule algorithms in terms of average task completion time through simulations, where the same exploration-exploitation approach as Blind GB-PANDAS is used for Max-Weight and c-$\mu$-rule. Our extensive simulations show that the Blind GB-PANDAS algorithm outperforms the three other algorithms at high loads by a reasonably large difference.

The rest of the paper is structured as follows. Section 2 describes the system model, GB-PANDAS, and the queueing structure of GB-PANDAS, in addition to deriving the capacity region of the system. Section 3 presents the Blind GB-PANDAS algorithm and queueing dynamics for this algorithm. Section 4 starts with some preliminary results and lemmas and ends up with the throughput optimality proof for Blind GB-PANDAS. Section 5 evaluates the performance of Blind GB-PANDAS versus Max-Weight, c-$\mu$-rule, and FCFS algorithms in terms of mean task completion time. Section 6 discusses the related works, and finally Section 7 concludes the paper with a discussion on opportunities for future work.

2 System Model

Consider $M$ unit-rate multi-skilled servers and $N_{T}$ number of task types as depicted in Figure 1. The set of servers and task types are denoted by $\mathcal{M}=\{1,2,\cdots,M\}$ and $\mathcal{L}=\{1,2,\cdots,N_{T}\},$ respectively. Each task can be processed by any of the $M$ servers, but with possibly different rates. The service times are assumed to be non-preemptive and discrete valued with an unknown distribution. Non-preemptive service means that the central load balancing algorithm cannot interrupt an in-service task, i.e. no other task is scheduled to a server until the server completely processes the task that is currently receiving service. The extension of the analysis for continuous service time, using approximation methods of continuous distributions with discrete ones, is an interesting future work. In this discrete time model, time is indexed by $t\in\mathbb{N}$. In the following, service time distributions and task arrivals are discussed, which are both unknown to the central scheduler.

Service time distribution: The service time offered by server $m\in\mathcal{M}$ to task type $i\in\mathcal{L}$ is a discrete-type random variable with cumulative distribution function (CDF) $F_{i,m}$ with mean $\frac{1}{\mu_{i,m}}$ or correspondingly with rate $\mu_{i,m}>0$. The service time distribution does not require the memory-less property. We further assume that the support of the service time is bounded, which is a realistic assumption and reduces the unnecessary complexity of the proofs specially in Lemma 4. The extension of the analysis for service times with unbounded supports is an interesting future work. Note that the completion time for a task is the waiting time for that task until it is scheduled to a server plus the service time of the task on the server. Waiting time depends on the servers’ status, the queue lengths or more specifically other tasks that are in the system or may arrive later, and the load balancing algorithm that is used, while service time has the mentioned distribution.

Task arrival: The number of incoming tasks of type $i\in\mathcal{L}$ at the beginning of time slot $t$ is a random variable on non-negative integer numbers that is denoted by $A_{i}(t)$, which are temporarily identically distributed and independent from each other. Denote the arrival rate of task type $i$ by $\lambda_{i}$, i.e. $\mathbb{E}[A_{i}(t)]=\lambda_{i}$. In the stability proof of Blind GB-PANDAS we need $\lambda_{i}$ to be strictly positive, so without loss of generality we exclude task types with zero arrival rate from $\mathcal{L}$. Furthermore, we assume that the number of each incoming task type at a time slot is bounded by constant $C_{A}$ and is zero with positive probability, i.e. $P(A_{i}(t)<C_{A})=1$ and $P(A_{i}(t)=0)>0$ for any $i\in\mathcal{L}$. The set of arrival rates for all task types is denoted by vector $\mathbold{\lambda}=(\lambda_{i}:i\in\mathcal{L})$.

Affinity scheduling problem refers to load balancing for such a system described above. The fluid model planning algorithm [3], MaxWeight [8], and c$\mu$-rule [9] are the baseline algorithms for affinity scheduling. All these algorithms in addition to GB-PANDAS use the rate of service times instead of the CDF functions. Hence, the system model can be summarized as an $N_{T}\times M$ matrix, where element $(i,m)$ is the processing rate of task type $i$ on server $m$, $\mu_{i,m}$, as follows:

[TABLE]

If both the set of arrival rates $\mathbold{\lambda}=(\lambda_{i}:i\in\mathcal{L})$ and the service rate matrix $B_{\mu}$ are known, the fluid model planning algorithm [3] derives the delay optimal load balancing by solving a linear programming. However, if the arrival rates of task types are not known, the delay optimal algorithm becomes an open problem which has not been solved for more than three decades. Max-Weight [8] and c$\mu$-rule [9] can be used for different objectives when we do not know the arrival rates, but none have delay optimality. In this work, we are assuming that we lack knowledge of not only the arrival rates $\mathbold{\lambda}$, but also the service rate matrix $B_{\mu}$. We take an exploration and exploitation approach to make our estimation of the underlying model, which is the service rate matrix, more accurate, and to keep the system stable.

2.1 Queueing Structure for GB-PANDAS

Every algorithm has its own specific queueing structure. For example, there is only a single central queue for the First-Come-First-Served (FCFS) algorithm, but there are $N_{T}$ number of queues when using fluid model planning, Max-Weight, or c$\mu$-rule. In the following, we present the queueing structure used for GB-PANDAS that captures the trade-off between the complexity of the system model and the complexity of the queueing structure very well. What we mean by the complexity of the system model is the heterogeneity of the service rate matrix, e.g. if all the elements of this matrix are the same number, the system is less complex than the case where each element of the matrix is different from other elements of the matrix.

The heterogeneity of the system from the perspective of server $m$ is captured in the $m$th column of the service rate matrix. Consider the $m$th column of the matrix has $N^{m}$ distinct values, where $N^{m}$ can be any number from $1$ to $N_{T}$. It is obvious that any of the task types with the same service (processing) rate on server $m$ look the same from the perspective of this server. Denote the $N^{m}$ distinct values of the $m$th column of $B_{\mu}$ by $\{\alpha_{m}^{1},\alpha_{m}^{2},\cdots,\alpha_{m}^{N^{m}}\}$ and without loss of generality assume that $\alpha_{m}^{1}>\alpha_{m}^{2}>\cdots>\alpha_{m}^{N^{m}}$. We call all the task types with a processing rate of $\alpha_{m}^{n}$ on the $m$th server, the $n$-local tasks to that server, and denote them by $\mathcal{L}_{m}^{n}=\{i\in\mathcal{L}:\mu_{i,m}=\alpha_{m}^{n}\}$. For ease of notation, we use both $\mu_{i,m}$ and $\alpha_{m}^{n}$ throughout the paper interchangeably; however, they are in fact capturing the same phenomenon, but with different interpretations. Note that the $n$-local tasks to server $m$ can be called $(n,m)$-local tasks in order to place more emphasis on the pair $n$ and $m$, so the $n$-local tasks to server $m$ are not necessarily the same as the $n$-local tasks to server $m^{\prime}$. We allocate $N^{m}$ queues for server $m$, where the $n$th queue of server $m$ holds all task types that are routed to this server and are $n$-local to it. As depicted in Figure 2, different servers can have different numbers of queues since the heterogeneity of the system model can be different from the perspective of different servers. We may interchangeably use queue or sub-queue to refer to the $n$th queue (sub-queue) of the $m$th server. The $N^{m}$ sub-queues of the $m$th server are denoted by $Q_{m}^{1},Q_{m}^{2},\cdots,Q_{m}^{N^{m}}$ and the queue lengths of these sub-queues, defined as the number of tasks in these sub-queues, at time slot $t$ are denoted by $Q_{m}^{1}(t),Q_{m}^{2}(t),\cdots,Q_{m}^{N^{m}}(t)$.

In the next subsection, the GB-PANDAS algorithm is proposed when the service rate matrix $B_{\mu}$ is known. Balanced-PANDAS for a data center with three levels of data locality is proposed by [6], and here we are proposing the Generalized Balanced-PANDAS algorithm from another perspective which is of its own interest.

2.2 GB-PANDAS Algorithm with Known Service Rate Matrix $B_{\mu}$

Before getting into the GB-PANDAS algorithm, we need to define the workload on server $m$.

Definition 1

The average time needed for server $m$ to process all tasks queued in its $N^{m}$ sub-queues at time slot $t$ is defined as the workload on the server:

[TABLE]

A load balancing algorithm consists of two parts, routing and scheduling. The routing policy determines the queue at which an incoming task is stored until it is assigned to a server for service. When a server becomes idle, the scheduling policy determines the next task that receives service on the idle server. The routing and scheduling policies of the GB-PANDAS algorithm are as follows:

GB-PANDAS Routing Policy: An incoming task of type $i$ is routed to the corresponding sub-queue of the server with the minimum weighted workload, where ties are broken arbitrarily to the favor of the fastest server. The server $m^{*}$ with the minimum weighted workload is defined as

[TABLE]

The corresponding sub-queue of server $m^{*}$ for a task of type $i$ is $n$ if $\mu_{i,m}=\alpha_{m}^{n}$.

GB-PANDAS Scheduling Policy: An idle server $m$ at time slot $t$ is scheduled to process a task of sub-queue $Q_{m}^{1}$ if there is any. If $Q_{m}^{1}(t)=0,$ a task of sub-queue $Q_{m}^{2}$ is scheduled to the server, and so on. It is a common assumption that servers do not have the option of processing the tasks queued in front of other servers, so a server remains idle if all its sub-queues are empty. Note that the routing policy is doing a sort of weighted water-filling for workloads, so the probability that a server becomes idle goes to zero as the load increases at heavy traffic regime. Remember that the tasks in sub-queue $Q_{m}^{1}$ are the fastest types of tasks for server $m$, the tasks in sub-queue $Q_{m}^{2}$ are the second fastest, and so on. Using this priority scheduling, the faster tasks in the $N^{m}$ sub-queues of server $m$ are processed first. Given the minimum weighted workload routing policy, the priority scheduling is optimal as it minimizes the mean task completion time of all tasks in the $N^{m}$ sub-queues of server $m$. In the following, Max-Weight and c$\mu$-rule algorithms are discussed for the sake of completeness.

Remark. Prioritized scheduling has no effect in the throughput-optimality proof of the GB-PANDAS algorithm and a work conservative scheduling of a server to its sub-queues suffices for the purpose of system’s stability. As a result, the GB-PANDAS policy can be implemented by considering a single queue per server at the expense of losing priority scheduling. In a single queue per server structure, instead of maintaining a server’s sub-queue lengths, the workload of the server defined in (2) is maintained. At the arrival of an $n$-local task to server $m$, the server’s workload is increased by $\frac{1}{\alpha_{m}^{n}}$, instead of increasing the corresponding sub-queue’s length by one, and the workload is decreased at the departure of a task by its corresponding load.

2.3 Max-Weight and c-$\mu$-Rule Algorithms with Known Service Rate Matrix $B_{\mu}$

The queueing structure used for Max-Weight and c-$\mu$-rule is as depicted in Figure 1, where there is a separate queue for each type of task. Denote the $N_{T}$ queues by $Q_{1},Q_{2},\cdots,Q_{N_{T}}$, and their corresponding queue lengths at time slot $t$ by $Q_{1}(t),Q_{2}(t),\cdots,Q_{N_{T}}(t)$. Note that the GB-PANDAS algorithm requires $M\times N_{T}$ number of queues in the worst case scenario, but it can use the symmetry of specific real-world structures to decrease the number of queues dramatically. As an example, for servers with rack structures, where Hadoop is used for map-reduce data placement with three replicas of data chunks on severs, Max-Weight and c-$\mu$-rule require ${M\choose 3}=O(M^{3})$ number of queues, while GB-PANDAS requires $3M$ queues. A task is routed to a server at the time of its arrival under the GB-PANDAS algorithm, while a task waits in its queue under both Max-Weight and c-$\mu$-rule algorithms, waiting to be scheduled for service, which is discussed below.

Max-Weight Scheduling Policy: An idle server $m$ at time slot $t$ is scheduled to process a task of type $j$ from $Q_{j}$, if there is any, such that

[TABLE]

The Max-Weight algorithm is throughput-optimal, but it is not heavy-traffic or delay optimal [8].

C-$\mu$-rule Scheduling Policy: Consider that queue $Q_{i}$ incurs a cost of C_{i}\big{(}Q_{i}(t)\big{)} at time slot $t$, where $C_{i}(.)$ is increasing and strictly convex. The c-$\mu$-rule algorithm maximizes the rate of decrease of the instantaneous cost at all time slots by the following scheduling policy. An idle server $m$ at time slot $t$ is scheduled to process a task of type $j$ from $Q_{j}$, if there is any, such that

[TABLE]

where $C^{\prime}(.)$ is the first derivative of the cost function. The c-$\mu$-rule algorithm minimizes both instantaneous and cumulative queueing costs, asymptotically. The mean task completion time corresponds to linear cost functions for all task types, so c-$\mu$-rule cannot minimize the mean task completion time, and as the result, is not heavy-traffic optimal.

2.4 Capacity Region of Affinity Scheduling Setup

We propose a decomposition of the arrival rate vector $\mathbold{\lambda}=$ $\left(\lambda_{i}:i\in\mathcal{L}\right)$ as follows. For any task type $i\in\mathcal{L},\lambda_{i}$ is decomposed into $\left(\lambda_{i,m},m\in\mathcal{M}\right)$, where $\lambda_{i,m}$ is assumed to be the arrival rate of type $i$ tasks for server $m$. Hence, $\lambda_{i}=\sum_{m=1}^{M}\lambda_{i,m}$. By using the fluid model planning algorithm, the affinity queueing system can be stabilized under a given arrival rate vector $\mathbold{\lambda}$ as long as the necessary condition of total $1$-local, $2$-local, …, and $N^{m}$-local load on server $m$ being strictly less than one for any server $m$ is satisfied:

[TABLE]

Hence, the capacity region of the affinity problem is the set of all arrival rate vectors $\mathbold{\lambda}$ that has a decomposition $(\lambda_{i,m},i\in\mathcal{L},m\in\mathcal{M})$ satisfying (3):

[TABLE]

The linear programming optimization associated with Equation (LABEL:capacityregion) can be solved to find the capacity region $\Lambda$ of the system. The GB-PANDAS algorithm stabilizes the system for any arrival rate vector inside the capacity region by knowing the service rate matrix. It is proved in Section 4 that the Blind GB-PANDAS algorithm is throughput-optimal without the knowledge of the service rate matrix, $B_{\mu}$.

3 The Blind GB-PANDAS Algorithm

The GB-PANDAS and Max-Weight algorithms need to know the precise value of the service rate matrix, but this requirement is not realistic for real applications. Furthermore, the service rate matrix can change over time, which confuses the load balancing algorithm if it uses a fixed given service rate matrix. In the Blind version of GB-PANDAS, the service rate matrix is initiated randomly and is updated as the system is running. More specifically, an exploration-exploitation framework is combined with GB-PANDAS. In the exploration phase, the routing and scheduling are performed so as to allow room for making the estimations of the system parameters more precise, and in the exploitation phase the routing and scheduling are done based on the available estimation of the service rate matrix so as to stabilize the system. Here we assume that $N^{m}$ is known as well as the locality level of a task on servers that can be inferred from prior knowledge on the structure of the system. This is not a necessary assumption for throughput-optimality proof, but it makes the intuition behind Blind GB-PANDAS more clear. As mentioned before, a single queue per server can be used when using Blind GB-PANDAS, in which case, there is no need to know $N^{m}$ as well as the ordering of service rates offered by servers for different task types.

We first propose the updating method used for the service rate matrix before getting into the routing and scheduling policies of the Blind GB-PANDAS algorithm. The estimated service rate matrix at time slot $t$ is denoted as

[TABLE]

Note that $\widetilde{\alpha}_{m}^{1}(t),\widetilde{\alpha}_{m}^{2}(t),\cdots,\widetilde{\alpha}_{m}^{N^{m}}(t),\ \forall m\in\mathcal{M}$ which are the estimates of $\alpha_{m}^{1}(t),\alpha_{m}^{2}(t),\cdots,\alpha_{m}^{N^{m}}(t),\ \forall m\in\mathcal{M}$ at time slot $t$ are nothing but the distinct values of the elements of the service rate matrix. More specifically, those are the $\widetilde{\alpha}_{m}^{n},\ \forall m\in\mathcal{M},\ \forall n\in\{1,2,\cdots,$ $N^{m}\}$ that are getting updated and then mapped into their corresponding elements in the service rate matrix to form $\widetilde{B}_{\mu}$ in (5) as mentioned in Section 2.1. Consider a random initialization of $\widetilde{\alpha}_{m}^{n}(0)>0,\ \forall m\in\mathcal{M},\ \forall n\in\{1,2,\cdots,N^{m}\}$ at time slot $t=0$. If server $m$ has processed $\widetilde{n}-1$ tasks that are $n$-local to this server by time $t_{1}$, the estimate of $\alpha_{m}^{n}$ at this time slot is $\widetilde{\alpha}_{m}^{n}(t_{1})$, and a new observation of service time for $n$-local task to server $m$ is made at time slot $t_{2}>t_{1}$ as $T_{m}^{n}(t_{2})$, we have $\widetilde{\alpha}_{m}^{n}(t)=\widetilde{\alpha}_{m}^{n}(t_{1})$ for $t_{1}\leq t<t_{2}$ and the update of this parameter at time slot $t_{2}$ is

[TABLE]

Note that $\widetilde{\alpha}_{m}^{n}$ is the service rate, not the service time mean, that is why $\frac{1}{T_{m}^{n}(t_{2})}$ is used above in the update of the service rate. In the following, the routing and scheduling policies of Blind GB-PANDAS are presented, where the exploration rate is chosen in such a way that infinitely many $n$-local tasks are scheduled for service on server $m$ for any $m\in\mathcal{M}$ and any $n\in\{1,2,\cdots,N^{m}\}$ so that by using the strong law of large numbers, the parameter estimations in (6) converge to their real values almost surely.

Blind GB-PANDAS Routing Policy: The estimated workload on server $m$ at time slot $t$ is defined based on parameter estimations in (6) as

[TABLE]

The routing of an incoming task is based on the following exploitation policy with probability $p_{e}=max(1-p(t),0)$, and is based on the exploration policy otherwise, where $p(t)\rightarrow 0$ as $t\rightarrow\infty$ and $\sum_{t=0}^{\infty}p(t)=\infty$, e.g. the exploitation probability can be chosen as $p_{e}=1-\frac{1}{t^{c}}$ for $0<c\leq 1.$

• •

Exploitation phase: An incoming task of type $i$ is routed to the corresponding sub-queue of the server with the minimum estimated weighted workload, where ties are broken arbitrarily. The server $\widetilde{m}^{*}$ with the minimum weighted workload for task of type $i$ is defined as

[TABLE]

The corresponding sub-queue of server $\widetilde{m}^{*}$ for a task of type $i$ is $n$ if $\widetilde{\mu}_{i,\widetilde{m}^{*}}=\widetilde{\alpha}_{\widetilde{m}^{*}}^{n}$.

• •

Exploration phase: An incoming task of type $i$ is routed to the corresponding sub-queue of a server chosen uniformly at random among $\{1,2,\cdots,M\}$.

Blind GB-PANDAS Scheduling Policy: The scheduling of an idle server is based on the following exploitation policy with probability $p_{e}$, and is based on the exploration policy otherwise.

• •

Exploitation phase: Priority scheduling is performed for an idle server as discussed in Section 2.2. We emphasize that given the routing policy, priority scheduling is the optimal scheduling policy in terms of minimizing the average completion time of tasks.

• •

Exploration phase: An idle server is scheduled to one of its non-empty sub-queues uniformly at random, and stays idle if all its sub-queues are empty.

Since the arrival rate of any task type is strictly positive, infinitely many of each task type arrives to system, and given the fact that the probability of exploration in both routing and scheduling policies decays such that $\sum_{t=0}^{\infty}p(t)=\infty$, using the second Borel-Cantelli lemma (zero-one law), it is obvious that $n$-local tasks to server $m$ are scheduled to this server for infinitely many times for any locality level and any server, so $\widetilde{B}_{\mu}(t)\rightarrow B_{\mu}$ as $t\rightarrow\infty$ using the updates in (6).

Remark. There has been a debate in the queueing community whether the exploration phase in a load balancing algorithm is required to stabilize a queueing system with unknown processing rates or the processing rates are learnt through a natural learning phenomena; and as a result, no exploration is needed. We provide an example in Figure 3 that shows no exploration can not only increase the mean task completion time, but it can also make the system unstable when the arrival rates are inside the capacity region of the queueing system. Consider a queueing system as depicted on the left-hand-side of Figure 3, where the processing times of any tasks on any servers are deterministic with the given rates and the arrival process of tasks is deterministic as well with the rates shown in the figure. It is obvious that the optimum load balancing is to process task type 1 on server 1 and task type 2 on server 2. However, if the processing rates are initialized as in the middle queueing system of Figure 3, for any $\lambda_{1}\leq 0.5$ and $\lambda_{2}\leq 0.5$, task type 1 is processed by server 2 and task type 2 is processed by server 1 under the GB-PANDAS and MaxWeight algorithms, resulting in a mean task completion time that is two times the optimum value. On the other hand, if the processing rates are initialized as in the right-hand-side queueing system of Figure 3, for any $0.5<\lambda_{1}\leq 1$ and $0.5<\lambda_{2}\leq 1$, the system is unstable under the GB-PANDAS and MaxWeight algorithms, while such processing rates are inside the capacity region of the queueing system. As a result, exploration is required in the load balancing algorithm in general for a queueing system with unknown processing rates. Using the intuition of the given example, it is a promising future work to find conditions for which exploration is not required for the purpose of delay optimality and/or stability.

3.1 Queue Dynamics under the Blind GB-PANDAS Algorithm

Denote the queue length vector at time slot $t$ by \mathbold{Q}(t)=\big{(}Q_{1}^{1}(t), Q_{1}^{2}(t),\cdots,Q_{1}^{N^{1}}(t),\cdots,Q_{M}^{N^{M}}(t)\big{)}. Let the number of incoming tasks of type $i$ that are routed to their corresponding sub-queue of server $m$ at the beginning of time slot $t$ be denoted as $A_{i,m}(t)$. Then, by denoting the number of incoming $n$-local tasks to server $m$ that are routed to $Q_{m}^{n}$ at the beginning of time slot $t$ by $A_{m}^{n}(t)$, we have:

[TABLE]

Denote the set of working status of servers by vector $\mathbold{f}(t)=$ \big{(}f_{1}(t), $f_{2}(t),$ $\cdots,$ f_{M}(t)\big{)}, where

[TABLE]

If server $m$ finishes processing a task at the end of time slot $t-1$, i.e. $f_{m}(t^{-})=-1$, a scheduling decision is taken for time $t$ based on $\mathbold{Q}(t)$ and $\mathbold{f}(t)$. Denote the scheduling decision for server $m$ at time slot $t$ by $\eta_{m}(t)$ that is defined as follows. For all busy servers, $\eta_{m}(t)=f_{m}(t)$, and when $f_{m}(t^{-})=-1$, i.e. server $m$ is idle, $\eta_{m}(t)$ is determined by the scheduler according to the Blind GB-PANDAS algorithm. Let \mathbold{\eta}(t)=\big{(}\eta_{1}(t), \eta_{2}(t),\cdots,\eta_{M}(t)\big{)}.

Let $S_{m}^{n}(t)$ denote the $n$-local service provided by server $m$, where such a service has the rate of $\alpha_{m}^{n}$ if $\eta_{m}(t)=n$ for $1\leq n\leq N^{m}$, and the rate is zero otherwise. Then, the queue dynamics for any $m\in\mathcal{M}$ is as follows:

[TABLE]

where U_{m}(t)=\max\big{\{}0,S_{m}^{N^{m}}(t)-A_{m}^{N^{m}}(t)-Q_{m}^{N^{m}}(t)\big{\}} is the unused service offered by server $m$ at time slot $t$.

Note that \big{\{}\mathbold{Q}(t), t\geq 0\big{\}} does not necessarily form a Markov chain, i.e. $\mathbold{Q}(t+1)|\mathbold{Q}(t)\not\perp\mathbold{Q}(t-1)$, since nothing can be said about locality of an in-service task at a server by just knowing the queue lengths. Even \big{\{}\left(\mathbold{Q}(t),\mathbold{\eta}(t)\right), t\geq 0\big{\}} is not a Markov chain since the service time distributions do not necessarily have the memory-less property. In order to use Foster-Lyapunov theorem for proving the positive recurrence of a Markov chain, we need to consider another measurement of the status of servers as follows.

• •

Let $\Psi_{m}(t)$ denote the number of time slots at the beginning of time slot $t$ that server $m$ has been allocated on the current in-service task on server $m$. This parameter is set to zero when server $m$ finishes processing a task. Let \mathbold{\Psi}(t)=\big{(}\Psi_{1}(t),\Psi_{2}(t),\cdots,\Psi_{M}(t)\big{)}.

Lemma 1

\big{\{}\mathbold{Z}(t)=\big{(}\mathbold{Q}(t),\mathbold{\eta}(t),\mathbold{\Psi}(t)\big{)},t\geq 0\big{\}}* forms an irreducible and aperiodic Markov chain. The state space of this Markov chain is \mathcal{S}=\big{(}\prod_{m\in\mathcal{M}}\mathbb{N}^{N^{m}}\big{)}\times\big{(}\prod_{m\in\mathcal{M}}\{1,2, $\cdots,$ N^{m}\}\big{)}\times\mathbb{N}^{M}.*

4 Throughput Optimality of the Blind GB-PANDAS Algorithm

Section 4.1 provides preliminaries on the workload dynamic of servers, the ideal workload on servers, some lemmas, and an extended version of the Foster-Lyapunov. The throughput-optimality theorem of the Blind GB-PANDAS algorithm and its proof are presented in Section 4.2, where the proof is followed by using Lemmas 2, 3, 4, 5, and 6.

4.1 Preliminary Materials and Lemmas

The workload on server $m$ evolves as follows:

[TABLE]

where $(a)$ is true by using the queue dynamics in (LABEL:queueevolution) and $(b)$ follows from defining the pseudo task arrival, service, and unused services of server $m$ as

[TABLE]

By defining the pseudo task arrival, service, and unused service processes as \mathbold{A}(t)=\big{(}A_{1}(t),A_{2}(t),\cdots,A_{M}(t)\big{)}, \mathbold{S}(t)=\big{(}S_{1}(t),S_{2}(t), \cdots,S_{M}(t)\big{)}, and $\widetilde{\mathbold{U}}(t)=$ \big{(}\widetilde{U}_{1}(t),\widetilde{U}_{2}(t), $\cdots,$ \widetilde{U}_{M}(t)\big{)}, respectively, the vector of servers’ workloads defined by $\mathbold{W}=(W_{1},W_{2},\cdots,W_{M})$ evolves as

[TABLE]

Lemma 2

For any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, there exists a load decomposition $\{\lambda_{i,m}\}$ and $\delta>0$ such that

[TABLE]

The fluid model planning algorithm solves a linear programming to find the load decomposition $\{\lambda_{i,m}\}$ that is used in its load balancing on the $M$ servers. In other words, this load decomposition is a possibility of task assignment on servers to stabilize the system.

Lemma 2 is used in the proof of Lemma 5.

Definition 2

The ideal workload on server $m$ corresponding to the load decomposition $\{\lambda_{i,m}\}$ of Lemma 2 is defined as

[TABLE]

Let $\mathbold{w}=(w_{1},w_{2},\cdots,w_{M})$. The vector of servers’ ideal workload is used as an intermediary term in Lemmas 4 and 5 which are later used for throughput optimality proof of the Blind GB-PANDAS algorithm.

Lemma 3

[TABLE]

The following lemma states that the sum over a time period of the inner product of the workload and the pseudo arrival rate is dominated on an expectation sense by the inner product of the workload and the ideal workload plus constants depending on the initial state of the system.

Lemma 4

Under the exploration-exploitation routing policy of the Blind GB-PANDAS algorithm, for any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, and the corresponding ideal workload vector $\mathbold{w}$ defined in (13), and for any arbitrary small $\theta_{0}>0$, there exists $T_{0}>t_{0}$ such that for any $t_{0}\geq 0$ and $T>T_{0}$:

[TABLE]

where the constants $\theta_{0},c_{0}>0$ are independent of $\mathbold{Z}(t_{0})$.

We emphasize that $\theta_{0}$ in Lemma 4 can be made arbitrarily small, as can be seen in the proof, which is used in the throughput optimality proof of Blind GB-PANDAS, Theorem 1. Throughout this paper, $\|.\|$ and $\|.\|_{1}$ are the $L^{2}$-norm and $L^{1}$-norm, respectively.

The following lemma is the counterpart of Lemma 4 for the pseudo service process.

Lemma 5

Under the exploration-exploitation scheduling policy of the Blind GB-PANDAS algorithm, for any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, and the corresponding ideal workload vector $\mathbold{w}$ in (13), there exists $T_{1}>0$ such that for any $T>T_{1}$, we have:

[TABLE]

where the constants $\theta_{1},c_{1}>0$ are independent of $\mathbold{Z}(t_{0})$.

Lemma 6

Under the exploration-exploitation load balancing of the Blind GB-PANDAS algorithm, for any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, and for any $\theta_{2}>0$, there exists $T_{2}>0$ such that for any $T>T_{2}$ and for any $t_{0}\geq 0$, we have:

[TABLE]

Theorem 3.3.8 in [13], an extended version of the Foster-Lyapunov theorem: Consider an irreducible Markov chain $\{\mathbold{Z}(t)\}$, where $t\in\mathbb{N}$, with a state space $\mathcal{S}$. If there exists a function $V:\mathcal{S}\rightarrow\mathcal{R}^{+}$, a positive integer $T\geq 1$, and a finite set $\mathcal{P}\subseteq\mathcal{S}$ satisfying the following condition:

[TABLE]

for some $\theta>0$ and $C<\infty$, then the irreducible Markov chain $\{\mathbold{Z}(t)\}$ is positive recurrent.

4.2 Throughput Optimality Theorem and Proof

Theorem 1

The Blind GB-PANDAS algorithm is throughput-optimal for a system with affinity setup discussed in Section 2, with general service time distributions with finite means and supports, without prior knowledge on the service rate matrix $B_{\mu}$ and the arrival rate vector $\mathbold{\lambda}$.

Proof: We use the Foster-Lyapunov theorem for proving that the irreducible and aperiodic Markov chain \big{\{}\mathbold{Z}(t)=\big{(}\mathbold{Q}(t),\mathbold{\eta}(t),\mathbold{\Psi}(t)\big{)}, t\geq 0\big{\}} (Lemma 1) is positive recurrent under the Blind GB-PANDAS algorithm, as far as the arrival rate vector is inside the capacity region, $\mathbold{\lambda}\in\Lambda$. This means that as time goes to infinity, the distribution of $\mathbold{Z}(t)$ converges to its stationary distribution, which implies that the system is stable and Blind GB-PANDAS is throughput-optimal. To this end, we choose the following Lyapunov function $V:\mathcal{S}\rightarrow\mathcal{R}^{+}$ and use Lemmas 2, 3, 4, 5, and 6 to derive its drift afterward:

[TABLE]

By choosing $\theta_{0}$ in Lemma 4 less than $\theta_{1}$ in Lemma 5, $\theta_{0}<\theta_{1}$, we get $T_{0}$ from Lemma 4, which is used in the drift of the Lyapunov function in Lemma 7.

Lemma 7

For any $t_{0}\leq T_{0}<T$, specifically $T_{0}$ from Lemma 4 that is dictated by choosing $\theta_{0}<\theta_{1}$, we have the following for the drift of the Lyapunov function in (16), where $T_{0}$ is used in the first summation after the inequality:

[TABLE]

By choosing $T>\max\{T_{0},T_{1},T_{2},\frac{\theta_{2}+c_{2}}{2(\theta_{1}-\theta_{0})}\}$, where $\theta_{2}>0$ is the one in Lemma 6, and substituting the terms on the right-hand side of the Lyapunov function drift (17) in Lemma 7 from the corresponding inequalities in Lemmas 4, 5, and 6, we have:

[TABLE]

where $c=2c_{0}+2c_{1}+c_{3}+MT$.

Let \mathcal{P}=\big{\{}\mathbold{Z}=\big{(}\mathbold{Q},\mathbold{\eta},\mathbold{\Psi}\big{)}\in\mathcal{S}:\|\mathbold{Q}\|_{1}+\|\mathbold{\Psi}\|_{1}\leq\frac{\bar{c}+c}{\theta_{2}}\big{\}} for any positive constant $\bar{c}>0$, where $\mathcal{P}$ is a finite set of the state space $\mathcal{S}$. By this choice of $\mathcal{P}$ for the Lyapunov function $V(.)$ defined in (16), all the conditions of the Foster-Lyapunov theorem are satisfied, which completes the throughput optimality proof for the Blind GB-PANDAS algorithm.

Note that the priority scheduling in the exploitation phase of the Blind GB-PANDAS algorithm is not used for the throughput optimality proof since the expected workload of a server is decreased in the same rate no matter what locality level is receiving service from the server. As long as an idle server gives service to one of the tasks in its sub-queues continuously, the system is stable. Given the routing policy, the priority scheduling is used in the exploitation phase to minimize the mean task completion time.

5 Simulation Results

In this section, the simulated performance of the Blind GB-PANDAS algorithm is compared with FCFS, Max-Weight, and c-$\mu$-rule algorithms. FCFS does not use system parameters for load balancing, but Max-Weight and c-$\mu$-rule use the same exploration-exploitation approach as Blind GB-PANDAS. Convex cost functions $C_{i}(Q_{i})=Q_{i}^{1.01}$ for $i\in\{1,2,3\}$ are used for the c-$\mu$-rule algorithm. Since the objective is to minimize the mean task completion time, the convexity of the cost functions are chosen in a way to be close to a line for small values of $Q_{i}$. Three types of tasks and a computing cluster of three servers are considered with processing rates depicted in Figure 4, which are not known from the perspective of the load balancing algorithms. The task arrivals are Poisson processes with the unknown rates determined in Figure 4 and the processing times are log-normal that are heavy-tailed and do not have the memory-less property. Note that this affinity structure does not have the rack structure mentioned in [6] since from the processing rates of task type $2$ on the three servers, servers $1$ and $2$ are in the same rack as server $3$, but from the processing rates of task type $3$ on the three servers, the second server is in the same rack as the third server, but not the first server. Hence, this affinity setup is more complicated than the one with a rack structure.

Inspired by the fluid model planning algorithm, the following linear programming optimization should be solved to find the capacity region of the simulated system.

[TABLE]

The capacity region in terms of $\lambda$ is found to be $\lambda\in[0,2.5)$. Figure 5 compares the throughput performance of the four algorithms, where the mean task completion time versus the total task arrival rate, $\lambda=\sum_{i=1}^{3}\lambda_{i}$, is plotted. The Blind GB-PANDAS, Max-Weight, and c-$\mu$-rule algorithms are throughput-optimal by stabilizing the system for $\lambda<2.5$. Taking a closer look at the performance of these algorithms at high loads, Blind GB-PANDAS has a much lower mean task completion time compared to Max-Weight and c-$\mu$-rule algorithms as depicted in Figure 6.

6 Related Work

In addition to the fluid model planning, Max-Weight, and c-$\mu$-rule algorithms for the affinity scheduling problem that are discussed in Section 1 and Section 2.3, there is a huge body of work on heuristic algorithms that are used for scheduling for data centers with multiple levels of data locality, e.g. [14, 15, 16], and look at the references in [11]. Although some of these heuristic algorithms are being used in real applications, simple facts about their optimality are not investigated. Recent works including the priority algorithm [17], Join-the-Shortest-Queue-Max-Weight (JSQ-MW) [10] and Weighted-Workload algorithm [6] study the capacity region and throughput optimality for a system with two and three levels of data locality. Some robust policies are studied in [18, 19, 20, 21, 22].

A related direction of work on scheduling for data centers with multi-level data locality, which is a direct application of affinity scheduling, is to efficiently do data replication on servers in MapReduce framework to increase availability. Increasing the availability is translated to increasing service rates in the context of this article which enlarges the capacity region and reduces the mean task completion time. For more information on data replication algorithms refer to Google File System [23], Hadoop Distributed File System [14], Scarlett [24], and Dare [25]. Data replication algorithms are complementary and orthogonal to throughput and delay optimality that is studied in this article.

Fairness is an issue in most scheduling problems which conflicts with delay optimality. A delay optimal load balancing algorithm can cooperate with fair scheduling strategies though by compromising on delay optimality to partly achieve fairness. Refer to Delay Scheduling [16], Quibcy [15], and the references therein for more details.

7 Conclusion and Future Work

The Blind GB-PANDAS algorithm is proposed for the affinity load balancing problem where no knowledge of the task arrival rates and the service rate matrix is available. An exploration-exploitation approach is proposed for load balancing which consists of exploration and exploitation phases. The system is proven to be stable under Blind GB-PANDAS and is shown empirically through simulations to have a better delay performance than Max-Weight, c-$\mu$-rule, and FCFS algorithms. Investigating the subspace of the capacity region in which GB-PANDAS is delay optimal is a promising direction for future work. Note that both GB-PANDAS and Max-Weight algorithms have high routing and scheduling computation complexity which can be alleviated using power-of-d-choices [26] or join-idle-queue [27] algorithms which are interesting directions to study as well. Another interesting future work is to consider a case where there are precedence relations between several tasks of a job, i.e. a departing task may join another queue.

.1 Proof of Lemma 1

Lemma 1: \big{\{}\mathbold{Z}(t)=\big{(}\mathbold{Q}(t),\mathbold{\eta}(t),\mathbold{\Psi}(t)\big{)},t\geq 0\big{\}} forms an irreducible and aperiodic Markov chain. The state space of this Markov chain is \mathcal{S}=\big{(}\prod_{m\in\mathcal{M}}\mathbb{N}^{N^{m}}\big{)}\times\big{(}\prod_{m\in\mathcal{M}}\{1,2, $\cdots,$ N^{m}\}\big{)}\times\mathbb{N}^{M}.

Proof: Consider \mathbold{Z}(0)=\big{\{}0_{(\sum_{m\in\mathcal{M}}N^{m})\times 1},\prod_{m\in\mathcal{M}}N^{m}, 0_{M\times 1}\big{\}} as the initial state of the Markov chain $\mathbold{Z}(t)$.

Irreducible: Since $F_{i,m}$ is increasing for any task-server pair, we can find an integer $\tau>0$ such that $F_{i,m}(\tau)>0$ for any $1\leq i\leq N^{m}$ and $m\in\mathcal{M}$. Furthermore, probability of zero task arrival is positive in each time slot. Hence, for any state $\mathbold{Z}=(\mathbold{Q},\mathbold{\eta},\mathbold{\Psi})$, there is a positive probability that each task receives service in $\tau$ time slots and no new task arrives at the system in $\tau\sum_{m\in\mathcal{M}}\sum_{n=1}^{N^{m}}Q_{m}^{n}$ time slots. Accordingly, the initial state of the Markov chain is reachable from any states of the system. Conversely, using the same approach, it is easy to see that any states of the system is reachable from the initial state, $\mathbold{Z}(0)$. Consequently, the Markov chain $\mathbold{Z}(t)$ is irreducible.

Aperiodic: Since Markov chain $\mathbold{Z}(t)$ is irreducible, in order to show that it is also aperiodic, it suffices to show that there is a positive probability for transition from a state to itself. Due to the fact that there is a positive probability that zero task arrives to the system, the Markov chain stays at the initial state with a positive probability. Hence, the Markov chain $\mathbold{Z}(t)$ is aperiodic.

.2 Proof of Lemma 2

Lemma 2: For any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, there exists a load decomposition $\{\lambda_{i,m}\}$ and $\delta>0$ such that

[TABLE]

Proof: The capacity region $\Lambda$ is an open set, so for any $\mathbold{\lambda}\in\Lambda$, there exists $\delta>0$ such that $(1+\delta)\mathbold{\lambda}=\mathbold{\lambda}^{\prime}\in\Lambda$. On that account, (LABEL:capacityregion) follows by $\sum_{i\in\mathcal{L}}\frac{\lambda_{i,m}^{\prime}}{\mu_{i,m}}=\sum_{i\in\mathcal{L}}\frac{(1+\delta)\lambda_{i,m}}{\mu_{i,m}}<1,\forall m\in\mathcal{M}$, which completes the proof:

[TABLE]

.3 Proof of Lemma 3

Lemma 3:

[TABLE]

Proof:

[TABLE]

If the unused service for server $m$ is zero, $U_{m}(t)=0$, the corresponding term for server $m$ is zero in the above summation. Alternatively, the unused service of server $m$ is positive if and only if all $N^{m}$ sub-queues of the server are empty, which again makes the corresponding term for server $m$ in the above summation equal to zero.

.4 Proof of Lemma 4

Lemma 4: Under the exploration-exploitation routing policy of the Blind GB-PANDAS algorithm, for any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, and the corresponding ideal workload vector $\mathbold{w}$ defined in (13), and for any arbitrary small $\theta_{0}>0$, there exists $T_{0}>t_{0}$ such that for any $t_{0}\geq 0$ and $T>T_{0}$:

[TABLE]

where the constants $\theta_{0},c_{0}>0$ are independent of $\mathbold{Z}(t_{0})$.

Proof: By the choice of exploration rate for Blind GB-PANDAS, which is independent of the system state, and the fact that exploration exists in both routing and scheduling, any task that is $n$-local to server $m$ is scheduled on this server for infinitely many times in the interval $[t_{0},\infty)$ only due to exploration, regardless of the initial system state. Processing time of an $n$-local task on server $m$ has a finite mean. Hence, due to strong law of large numbers, using the update rule (6) for the elements of the service rate matrix, we have:

[TABLE]

By the above choice of $\epsilon$, for $t>T_{0}^{\prime}$, the different locality levels are distinct from each other with at least $1-\delta^{\prime}$ probability. Let $E$ be the event that \big{|}\widetilde{\alpha}_{m}^{n}(t)-\alpha_{m}^{n}\big{|}<\epsilon and $\ 1-\epsilon<\frac{\alpha_{m}^{n}}{\widetilde{\alpha}_{m}^{n}(t)}<1+\epsilon$ for $t\geq T_{0}^{\prime}$.

For an incoming task of type $i\in\mathcal{L}$ at time slot $t$, define the exact (but not known) and estimated minimum weighted workloads as

[TABLE]

where $W_{m}(t)$ and $\widetilde{W}_{m}(t)$ are defined in (2) and (7), respectively. $W_{m}(t)$ and $\widetilde{W}_{m}(t)$ are related to each other as follows:

[TABLE]

hence, using (LABEL:epsilonchoice), for any $t>T_{0}^{\prime}$ and any $m\in\mathcal{M}$, we have

[TABLE]

and using (LABEL:WWW) and (20), we have

[TABLE]

Using the conditional independence of $\widetilde{\mathbold{W}}(t)$ and $\mathbold{A}(t)$ from $\mathbold{Z}(t_{0})$ given $\mathbold{Z}(t)$, for any $T>T_{0}^{\prime}-t_{0}$, we have the following for $T_{0}^{\prime}\leq t\leq t_{0}+T-1$:

[TABLE]

[TABLE]

where $(a)$ and $(b)$ are simply followed by the definitions of pseudo task arrival process in (10) and $A_{m}^{n}(t)$ in (8), respectively. The order of summations is changed in $(c)$. By the law of total probability, (LABEL:epsilonchoice), and (20), $(d)$ is true, and $(e)$ follows by the routing policy of Blind GB-PANDAS, where an incoming task at the beginning of time slot $t$ is routed to the corresponding sub-queue of the server with the minimum estimated weighted workload with probability $p_{e}=\max(1-p(t),0)$ and is routed to the corresponding sub-queue of a server chosen uniformly at random with probability $1-p_{e}$. Also note that the number of arriving tasks at a time slot is assumed to be upper bounded by $C_{A}$. The last step, $(f)$, is true by using (LABEL:epsilonchoice), upper bounding the exploration probability $1-p_{e}$ by $\frac{1}{t^{\delta^{\prime\prime}}}$ given that $\delta^{\prime\prime}>0$ is a constant, and doing simple calculations, where $c_{0}^{\prime\prime}$ and $c_{0}^{\prime}$ are constants independent of $\mathbold{Z}(t_{0})$. Note that minimum value of the estimated service rates, $\min_{i,m}\{\widetilde{\mu}_{i,m}(t)\}$, is lower bounded for any $t\geq t_{0}$ by a constant which is the minimum of the initialization of service rates and the inverse of the maximum support of CDF functions $F_{i,m}$. We also have

[TABLE]

where $(a)$ is true by the definition of the ideal workload on a server in (13), note that the ideal workload is not state dependent but $W_{m}(t)$ is, the order of summations is changed in $(b)$, and $(c)$ is followed by the law of total probability, ignoring the second term, and Equation (21).

Putting (22) and (23) together, for $T>T_{0}>T_{0}^{\prime}$, we have

[TABLE]

[TABLE]

where $(a)$ follows by upper bounding $1-\epsilon$, $\frac{1}{(1-\epsilon)^{2}(1+\epsilon)^{2}}$, and $\frac{1}{t^{\delta^{\prime\prime}}}$ by $1$, $\frac{16}{9}$, and $\frac{1}{T_{0}^{\delta^{\prime\prime}}}$, respectively, and $(b)$ is true by the fact that the number of arriving tasks is bounded by $C_{A}$, the number of task types is $N_{T}$, and the maximum arrival rate of task types, $\max_{i}\{\lambda_{i}\}$, is bounded by the number of servers. Inequality $(c)$ is true by doing simple calculations and using the fact that $\min_{i,m}\{\widetilde{\mu}_{i,m}(t)\}$ is lower bounded by a constant for any $t\geq t_{0}$ as discussed in $(f)$ of (22).

Remark. $\theta_{0}$ can be made arbitrary small by choosing $\epsilon$ and $\delta^{\prime}$ small and $T_{0}$ large enough.

.5 Proof of Lemma 5

Lemma 5: Under the exploration-exploitation scheduling policy of the Blind GB-PANDAS algorithm, for any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, and the corresponding ideal workload vector $\mathbold{w}$ in (13), there exists $T_{1}>0$ such that for any $T>T_{1}$, we have:

[TABLE]

where the constants $\theta_{1},c_{1}>0$ are independent of $\mathbold{Z}(t_{0})$.

Proof: The proof is similar to the proof of lemma 4 in [11] and is presented for the sake of completeness. By the assumption on boundedness of arrival and service processes, there exists a constant $C_{A}$ such that for any $t_{0},t,$ and $T$ with $t_{0}\leq t\leq t_{0}+T$, we have the following for all $m\in\mathcal{M}$:

[TABLE]

On the other hand, by Lemma 2, the ideal workload on a server defined in (13) can be bounded as follows:

[TABLE]

Hence,

[TABLE]

[TABLE]

where $(a)$ is true by bringing the inner summation on $m$ out of the expectation and using the boundedness property of the workload in Equation (24), and $(b)$ is true by Equation (25).

Before investigating the second term on the left-hand side of Equation (14), \mathbb{E}\Big{[} $\sum_{t=t_{0}}^{t_{0}+T-1}$ \Big{(}\langle\mathbold{W}(t),\mathbold{S}(t)\rangle\Big{)} \Big{|}\mathbold{Z}(t_{0})\Big{]}, we propose the following lemma which will be used in lower bounding this second term.

Lemma 8

For any server $m\in\mathcal{M}$ and any $t_{0}$, we have the following:

[TABLE]

We then have the following:

[TABLE]

where $(a)$ follows by bringing the inner summation on $m$ out of the expectation and using the boundedness property of the workload in Equation (24).

Using Lemma 8, for any $0<\epsilon_{0}<\frac{\delta}{1+\delta}$, there exists $T_{1}$ such that for any $T\geq T_{1}$, we have the following for any server $m\in\mathcal{M}$:

[TABLE]

Then continuing on Equation (27), we have the following:

[TABLE]

Then Lemma 5 is concluded as follows by using equations (26) and (28) and picking $c_{1}=\frac{MT^{2}}{\min_{m,n}\{\alpha_{m}^{n}\}}(C_{A}+1+\epsilon_{0})$ and $\theta_{1}=\frac{1}{\max_{m,n}\{\alpha_{m}^{n}\}}\left(\frac{\delta}{1+\delta}-\epsilon_{0}\right)$, where by our choice of $\epsilon_{0}$ we have $\theta_{1}>0$:

[TABLE]

[TABLE]

where $(a)$ is true as $W_{m}(t_{0})\geq\frac{Q_{m}^{1}(t_{0})+Q_{m}^{2}(t_{0})+\cdots+Q_{m}^{N^{m}}(t_{0})}{\max_{m,n}\{\alpha_{m}^{n}\}}$.

.6 Proof of Lemma 6

Lemma 6: Under the exploration-exploitation load balancing of the Blind GB-PANDAS algorithm, for any arrival rate vector inside the capacity region, $\mathbold{\lambda}\in\Lambda$, and for any $\theta_{2}>0$, there exists $T_{2}>0$ such that for any $T>T_{2}$ and for any $t_{0}\geq 0$, we have:

[TABLE]

Proof: This proof is the same as the proof of lemma 5 in [11] and is presented for the sake of completeness. For any server $m\in\mathcal{M}$, let $t_{m}^{*}$ be the first time slot after or at time slot $t_{0}$ at which the server is available; that is,

[TABLE]

where it is obvious that $\Psi_{m}(t_{m}^{*})=0.$ Note that for any $t\geq t_{0}$, we have $\Psi_{m}(t+1)\leq\Psi_{m}(t)+1$, which is true by the definition of $\Psi(t)$ that is the number of time slots that server $m$ has spent on the currently in-service task. From time slot $t$ to $t+1$, if a new task comes in service, then $\Psi_{m}(t+1)=0$ which results in $\Psi_{m}(t+1)\leq\Psi_{m}(t)+1$; otherwise, if server $m$ continues giving service to the same task, then $\Psi_{m}(t+1)=\Psi_{m}(t)+1$. Thus, if $t_{m}^{*}\leq t_{0}+T$, it is easy to find out that $\Psi_{m}(t_{0}+T)\leq t_{0}+T-t_{m}^{*}\leq T$. In the following, we use $t_{m}^{*}$ to find a bound on $\mathbb{E}[\Psi_{m}(t_{0}+T)-\Psi_{m}(t_{0})|\mathbold{Z}(t_{0})]$:

[TABLE]

where $(a)$ is true as given that $t_{m}^{*}\leq t_{0}+T$ we found that $\Psi_{m}(t_{0}+T)\leq T$, so $\Psi_{m}(t_{0}+T)-\Psi_{m}(t_{0})\leq T-\Psi_{m}(t_{0})$, and given that $t_{m}^{*}>t_{0}+T$, it is concluded that server $m$ is giving service to the same task over the whole interval $[t_{0},t_{0}+T]$, which results in $\Psi_{m}(t_{0}+T)-\Psi_{m}(t_{0})=T$.

Since the CDF of service time of an $n$-local task on server $m$ has finite mean, we have the following:

[TABLE]

so for any $\theta_{2}\in(0,1)$ there exists $T_{2}$ such that for any $T\geq T_{2}$, we have P\left(t_{m}^{*}\leq t_{0}+T\Big{|}\mathbold{Z}(t_{0})\right)\geq\theta_{2}, for any $m\in\mathcal{M}$, so Equation (30) follows as below which completes the proof:

[TABLE]

.7 Proof of Lemma 7

Lemma 7: For any $t_{0}\leq T_{0}<T$, specifically $T_{0}$ from lemma 4 that is dictated by choosing $\theta_{0}<\theta_{1}$, we have the following for the drift of the Lyapunov function in (16), where $T_{0}$ is used in the first summation after the inequality:

[TABLE]

Proof:

[TABLE]

where $(a)$ is true by the telescoping series, $(b)$ follows by using (11) to substitute $\mathbold{W}(t+1)$, $(c)$ follows by Lemma 3 and the fact that the task arrival is assumed to be bounded and the service and unused service are also bounded as the number of servers are finite, so the pseudo arrival, service, and unused service are also bounded, and therefore there exists a constant $c_{1}$ such that $\|\mathbold{A}(t)-\mathbold{S}(t)+\widetilde{\mathbold{U}}(t)\|^{2}\leq\frac{c_{3}^{\prime}}{T}$, and $(d)$ follows by adding and subtracting the intermediary term $\langle\mathbold{W}(t),\mathbold{w}\rangle$. On the other hand,

[TABLE]

[TABLE]

where $(a)$ is true by the fact that at most $C_{A}$ tasks arrive at system in each time slot, and by using the definition of pseudo task arrival in (10). Putting (32) and (33) together, Lemma 7 is proved as follows:

[TABLE]

where $c_{3}=c_{3}^{\prime}+c_{3}^{\prime\prime}$.

.8 Proof of Lemma 8

Lemma 8: For any server $m\in\mathcal{M}$ and any $t_{0}$, we have the following:

[TABLE]

Proof: The proof is similar to the proof of lemma 6 in [11] and is presented for the sake of completeness. Let $t_{m}^{*}$ be the first time slot after or at time slot $t_{0}$ at which server $m$ becomes idle, and so is available to serve another task ($t_{m}^{*}$ is also defined in (29)); that is,

[TABLE]

where, as a reminder, $\Psi_{m}(\tau)$ is the number of time slots that the $m$-th server has spent on the task that is receiving service from this server at time slot $\tau$.

Denote the CDF of service time of an $n$-local task on server $m$ by $F_{m}^{n}$ that has finite mean $\alpha_{m}^{n}<\infty$; therefore, $t_{m}^{*}<\infty$. We then have the following by considering the bounded service:

[TABLE]

[TABLE]

where by boundedness of $t_{m}^{*},\alpha_{m}^{1},$ and $\alpha_{m}^{N^{m}}$, it is obvious that $\lim_{T\rightarrow\infty}$ $\frac{-\frac{t_{m}^{*}-t_{0}}{\alpha_{m}^{N^{m}}}+\frac{1}{\alpha_{m}^{1}}}{T}=0$ and $\lim_{T\rightarrow\infty}\frac{\frac{1}{\alpha_{m}^{N^{m}}}}{T}=0$. Hence, by taking the limit of the terms in Equation (35) as $T$ goes to infinity, we have the following:

[TABLE]

Considering the service process as a renewal process, given the scheduling decisions at the end of the renewal intervals in $[t_{m}^{*},t_{m}^{*}+T-1]$, all holding times for server $m$ to give service to tasks in its sub-queues are independent. We elaborate on this in the following.

We define renewal processes, $N_{m}^{n}(t),\ n\in\{1,$ $2,$ $\cdots,$ $N^{m}\}$, as follows, where $t$ is an integer valued number:

Let $H_{m}^{n}(l)$ be the holding time (service time) of the $l$-th task that is $n$-local to server $m$ after time slot $t_{m}^{*}$ receiving service from server $m$, and call $\{H_{m}^{n}(l),l\geq 1\}$ the holding process of $n$-local task type, $n\in\{1,2,\cdots,N^{m}\}$. Then define $J_{m}^{n}(l)=\sum_{i=1}^{l}H_{m}^{n}(l)$ for $l\geq 1$, and let $J_{m}^{n}(0)=0$. In the renewal process, $J_{m}^{n}(l)$ is the $l$-th jumping time, or the time at which the $l$-th occurrence happens, and it has the following relation with the renewal process, $N_{m}^{n}(t)$:

[TABLE]

Another way to define $N_{m}^{n}(t)$ is as shown in the following algorithm, where by convention, $N_{m}^{n}(0)=0$.

Another renewal process, $N_{m}(t)$, is defined as

[TABLE]

Similarly, let $H_{m}(l)$ be the holding time (service time) of the $l$-th task after time slot $t_{m}^{*}$ receiving service from server $m$, and call $\{H_{m}(l),l\geq 1\}$ the holding process. Then define $J_{m}(l)=\sum_{i=1}^{l}H_{m}(l)$ for $l\geq 1$, and let $J_{m}(0)=0$. In the renewal process, $J_{m}(l)$ is the $l$-th jumping time, or the time at which the $l$-th occurrence happens, and it has the following relation with the renewal process, $N_{m}(t)$:

[TABLE]

Note that the central scheduler makes scheduling decisions for server $m$ at time slots $\{t_{m}^{*}+J_{m}(l),l\geq 1\}$. We denote these scheduling decisions by D_{m}(t_{m}^{*})=\Big{(}\eta_{m}(t_{m}^{*}+J_{m}(l)):l\geq 1\Big{)}. Consider the time interval $[t_{m}^{*},t_{m}^{*}+T-1]$ when $T$ goes to infinity. Define $\rho_{m}^{n}$ as the fraction of time that server $m$ is busy giving service to tasks that are $n$-local to this server, in the mentioned interval. Obviously, $\sum_{n=1}^{N^{m}}\rho_{m}^{n}=1$. Then Equation (36) is followed by

[TABLE]

Note that given $\{D_{m}(t_{m}^{*}),\mathbold{Z}(t_{0})\}$, the holding times $\{H_{m}^{n}(l),l\geq 1\}$ are independent and identically distributed with CDF $F_{m}^{n}$. If $\rho_{m}^{n}=0$, then we do not have to worry about those tasks that are $n$-local to server $m$ since they receive service from this server for only a finite number of times in time interval $[t_{m}^{*},t_{m}^{*}+T-1]$ as $T\rightarrow\infty$, so

[TABLE]

But if $\rho_{m}^{n}>0$, we can use the strong law of large numbers for renewal process $N_{m}^{n}$ to conclude the following:

[TABLE]

where the holding time (service time) $H_{m}^{n}(1)$ has CDF $F_{m}^{n}$ with expectation $\frac{1}{\alpha_{m}^{n}}$. Combining equations (37) and (38), Lemma 8 is concluded as follows:

[TABLE]