When Do Redundant Requests Reduce Latency ?

Nihar B. Shah, Kangwook Lee, Kannan Ramchandran

I Introduction

Several systems possess the flexibility to serve requests in more than one way. For instance, in a cluster with $n$ processors, a computation may be performed at any one of the $n$ processors; in a distributed storage system where data is stored using an $(n,k)$ Reed-Solomon code, a read-request may be served by reading data from any $k$ of the $n$ servers; in a network with $n$ available paths from the source to the destination, communication may be performed by transmitting across any one of the $n$ paths. In such settings, the latency of serving the requests can potentially be reduced by sending redundant requests. Under a policy of sending redundant requests, each request is attempted to be served in more than one way. The request is deemed served when it is served in any one of these ways. Following this, the other copies of this request may be removed from the system.

It is unclear whether or not such a policy of having redundant requests will actually reduce the latency. On one hand, for any individual request, one would expect the latency to reduce since the time taken to process the request is the minimum of the processing times of its multiple copies. On the other hand, introducing redundancy in the requests consumes additional resources and increases the overall load on the system, thereby adversely affecting the latency.

Many recent works such as perform empirical studies on the latency performance of sending redundant requests, and report reductions in latency in several scenarios (but increases in some others). However, despite a significant interest among practitioners, to the best of our knowledge, no rigorous analysis is known as to when redundant requests help in reducing latency (and when not). This precisely forms the goal of this work. We consider a model based on the ‘MDS queue’ model , which captures some of the key features of such systems, and can serve as a building block for more complex systems. Under this model, for several classes of distributions of the arrival, service and removal times, we derive the optimal redundant-requesting policies. These results are summarized in Table I. Our proof techniques allow for arbitrary arrival sequences and are not restricted to (asymptotic) steady-state settings.

The remainder of this paper is organized as follows. Section II discusses related literature. Section III presents the system model with a centralized buffer. Section IV presents analytical results for such a centralized setting. Section V describes a distributed setting where each server has its own buffer. Section VI presents analytical results under this distributed setting. Finally, Section VII presents conclusions and discusses open problems. Appendix A presents properties and examples of the heavy-everywhere and light-everywhere distributions defined in the paper. Appendix B contains proofs of all the analytical results.

II Related Literature

Policies that try to reduce latency by sending redundant requests have been previously studied, largely empirically, in . These works evaluate system performance under redundant requests for several applications, and report reduction in the latency in many cases. For instance, Ananthanarayanan et al. consider the setting where requests take the form of computations to be performed at processors. In their setting, requests have diffferent workloads, and the authors propose adding redundancy in the requests with lighter workloads. They observe that on the PlanetLab network, the average completion time of the requests with lighter workloads improves by 47%, at the cost of just 3% extra resources. Huang et al. consider a distributed stoage system where the data is stored using an $(n=16,\ k=12)$ Reed-Solomon code. For $k^{\prime}\in\{12,13,14,15\}$ , they perform the task of decoding the original data by connecting to $k^{\prime}$ of the nodes and decoding from the $k$ pieces of encoded data that arrive first. They empirically observe that the latency reduces upon increase in $k^{\prime}$ . In a related setup, codes and algorithms tailored specifically for employing redundant requests in distributed storage are designed in for latency-sensitive settings, allowing for data stored in a busy or a failed node to be obtained by downloading little chunks of data from other nodes. In particular, these codes provide the ability to connect to more nodes than required and use the data received from the first subset to respond, treating the other slower nodes as erasures. Vulimiri et al. propose sending DNS queries to multiple servers. They observe that on PlanetLab servers, the latency of the DNS queries reduces with an increase in the number of DNS servers queried. Dean and Barroso observe a reduction in latency in Google’s system when requests are sent to two servers instead of one. Liang and Kozat perform experiments on the Amazon EC2 cloud. They observe that when the rate of arrival of the requests is low, the latency reduces when the requests are sent to a higher number of servers. However, when the rate of arrival is high, they observe that a high redundancy in the requests increases the latency.

To the best of our knowledge, there has been little theoretical characterization of analysing under what settings sending redundant requests would help (and under what settings it would not help). Two exceptions relating to theoretical results in this area that we are aware of are and . In , Joshi et al. consider the arrival process to be Poisson, and the service to be i.i.d. memoryless, and provide bounds on the average latency faced by a batch in the steady state when the requests are sent (redundantly) to all the servers. However, no comparisons are made with other schemes involving redundant requests, including the scheme of having no redundancy in the requests. In fact, our work can be considered as complementary to that of , in that we complete this picture by establishing that under the models considered therein, sending (redundant) requests to all servers is indeed the optimal choice. In , Liang and Kozat provide an approximate analysis of a system similar to that described in this paper under the assumption that arrivals follow a Poisson process; using insights from their approximations, they experiment with certain scheduling policies on the Amazon EC2 cloud. However, no analysis or metrics for accuracy of these approximations are provided, nor is there any treatment of whether these approximations lead to any useful upper or lower bounds.

III System Model: Centralized Buffer

We will first describe the system model followed by an illustrative example. The model is associated to three parameters: two parameters $n$ and $k$ that are associated to the system, and the third parameter $r$ that is associated to the redundant-requesting policy. The system comprises a set of $n$ servers. A request can be served by any arbitrary $k$ distinct servers out of this collection of $n$ servers. Several applications fall under the special case of $k=1$ : a compute-cluster where computational tasks can be performed at any one of multiple processors, or a data-transmission scenario where requests comprise packets that can be transmitted across any one of multiple routes, or a distributed storage system with data replicated in multiple servers. Examples of settings with $k>1$ include: a distributed storage system employing an $(n,\ k)$ Reed-Solomon code wherein the request for any data can be served by downloading the data from any $k$ of the $n$ servers, or a compute-cluster where each job is executed at multiple processors in order to guard from possible errors during computation.

The policy of redundant requesting is associated to a parameter $r~{}(k\leq r\leq n)$ which we call the ‘request-degree’. Each request is sent to $r$ of the servers, and upon completion of any $k$ of these, it is deemed complete. To capture this, we consider each request as a batch of $r$ jobs, wherein each of the $r$ jobs can be served by any arbitrary $r$ distinct servers. The batch is deemed served when any $k$ of its $r$ jobs are serviced. At this point in time, the remaining $(r-k)$ jobs of this batch are removed from the system. Such a premature removal of a job from a server may lead to certain overheads: the server may need to remain idle for some (random) amount of time before it becomes ready to serve another job. We shall term this idle time as the removal cost.

We assume that the time that a server takes to service a job is independent of the arrival and service times of other jobs. We further assume that the jobs are processed in a first-come-first-served fashion, i.e., among all the waiting jobs that an idle server can serve, it serves the one which had arrived the earliest. Finally, to be able to perform valid comparisons, we assume that the system is stable in the absence of any redundancy in the requests (i.e., when $r=k$ ). The arrival process may be arbitrary, and the only assumption we make is that the arrival process is independent of the present and past states of the system.

We consider a centralized queueing system in this section, where requests enter into a (common) buffer of infinite capacity. The choice of the server that serves a job may be made at any point in time. (This is in contrast to the distributed system considered subsequently in Section V, wherein this choice must be made upon arrival of the request into the system).

The scheduling algorithm is formalized in Algorithm 1. Note that the case of $r=k$ corresponds to the case where no redundancy is introduced in the requests, while $r=n$ corresponds to maximum redundancy with each batch being sent to all the servers.

The following example illustrates the working of the system.

Fig. 1 illustrates the system model and the working of Algorithm 1 when $n=4$ , $k=2$ and $r=3$ . The system has $n=4$ servers and a common buffer as shown in Fig. 1a. Let us denote the four servers (from left to right) as servers $1$ , $2$ , $3$ and $4$ . Each request comes as a batch of $r=3$ jobs, and hence we denote each batch (e.g., $A$ , $B$ , $C$ , etc.) as a triplet of jobs (e.g., $\{A_{1},A_{2},A_{3}\}$ , $\{B_{1},B_{2},B_{3}\}$ , $\{C_{1},C_{2},C_{3}\}$ , etc.). A batch is considered served if any $k=2$ of the $r=3$ jobs of that batch are served.

Fig. 1b depicts the arrival of batch $A$ . As shown in Fig. 1c, three of the idle servers begin serving the three jobs $\{A_{1},A_{2},A_{3}\}$ . Fig. 1c depicts the arrival of batch $B$ followed by batch $C$ . Server $4$ begins service of job $B_{1}$ as shown in Fig. 1d, while the other jobs wait in the buffer. Now suppose server $1$ completes servicing job $A_{1}$ (Fig. 1e). This server now becomes idle to serve any of the jobs remaining in the buffer. We allow jobs to be processed in a first-come first-served manner, and hence server $1$ begins servicing job $B_{2}$ (assignment of $B_{3}$ instead would also have been valid). Next, suppose the second server completes service of $A_{2}$ before any other servers complete their current tasks (Fig. 1f). This results in the completion of a total of $k=2$ jobs of batch $A$ , and hence batch $A$ is deemed served and is removed the system. In particular, job $A_{3}$ is removed from server $3$ (this may cause the server to remain idle for some time, depending on the associated removal cost). Servers $2$ and $3$ are now free to serve other jobs in the buffer. These are now populated with jobs $B_{3}$ and $C_{1}$ respectively. Next suppose server $3$ completes serving $C_{1}$ (Fig. 1g). In this case, since server $3$ has already served a job from batch $C$ , it is not allowed to service $C_{2}$ or $C_{3}$ (since the jobs of a batch must be processed by distinct servers). Since there are no other batches waiting in the buffer, server $3$ thus remains idle (Fig. 1h).

IV Analytical Results for the Centralized Buffer Setting

In this section, we consider the model presented in Section III that has a centralized buffer. We find redundant-requesting policies that minimize the average latency under various settings. This minimization is not only over redundant-requesting policies with a fixed value of the request-degree $r$ (as described in Section III) but also over policies that can choose different request-degrees for different batches. The proofs of these results are provided in Appendix B.

The first two results, Theorems 1 and 2, consider the service times to follow an exponential (memoryless) distribution.

Consider a system with $n$ servers such that any one server suffices to serve any request, the service-time is i.i.d. memoryless, and jobs can be removed instantly from the system. For any $r_{1}<r_{2}$ , the average latency in a system with request-degree $r_{1}$ is larger than the average latency in a system with request-degree $r_{2}$ . Furthermore, the distribution of the buffer occupancy in the system with request-degree $r_{1}$ dominates (is larger than) that of the system with request-degree $r_{2}$ . Finally, among all possible redundant requesting policies, the average latency is minimized when each batch is sent to all $n$ servers, i.e., when request-degree $r=n$ .

Consider a system with $n$ servers such that any $k$ of them can serve a request, the service-time is i.i.d. memoryless, and jobs can be removed instantly from the system. The average latency is minimized when all batches are sent to all the servers, i.e., when $r=n$ for every batch. Furthermore, the distribution of the buffer occupancy in the system with request-degree $r=n$ is strictly dominated by (i.e., is smaller than) a system with any other request-degree.

Fig. 3 depicts simulations that corroborate this result.

We now move on to some more general classes of service-time distributions. The first class of distributions is what we term heavy-everywhere, defined as follows.

A distribution on the non-negative real numbers is termed heavy-everywhere if for every pair of values $a>0$ and $b\geq 0$ with $P(X>b)>0$ , the distribution satisfies

In words, under a heavy-everywhere distribution, the need to wait for a while makes it more likely that a bad event has occurred, thus increasing the possibility of a greater wait than usual.

For example, a mixture of independent exponential distributions satisfies (1) and hence is heavy-everywhere. Some properties of heavy-everywhere distributions are discusses in Appendix A.

A second class of distributions is what we call light-everywhere distributions, defined as follows.

A distribution on the non-negative real numbers is termed light-everywhere if for every pair of values $a>0$ and $b\geq 0$ with $P(X>b)>0$ , the distribution satisfies

In words, under a light-everywhere distribution, waiting for some time brings you closer to completion, resulting in a smaller additional waiting time.

For example, an exponential distribution that is shifted by a positive constant is light-everywhere, and so is the uniform distribution. Some properties of light-everywhere distributions are discussed in Appendix A

The following theorems present results for systems with service-times belonging to one of these two classes of distributions.

Consider a system with $n$ servers such that any one server suffices to serve any request, the service-time is i.i.d. heavy-everywhere, and jobs can be removed instantly from the system. When the system has a 100% server utilization, the average latency is minimized when each batch is sent to all $n$ servers, i.e., when $r=n$ for each batch.

This is corroborated in Fig. 3 which depicts simulations with the service time $X$ distributed as a mixture of exponentials:

Note that Theorem 3 addresses only the scenario of high loads and predicts minimization of latency when $r=n$ in this regime; simulations of Fig. 3 further seem to suggest that the policy of $r=n$ minimizes the average latency for all loads. Similar phenomena are observed in simulations for $k>1$ .

Consider a system with $n$ servers such that any one server suffices to serve any request, and the service-time is i.i.d. light-everywhere. When the system has a 100% server utilization, the average latency is minimized when there is no redundancy in the requests, i.e., when $r=k~{}(=1)$ for all batches.

This is corroborated in Fig. 5 which depicts simulations with the service time $X$ distributed as a sum of a constant and a value drawn from an exponential distribution:

We observe in Fig. 5 that at high loads, the absence of any redundant requests (i.e., $r=1$ ) minimizes the average latency, which is as predicted by the theory. We also observe in the simulations for this setting that redundant requests do help when arrival rates are low, but start hurting beyond a certain threshold on the arrival rate. Similar phenomena are observed in simulations for $k>1$ .

The next theorem revisits memoryless service times, but under non-negligible removal costs.

Consider a system with $n$ servers such that any one suffices server to serve any request, and the service-time is i.i.d. memoryless, and removal of a job from a server incurs a non-zero delay. When the system has a 100% server utilization, the average latency is minimized when there is no redundancy in the requests, i.e., when $r=k~{}(=1)$ for all batches.

Fig. 5 presents simulation results for such a setting. The figure shows that under this setting, redundant requests lead to a higher latency at high loads, as predicted by theory.

V System Model: Distributed Buffers

The model with distributed buffers closely resembles the case of a centralized buffer. The only difference is that in this distributed setting, each server has a buffer of its own, and the jobs of a batch must be sent to some $r$ of the $n$ buffers as soon as the batch arrives in the system. The protocol for choosing these $r$ servers for each batch may be arbitrary for the purposes of this paper, but for concreteness, the reader may assume that the $r$ least-loaded buffers are chosen. The setting with distributed buffers is illustrated in the following example.

Fig. 6 illustrates the system model and the working of the system in the distributed setting, for parameters $n=4$ , $k=2$ and $r=3$ . The system has $n=4$ servers, and each of these servers has its own buffer, as shown in Fig. 6a. Denote the four servers (from left to right) as servers $1$ , $2$ , $3$ and $4$ . Fig. 6a depicts a scenario wherein batch $A$ is already being served by the first three servers, and batch $B$ just arrives. The three servers (buffers) to which batch $B$ will be sent to must be selected at this time. Suppose the algorithm chooses to send the batch to buffers $2$ , $3$ and $4$ (Fig. 6b). Now suppose server $1$ completes service of job $A_{1}$ (Fig. 6c). Since there is no job waiting in the first buffer, server $1$ remains idle. Note that in contrast, a centralized setting would have allowed the first server to start processing either job $B_{2}$ or $B_{3}$ . Next, suppose server $2$ completes service of job $A_{2}$ (Fig. 6d). With this, $k=2$ jobs of batch $A$ are served, and the third job $A_{3}$ is thus removed. Servers $2$ and $3$ can now start serving jobs $B_{3}$ and $B_{2}$ respectively.

VI Analytical Results for the Distributed Buffers Setting

As in the centralized setting of Section IV, we continue to assume that the service-time distributions of jobs are i.i.d. and the system operates on a first-come-first-served basis. The following theorems prove results that are distributed counterparts of the results of Section IV.

VII Conclusions and Open Problems

The prospect of reducing latency by means of redundant requests has garnered significant attention among practitioners in the recent past (e.g., ). Many recent works empirically evaluate the latency performance of redundant requests under diverse settings. The goal of our work is to analytically characterize the settings under which redundant requests help (and when they hurt), and to design scheduling policies that employ redundant-requesting to reduce latency. In this paper, we propose a model that captures key features of such systems, and under this model we analytically characterize several settings wherein redundant requests help and where they don’t. For each of these settings, we also derive the optimal redundant-requesting policy.

While we have characterized when redundant requests help for several scenarios in this paper, the characterization for many more general settings remains open. Some questions that immediately arise are:

What is the optimal redundant-requesting policy for service-time distributions and removal-costs not considered in this paper ?

We observed in the simulations (e.g., Fig. 5) that for several service-time distributions, redundant requests start hurting when the system is loaded beyond a certain threshold. In the future, we wish to use the insights developed in this paper to analytically characterize this threshold.

What happens when the requests or the servers are heterogeneous, or if the service-times of different jobs of a batch are not i.i.d. ?

What about other metrics such as the tails of the latency, or a quantification of the amount of gains achieved via redundant requests ?

If we allow choosing different values of the request-degree $r$ adaptively for different batches, what is the minimal information about the state of the system required to make this choice? What are the optimal scheduling policies in that case ?

In certain settings, one may be constrained with each request having the ability to get served by only a specific $m~{}(<n)$ of the $n$ servers. It remains to investigate which of the results for $m=n$ carry over to this setting of $m<n$ (see, for example, Fig 7)?

References

Appendix A Heavy-everywhere and light-everywhere distributions

In this section we derive some properties of heavy-everywhere (1) and light-everywhere (2) classes of distributions. We also provide examples of distributions that fall into these classes. We first state the results, following which we provide the proofs.

The expected value of the minimum of $n$ random variables, each drawn independently from a distribution that is heavy-everywhere, is no larger than $\frac{1}{n}$ times the expected value of that distribution. The expected value of the minimum of $n$ random variables, each drawn independently from a distribution that is light-everywhere, is no smaller than $\frac{1}{n}$ times the expected value of that distribution.

Consider a finite set of independent random variables $X_{1},\ldots,X_{L}$ , each of whose (marginal) distributions is heavy-everywhere, such that for every $i,j$ and every $a\geq 0,\ b\geq 0$ ,

Then, any mixture of $X_{1},\ldots,X_{L}$ is also a heavy-everywhere distribution.

The following distributions are heavy-everywhere:

A mixture of a finite number of independently drawn exponential distributions.

A Weibull distribution with scale parameter smaller than $1$ , i.e., with a pdf

The sum of a finite number of independent random variables, each of which has a (marginal) distribution that is light-everywhere, also has a distribution that is light-everywhere.

The following distributions are light-everywhere:

For any $c>0$ , the constant distribution with entire mass on $c$ .

An exponential distribution that is shifted by a positive constant.

For any pair of non-negative constants $c_{1}$ and $c_{2}$ with $2c_{1}>c_{2}>c_{1}$ , a distribution with its support comprising only the two constants $c_{1}$ and $c_{2}$ .

We now present the proofs of these claims.

Let $X$ be a random variable with a distribution that is heavy-everywhere. Consider any $x>0$ . Using the property of being heavy-everywhere, we have

Now consider i.i.d. random variables $X_{1},\ldots,X_{n}$ drawn from this distribution. The expected value of their minimum is given by

If the distribution is light-everywhere, then each of the inequalities in the entire proof above are flipped, leading to the result

Suppose $X$ is drawn from a mixture of $L$ independent random variables $X_{1},\ldots,X_{L}$ for some $L\geq 1$ whose (marginal) distributions satisfy the conditions stated in the proposition. In particular, suppose $X$ takes value $X_{i}$ with probability $p_{i}\geq 0$ (with $\sum_{i=1}^{L}p_{i}=1$ ). Then

where (8) is a result of the assumption that $P(X_{i}>a)\geq P(X_{j}>a)\Rightarrow P(X_{i}>b)\geq P(X_{j}>b)$ . ∎

Let $X$ be a random variable drawn from the distribution under consideration.

A mixture of a finite number of independently drawn exponential distributions. The exponential distribution trivially satisfies (1) and hence is heavy-everywhere. Furthermore, if $X_{i}$ and $X_{j}$ are exponentially distributed with rates $\mu_{i}$ and $\mu_{j}$ ,

This allows us to apply Prop. 11, giving the desired result.

A Weibull distribution with scale parameter smaller than $1$ . The Weibull distribution has a complementary c.d.f.

For $k\in(0,1]$ , and for any $a,b>0$ , we know that

Let $X_{1}$ and $X_{2}$ be independent random variables whose (marginal) distributions are light-everywhere. Let $X=X_{1}+X_{2}$ , Then,

where the inequality (18) utilizes the light-everywhere property of the distribution of $X_{2}$ . Also,

where the inequality (21) utilizes the light-everywhere property of the distribution of $X_{1}$ . Putting it back together in (15) we get

Let $X$ be a random variable drawn from the distribution under consideration.

For any $c>0$ , the constant distribution with entire mass on $c$ . If $a\leq c$ then $P(X>a)=1$ . If $a>c$ then $P(X>a+b)=0$ . Thus the constant distribution satisfies (2).

An exponential distribution that is shifted by a positive constant. The exponential distribution trivially satisfies (2) and is light-everywhere. A constant is also light-everywhere as shown above. Applying Proposition 13, we get the desired result.

The uniform distribution. We first show that for every $M>0$ . the uniform distribution on the interval $[0,M]$ is light-everywhere. If $a+b\geq M$ then $P(X>a+b)=0$ , thus trivially satisfying (2). If $a+b<M$ then $P(X>a)=\frac{M-a}{M}$ and $P(X>a+b|X>b)=\frac{M-a-b}{M-b}$ . Using the fact that $a\geq 0,b\geq 0$ , some simple algebraic manipulations of these expressions lead to (2). Since a constant is light-everywhere, Proposition 13 completes the result.

For any pair of non-negative constants $c_{1}$ and $c_{2}$ with $2c_{1}>c_{2}>c_{1}$ , a distribution with its support comprising only the two constants $c_{1}$ and $c_{2}$ . If $a+b\geq c_{2}$ then $P(X>a+b)=0$ . If $a<c_{1}$ then $P(X>a)=1$ . Finally, if $a\geq c_{1}$ and $a+b<c_{2}$ then the constraint of $2c_{1}>c_{2}$ implies $b<c_{1}$ . Thus in this setting, $P(X>a+b|X>b)=P(X=c_{2})=P(X>a)$ .

Appendix B Proofs

We first present a brief description of the general proof technique we follow to obtain the analytical results, following which we provide the proofs of the individual results.

The general proof technique is depicted pictorially in Fig. 8. Consider two identical systems $S_{1}$ and $S_{2}$ with different redundant-requesting policies. Suppose we wish to prove that the redundant-requesting policy of system $S_{2}$ leads to a lower latency as compared to the redundant-requesting policy of system $S_{1}$ . To this end we first construct two new hypothetical systems $T_{1}$ and $T_{2}$ . The construction is such that the performance of system $T_{1}$ is statistically identical or better than $S_{1}$ , and that of $T_{2}$ is statistically identical or worse than $S_{2}$ . The two systems $T_{1}$ and $T_{2}$ are also coupled in the following manner. The construction establishes a one-to-one correspondence between the $n$ servers of $T_{1}$ and the $n$ servers of $T_{2}$ . Furthermore, it also establishes a one-to-one correspondence between the service events occurring in both systems, i.e., the completion of any job in $T_{1}$ is associated to the completion of a unique job in $T_{2}$ and vice versa. The same sequence of arrivals is applied to both systems.

Such a coupling facilitates an apples-to-apples comparison between the two systems. We exploit this and show that at any point in time, system $T_{2}$ is in a better state than system $T_{1}$ . Putting it all together, it implies that system $S_{2}$ is better than system $S_{1}$ .

Most interestingly, this technique allows us to handle arbitrary arrival sequences. Furthermore, it does not restrict the results to the (asymptotic) setting when the system is in steady state, but allows the results to be applicable to any interval of time.

We now provide proofs of the analytical results presented in the paper.

Consider two systems, system $S_{1}$ with request-degree $r_{1}$ and system $S_{2}$ with request-degree $r_{2}~{}(>r_{1})$ , both having system parameters $(n,\ k=1)$ , the same arrival process, and the same rate of service. In the proof, we shall construct two new hypothetical systems $T_{1}$ and $T_{2}$ such that the statistics of $T_{1}$ are identical to $S_{1}$ , and the statistics of $T_{2}$ are identical to $S_{2}$ . We shall then show that system $T_{2}$ outperforms system $T_{1}$ , and conclude that $S_{2}$ outperforms $S_{1}$ .

The new system $T_{1}$ is defined as follows. The system $T_{1}$ is also associated to parameters $(n,\ k=1)$ , has the same arrival and service processes as $S_{1}$ , and follows the scheduling protocol described in Algorithm 1 with request-degree $r_{1}$ . However, after every service-event, we perform a specific permutation of the $n$ servers. Since the $n$ servers have independent and memoryless service time distributions with identical rates, the system $T_{1}$ remains statistically identical to $S_{1}$ . In particular, the two systems $T_{1}$ and $S_{1}$ have identical distributions of the latency and buffer occupancy. The specific permutation applied is as follows. At any point in time, consider denoting the $n$ servers by indices ‘1’, $\ldots$ ,‘n’. Upon completion of any job at any server, the servers are permuted such that the busy servers have the lowest indices and the idle servers have the higher indices. In a similar manner, we construct $T_{2}$ to be a system identical to $S_{2}$ , but again permuting the servers in $T_{2}$ after every job completion such that the busy servers have the lowest indices. Thus $T_{2}$ is statistically identical to $S_{2}$ .

In the system under consideration, at any point in time, there are $(n+1)$ processes simultaneously going on: the arrival process and the processes at the $n$ servers. The assumption of memoryless service times allows us to assume that a (fictitious) service process continues to execute even in an idle server, although no job is counted as served upon completion of the process. Let us call the completion of any of these processes as an event. In this proof, we assume the occurrence of any arbitrary sequence of events, and evaluate the performance of systems $T_{1}$ and $T_{2}$ under this sequence of events. Since the arrivals into the system and the memoryless processes at the servers are all independent of the state of the system, we can assume the same sequence of events to occur in the two systems.

We begin by showing that under an identical sequence of events (the arrivals and server completions) in systems $T_{1}$ and $T_{2}$ , the number of batches remaining to be completely served in $T_{2}$ at any point of time is no more than number of batches remaining in $T_{1}$ at that time. Without loss of generality, we shall prove this statement only at times immediately following an event, since the systems do not change state between any two consecutive events. With some abuse of notation, for $z\in\{0,1,2,\ldots\}$ , we shall use the term “time $z$ ” to denote the time immediately following the $z^{\textrm{th}}$ event.

Assume that the two systems begin in identical states at time . For system $T_{i}~{}(i\in\{1,2\})$ , let $b_{i}(z)$ denote the number of batches remaining in system $T_{i}$ at time $z$ . The proof proceeds via induction on $z$ . The induction hypothesis is that at any time $z$ , we have $b_{1}(z)\geq b_{2}(z)$ . Since the two systems begin in identical states, $b_{1}(0)=b_{2}(0)$ . Now suppose the induction hypothesis is satisfied at time $(z-1)$ . We shall now show that it is satisfied at time $z$ as well.

Suppose the $z^{\textrm{th}}$ event is the arrival of a new batch. Then

where (26) follows from the induction hypothesis. Thus, the hypothesis is satisfied at time $z$ .

Now suppose the $z^{\textrm{th}}$ event is the completion of the exponential timer of one of the $n$ servers (in both the systems). We first consider the case $b_{1}(z-1)\geq b_{2}(z-1)+1$ . Since the completion of the timer at a server can lead to the completion of the service of at most one batch, it follows that $b_{1}(z)\geq b_{2}(z)$ in this case. Now consider the case $b_{1}(z-1)=b_{2}(z-1)$ . Since $k=1$ , the number of servers occupied in system $T_{i}~{}(i\in\{1,2\})$ at time $(z-1)$ is equal to $\min\{r_{i}b_{i}(z-1),\ n\}$ . Furthermore, from the construction of systems $T_{1}$ and $T_{2}$ described above (recall the permutation of servers), it must be that the first $\min\{r_{i}b_{i}(z-1),\ n\}$ servers are occupied at time $(z-1)$ in system $T_{i}$ . Thus, since $r_{1}<r_{2}$ and $b_{1}(z-1)=b_{2}(z-1)$ , the set of servers occupied at time $(z-1)$ in $T_{1}$ is a subset of the servers occupied in $T_{2}$ . Now, since $k=1$ , an event at a server triggers the completion of service of a batch if and only if that server was not idle. Thus, if this event leads to the completion of service of a batch in $T_{1}$ , it also leads to the completion of service of a batch in system $T_{2}$ . It follows that $b_{1}(z)\geq b_{2}(z)$ . We have thus shown that at any point in time, the number of batches remaining in system $T_{2}$ is no more than that under system $T_{1}$ .

The arguments above show that the distribution of the number of batches remaining in $T_{1}$ dominates that in $T_{2}$ : with $B_{1}$ and $B_{2}$ denoting the number of batches in the system $T_{1}$ and $T_{2}$ respectively under steady state, $P(B_{1}>x)\geq P(B_{2}>x)$ for all $x\geq 0$ . Since the average latency is proportional to the average system occupancy, it follows that the latency faced by a batch on an average in system $T_{2}$ is no more than that in $T_{1}$ . These properties carry over to $S_{1}$ and $S_{2}$ since the statistics of $S_{1}$ and $S_{2}$ are identical to those of $T_{1}$ and $T_{2}$ respectively.

From arguments identical to the above, it follows that having a request degree of $n$ for each batch minimizes the average latency as compared to any other redundant requesting policy, including ones where a different request degree may be chosen (adaptively) for different batches.

Finally, we show that if $T_{1}$ employs a fixed request-degree $r<n$ for all batches, and $T_{2}$ employs $r=n$ for all batches, then the average latency under $T_{2}$ is strictly smaller. At any given time, there is a non-zero probability of the occurrence of a sequence of service-events that empty system $T_{1}$ (which also results in $T_{2}$ getting emptied). Now, upon arrival of a batch, this new batch is served in $r<n$ servers of $T_{1}$ and in all $n$ servers of $T_{2}$ , and hence there is a strictly positive probability that the batch completes service in $T_{2}$ before it completes service in $T_{1}$ and also before a new batch arrives. This event results in $b_{2}(\cdot)<b_{1}(\cdot)$ , and since this event occurs with a non-zero probability, we can draw the desired conclusion. ∎

Consider two systems, system $S_{1}$ with an arbitrary redundant-requesting policy and system $S_{2}$ with request-degree $n$ , both having system parameters $(n,\ k)$ , the same arrival process, and the same rate of service. In the proof, we shall construct two new systems $T_{1}$ and $T_{2}$ such that the statistics of $T_{1}$ are identical to $S_{1}$ , and the statistics of $T_{2}$ are identical to $S_{2}$ . We shall then show that system $T_{2}$ outperforms system $T_{1}$ , and conclude that $S_{2}$ outperforms $S_{1}$ .

In either system, at any point in time, there are $(n+1)$ processes simultaneously going on: the arrival process and the processes at the $n$ servers. The assumption of memoryless service times allows us to assume that a (fictitious) service process continues to execute even in an idle server, although no job is counted as served upon completion of the process. Let us term the completion of any of these $(n+1)$ timers as the an event. In this proof, we assume the occurrence of any arbitrary sequence of events, and evaluate the performance of systems $T_{1}$ and $T_{2}$ under this sequence of events. Since the arrivals into the system and the memoryless processes at the servers are all independent of the state of the system, we can assume the same sequence of events to occur in the two systems.

We shall now show that under an identical sequence of events (arrivals and server completions) in $T_{1}$ and $T_{2}$ , the number of batches remaining in system $T_{1}$ is at least as much as that in $T_{2}$ at any given time. Without loss of generality, we shall prove this statement only at times immediately following an event, since the states of the systems do not change in between any two events. Abusing some notation, for $z\in\{0,1,2,\ldots\}$ , we shall use the term “time $z$ ” to denote the time immediately following the $z^{\textrm{th}}$ event.

Assume that the two systems begin in the same state at time $z=0$ . For system $T_{i}~{}(i\in\{1,2\})$ , let $b_{i}(z)$ denote the number of batches remaining in system $T_{i}$ at time $z$ . The proof proceeds via induction on the time $z$ . The induction hypothesis is that at any time $z$ :

for any $z^{\prime}>z$ , if there are no arrivals between time $z$ and $z^{\prime}$ (including at time $z^{\prime}$ ), then $b_{1}(z^{\prime})\geq b_{2}(z^{\prime})$ .

The hypotheses are clearly true at $z=0$ , when the two systems are in the same state. Now, let us consider them to be true for time $z~{}(\geq 0)$ . Suppose the next event occurs at time $(z+1)$ . We need to show that the hypotheses are true even after this event at time $(z+1)$ .

First suppose the event was the completion of an exponential-timer at one of the $n$ servers. Then there has been no arrival between times $z$ and $(z+1)$ . This allows us to apply hypothesis (b) at time $z$ with $z^{\prime}=z+1$ , which implies the satisfaction of both the hypotheses at time $(z+1)$ .

Now suppose the event at time $(z+1)$ is the arrival of a new batch. Then, hypothesis (a) is satisfied at time $(z+1)$ since $b_{1}(z+1)=b_{1}(z)+1\geq b_{2}(z)+1=b_{2}(z+1)$ . We now show that hypothesis (b) is also satisfied. Consider any sequence of server-events, and any time $z^{\prime}>z+1$ such that there were no further arrivals between times $(z+1)$ and $z^{\prime}$ .

Let $a_{1}(z^{\prime})$ and $a_{2}(z^{\prime})$ be the number of batches remaining in the two systems at time $z^{\prime}$ if the new batch had not arrived but the sequence of server-events was the same as before. From hypothesis (b) at time $z$ , we know that $a_{1}(z^{\prime})\geq a_{2}(z^{\prime})$ . Also note that the scheduling protocol described in Algorithm 1 gives priority to the batch that had arrived earliest, and as a consequence, a server serves a job from the new batch only when it cannot serve any other batch. It follows that under any sequence of server-events, for $i\in\{1,2\}$ , $b_{i}(z^{\prime})=a_{i}(z^{\prime})+1$ if $k$ jobs of the new batch have not completed service in $T_{i}$ , else $b_{i}(z^{\prime})=a_{i}(z^{\prime})$ . When $b_{1}(z^{\prime})=a_{1}(z^{\prime})+1$ , it follows that $b_{1}(z^{\prime})=a_{1}(z^{\prime})+1\geq a_{2}(z^{\prime})+1\geq b_{2}(z^{\prime})$ . It thus remains to show that $b_{1}(z^{\prime})=a_{1}(z^{\prime})\Rightarrow b_{2}(z^{\prime})\leq b_{1}(z^{\prime})$ . The condition $b_{1}(z^{\prime})=a_{1}(z^{\prime})$ implies that $k$ jobs of the new batch have completed service in system $T_{1}$ at or before time $z^{\prime}$ . Let $z_{1},\ldots,z_{k}$ ( $z_{1}<\ldots<z_{k}\leq z^{\prime}$ ) be the events when the $k$ jobs of the new batch are served in system $T_{1}$ . Then, at these times, the corresponding servers must have been idle in system $T_{1}$ if the new batch had not arrived.

Consider another sequence of events that is identical to that discussed above, but excludes the server-events that happened at times $z_{1},\ldots,z_{k}$ , and also excludes the arrival at time $(z+1)$ . Let $c_{i}(z^{\prime})$ denote the number of batches remaining in this situation at time $z^{\prime}$ . From the arguments above, we get $c_{1}(z^{\prime})=a_{1}(z^{\prime})$ . From the second hypothesis, we also have $c_{2}(z^{\prime})\leq c_{1}(z^{\prime})$ . Thus we already have $c_{2}(z^{\prime})\leq c_{1}(z^{\prime})=a_{1}(z^{\prime})=b_{1}(z^{\prime})$ , and hence for our goal of showing $b_{2}(z^{\prime})\leq b_{1}(z^{\prime})$ , it now suffices to show that $b_{2}(z^{\prime})\leq c_{2}(z^{\prime})$ .

If $b_{2}(z^{\prime})=0$ then we automatically have $b_{2}(z^{\prime})\leq b_{1}(z^{\prime})$ and there is nothing left to show. Thus, we consider the case $b_{2}(z^{\prime})>0$ , i.e., system $T_{2}$ is non-empty at time $z^{\prime}$ . We shall now see how to count the number of batches in any system at time $z^{\prime}$ , under the condition that there were no arrivals between time $(z+1)$ and $z^{\prime}$ . Consider $(n+1)$ counters: one counter each for the $n$ servers and one ‘global’ counter. At time $(z+1)$ , let the value of the counter of any server be equal to the number of jobs that this server has finished serving from the batches that are still remaining in the system. Let the value of the global counter be at this time. Now, whenever a server-event occurs, add $1$ to the counter associated to that server, irrespective of whether the server had a job or not. Whenever the counters of any $k$ servers become greater than zero, add $1$ to the global counter, and subtract $1$ from the counters of these $k$ servers. One can see that in this process, the value of the global counter at any time gives the number of batches that have finished service since the time we started counting. With this in mind, we shall compare the sequence of events that includes the events at $z_{1},\ldots,z_{k}$ to that which excludes these events. Since the events $z_{1},\ldots,z_{k}$ must correspond to events at $k$ distinct servers, the service-events at $z_{1},\ldots,z_{k}$ cause the global counter of system $T_{2}$ to increase by one. Since $T_{2}$ also had one additional arrival as compared to the system of $c_{2}(\cdot)$ , it must be that $b_{2}(z^{\prime})=c_{2}(z^{\prime})$ . Putting the pieces together, we get that the number of batches served in $T_{2}$ at any time is at least as much as that served in $T_{1}$ at any time.

Since the average latency is proportional to the average system occupancy, it follows that the latency faced by a batch on an average in system $T_{2}$ is smaller than that in $T_{1}$ . These properties carry over to $S_{1}$ and $S_{2}$ since the statistics of $S_{1}$ and $S_{2}$ are identical to those of $T_{1}$ and $T_{2}$ respectively.

Consider two systems, system $S_{1}$ with some arbitrary redundant-requesting policy, and system $S_{2}$ with request-degree $n$ for all batches. We shall now construct two new hypothetical systems $T_{1}$ and $T_{2}$ such that $T_{1}$ is statistically identical to $S_{1}$ and $T_{2}$ is worse than $S_{2}$ , and show that the performance of $T_{1}$ is worse than that of $T_{2}$ .

The two new systems $T_{1}$ and $T_{2}$ are constructed as follows. Both systems have the same parameters $n$ and $k=1$ , and retain the redundant-requesting policies of $S_{1}$ and $S_{2}$ respectively. The service-time distribution in $T_{1}$ is identical to that in $S_{1}$ . On the other hand, we shall make the service time distribution of $T_{2}$ worse than that of $S_{2}$ in the manner described below.

Let us fix some arbitrary one-to-one correspondence between the $n$ servers of system $T_{1}$ and the $n$ servers of system $T_{2}$ . Consider any point in time when a server in system $T_{2}$ is just beginning the service of a job. Let $X$ denote the random variable corresponding to this service time. Let $P_{H}$ denote the law associated to the heavy-everywhere service-time distribution under consideration. Since the systems operate at 100% server utilization, the corresponding server in $T_{1}$ is not idle at this point in time and is serving some job. When this server in system $T_{2}$ begins service, suppose the job in the corresponding server of system $T_{1}$ began to be serviced $t>0$ units of time ago. Then we modify the distribution of $X$ and let it follow the law

Since the distribution $P_{H}$ is heavy-everywhere (1), the service under system $T_{2}$ is no better than that under $S_{2}$ . As a result of the construction above, whenever a job begins to be processed in system $T_{2}$ , it has a service-time distribution that is identical to the distribution of the service-time of the job in the corresponding server in $T_{1}$ . We couple the servers even further by assuming whenever a server in $T_{2}$ begins a new job, the time taken for this job to be completed is identical to that taken for the job in the corresponding server in $T_{1}$ (unless, of course, some other job of the batch completes service first and this job is removed). We also feed an identical sequence of arrivals to the two systems $T_{1}$ and $T_{2}$ . This completes the construction of the two systems $T_{1}$ and $T_{2}$ .

Note that the aforementioned coupling of service-times between corresponding servers of systems $T_{1}$ and $T_{2}$ only takes place when the server in $T_{2}$ begins a job. The case when a server of $T_{1}$ begins serving a new job when the corresponding server of $T_{2}$ is already serving a job is not accounted for. The induction hypothesis below handles such situations.

We start at any point in time when the two systems are in an identical state, and show that the average latency faced by the batches in $T_{2}$ from then on is no larger than that faced by batches in $T_{1}$ . We shall now show the following two properties via an induction on time:

At any point in time, the number of batches in system $T_{2}$ is no more than the number of batches in system $T_{1}$ .

At any point in time, if a server in system $T_{1}$ begins service of a job, the corresponding server in $T_{2}$ also begins service of some job.

Part (b) of the hypothesis ensures that the service times of the jobs in corresponding servers of systems $T_{1}$ and $T_{2}$ are always identical (via the construction above).

As mentioned previously, let us start at any point in time when the two systems are in an identical state. Since the systems are in an identical state, both hypotheses hold true at this time. Without loss of generality, we shall now consider only the times immediately following an event in either system, where an event is defined as an arrival of a batch or the completion of processing by a server. First consider any time that immediately follows an arrival. By our induction hypothesis, just before the arrival, the number of batches in $T_{2}$ was no more than that in $T_{1}$ . The arrival only increases the number of batches in both systems by $1$ , and hence induction hypothesis (a) still stands. Under a 100% server utilization, an arrival does not trigger the beginning of a service in either system. Thus, hypothesis (b) continues to hold. Let us now consider an event where a server completes processing a job. Due to hypothesis (b), the service times at corresponding servers in the two systems were coupled. As a result, the next service completes at the same time in corresponding servers of both systems. This reduces the number of batches in both systems by one, thus continuing to satisfy hypothesis (a). Furthermore, since we have assumed a 100% utilization of the servers, there is at least one batch waiting in the buffer in both the systems. In system $T_{2}$ , since we had $k=1$ , $r=n$ and no removal cost, at any given time each of the $n$ servers in system $T_{2}$ will be serving jobs of the same batch. Thus jobs in all the servers of $T_{2}$ are removed from the system, and are replaced by (new) jobs of the next batch. As a result, upon any service-event, each of the servers in $T_{2}$ begin serving new jobs, thus satisfying hypothesis (b). Due to the specific construction of the two systems, the service times of these new jobs in the servers of $T_{2}$ are identical to those of jobs in corresponding servers of $T_{1}$ .

This completes the proof of the induction hypothesis, and in particular that the number of batches in $T_{2}$ at any time is no more than the number of batches in system $T_{1}$ . The fact that the average latency is proportional to the average number of batches in the system implies that the average latency in system $T_{1}$ is no smaller than in $T_{2}$ . Finally, the constructions of the two systems $T_{1}$ and $T_{2}$ ensured that system $T_{2}$ is worse than $S_{2}$ , and system $T_{1}$ is statistically identical to $S_{1}$ , thus leading to the desired result.

Finally, suppose system $T_{1}$ employs a fixed request-degree $r<n$ for all batches. Further suppose that the heavy-everywhere distribution is such that (1) holds with a strict inequality for a set of events that have a probability bounded away from zero. Under this setting, the aforementioned construction is such that system $T_{2}$ is worse than system $S_{2}$ by a non-trivial amount, and as a result, the average latency in system $S_{2}$ is strictly smaller than that of $S_{1}$ . ∎

Consider two systems, system $S_{1}$ with some arbitrary redundant-requesting policy, and system $S_{2}$ with request-degree $r=k=1$ for all batches. We shall now construct two new hypothetical systems $T_{1}$ and $T_{2}$ such that $T_{1}$ is statistically identical to $S_{1}$ and $T_{2}$ is worse than $S_{2}$ , and show that the performance of $T_{1}$ is worse than that of $T_{2}$ .

The two new systems $T_{1}$ and $T_{2}$ are constructed as follows. Both systems have the same parameters $n$ and $k=1$ , and retain the redundant-requesting policies of $S_{1}$ and $S_{2}$ respectively. The service-time distribution in $T_{2}$ is identical to that in $S_{2}$ . On the other hand, we shall make the service time distribution of $T_{1}$ better than that of $S_{1}$ in the manner described below.

Let us fix some arbitrary one-to-one correspondence between the $n$ servers of system $T_{1}$ and the $n$ servers of system $T_{2}$ . Consider any point in time when a server in system $T_{1}$ is just beginning the service of a job. Let $X$ denote the random variable corresponding to this service time. Let $P_{L}$ denote the law associated to the heavy-everywhere service-time distribution under consideration. Since the systems operate at 100% server utilization, the corresponding server in $T_{2}$ is not idle at this point in time and is serving some job. When this server in system $T_{2}$ begins service, suppose the job in the corresponding server of system $T_{1}$ began to be served $t>0$ units of time ago. Then we modify the distribution of $X$ and let it follow the law

Since the distribution $P_{L}$ is light-everywhere (2), the service under system $T_{1}$ is no better than that under $S_{1}$ . As a result of the construction above, whenever a job begins to be processed in system $T_{1}$ , it has a service-time distribution that is identical to the distribution of the service-time of the job in the corresponding server in $T_{2}$ . We couple the servers even further by assuming whenever a server in $T_{1}$ begins a new job, the time taken for this job to be completed is identical to that taken for the job in the corresponding server in $T_{2}$ (unless, of course, some other job of the batch completes service first and this job is removed). We also feed an identical sequence of arrivals to the two systems $T_{1}$ and $T_{2}$ . This completes the construction of the two systems $T_{1}$ and $T_{2}$ .

Note that the aforementioned coupling of service-times between corresponding servers of systems $T_{1}$ and $T_{2}$ only takes place when the server in $T_{1}$ begins a job. The case when a server of $T_{2}$ begins serving a new job when the corresponding server of $T_{1}$ is already serving a job is not accounted for. The induction hypothesis below handles such situations.

We start at any point in time when the two systems are in an identical state, and show that the average latency faced by the batches in $T_{2}$ from then on is no more than that faced by batches in $T_{1}$ . We shall now show the following two properties via an induction on time:

At any point in time, the number of batches in system $T_{2}$ is no more than the number of batches in system $T_{1}$ .

At any point in time, if a server in system $T_{2}$ begins service of a job, the corresponding server in $T_{1}$ also begins service of some job.

Part (b) of the hypothesis ensures that the service times of the jobs in corresponding servers of systems $T_{1}$ and $T_{2}$ are always identical (via the construction above).

As mentioned previously, let us start at any point in time when the two systems are in an identical state. Since the systems are in an identical state, both hypotheses hold true at this time. Without loss of generality, we shall now consider only the times immediately following an event in either system, where an event is defined as an arrival of a batch or the completion of processing at server. First consider any time that immediately follows an arrival. By our induction hypothesis, just before the arrival, the number of batches in $T_{2}$ was no more than that in $T_{1}$ . The arrival only increases the number of batches in both systems by $1$ , and hence induction hypothesis (a) still stands. Under a 100% server utilization, an arrival does not trigger the beginning of a service in either system. Thus, hypothesis (b) continues to hold. Let us now consider an event where a server completes processing a job. Due to hypothesis (b), the service times at corresponding servers in the two systems were coupled. As a result, the next service completes at the same time in corresponding servers of both systems. This reduces the number of batches in both systems by one, thus continuing to satisfy hypothesis (a). Furthermore, since we have assumed a 100% utilization of the servers, there is at least one batch waiting in the buffer in both the systems. In system $T_{2}$ , since we had $k=1$ and $r=k=1$ , only this server begins serving a new job, while all remaining $(n-1)$ servers continue processing the jobs they already have. Now, the corresponding server in $T_{1}$ also had a server-event and begins serving a new job at this moment. Thus this satisfies hypothesis (b). Due to the specific construction of the two systems, the service times of these new jobs in the servers of $T_{2}$ are identical to those of jobs in corresponding servers of $T_{1}$ .

Finally, suppose system $T_{1}$ employs a fixed request-degree $r<n$ for all batches. Further suppose that the light-everywhere distribution is such that (2) holds with a strict inequality for a set of events that have a probability bounded away from zero. Under this setting, the aforementioned construction is such that system $T_{1}$ is better than system $S_{1}$ by a non-trivial amount, and as a result, the average latency in system $S_{2}$ is strictly smaller than that of $S_{1}$ . ∎

The proof is identical to that of Theorem 4. The system $T_{2}$ is constructed to be ‘better’ than system $S_{2}$ by assuming zero removal costs in $T_{2}$ . ∎

In order to get to the desired results, we shall first compare a system with distributed buffers to an analogous system that has a central buffer. The scheduling policy in either setting needs to make two kinds of decisions: the number of redundant requests for each batch, and the precise set of servers to which these requests are assigned. Firstly, observe that under the redundant requesting policy of $r=n$ for all batches, the choice of the $r~{}(=n)$ servers to which the jobs are assigned does not require any decision to be made. The centralized and the distributed systems thus are identical in this case and hence have the same average latency. Secondly, we know from the results of Section IV that under all the arrival and service time distributions considered here, the choice of $r=n$ for all batches is optimal under a centralized scheme. Thirdly, for any fixed redundant requesting policy, the average latency under the centralized scheme will be no more than the average latency under the distributed scheme. This is because the first-come first-served policy as described in Algorithm 1 minimizes average latency, and moreover, the policy of the system with a centralized buffer has more information (about the system) as compared to the one operating under distributed buffers. It thus follows that even in the case of distributed buffers, the average latency is minimized when the request-degree for each batch is $n$ . ∎