Fair scheduling of bag-of-tasks applications on large-scale platforms

Highlights

• We present a scheduling model for fair resource sharing on large-scale platforms.

• It effectively aggregates information about application stretch.

• Task allocation is performed so that the maximum stretch is minimized.

• Our model is able to perform similar to a centralized implementation.

• The management overhead is bounded.

Abstract

Users of distributed computing platforms want to obtain a fair share of the resources they use. With respect to the amount of computation, the most suitable measure of fairness is the stretch. It describes the slowdown that the applications suffer for being executed in a shared platform, in contrast to being executed alone. In this paper, we present a decentralized scheduling policy that minimizes the maximum stretch among user-submitted applications. With two reasonable assumptions, that can be deduced from existing system traces, we are able to minimize the stretch using only local information. In this way, we avoid a centralized design and provide scalability and fault tolerance. As a result, our policy performs just 11% worse than a centralized implementation, and largely outperforms other common policies. Additionally, it easily scales to hundreds of thousands of nodes. We presume that it can scale to millions with a minimal overhead. Finally, we also show that preemption is crucial to provide fairness in any case.

Introduction

It is common for a distributed computing platform to be shared among several users, for instance, a cluster giving service to several researchers of an academic institution, or a commercial cloud infrastructure attending millions of requests from around the world. All of them would like to obtain a fair share of the platform. However, the most common scheduling policies are incompatible with the fairness objective. They unbalance the share of the platform among users to maximize the global throughput, minimize the makespan or satisfy the negotiated SLA terms. So, it is the scheduling policy itself who must enforce the fair sharing of the platform among its users. While several such policies have been proposed  [1], [2], [3], [4], [5], [6], [7], [8], [9], they have serious scalability limitations. They are usually implemented with a centralized design that relies on full knowledge of the platform and the workload. This prevents them from managing the scheduling of tasks on systems of thousands, or even millions of nodes, a scale that is becoming more common every day.

In this paper we present the Fair Share Policy (FSP), a scheduling policy that allocates bag-of-tasks (BoT) applications with fairness in mind. It is a policy for STaRS  [10], a scheduling model that can be implemented as part of a distributed computing platform. It provides scalability, fault-tolerance and the ability to support different scheduling policies. It is based on decentralized algorithms that eliminate the bottlenecks of a centralized design, and it is best suited for environments with millions of nodes. So, throughout the paper we assume that we deal with a very large platform and no centralized scheduler.

To measure the share of the platform, we consider the amount of computation that each user wants to get done. In this case, the most suited metric seems to be the maximum stretch, or slowdown  [11], [2]. The stretch of an application is defined as the ratio of its response time under the concurrent scheduling of applications to its response time when it is the only application executed on the platform. It is the user’s perception of how slow its applications run due to its sharing the platform with other users. Let $r_i$ be the release time of an application $A_i,e_i$ its end time and ${\Theta }_i$ its response time in a platform dedicated to itself, its stretch $S_i$ is calculated as

$$S_i=\frac{e_i-r_i}{{\Theta }_i}\text{.}$$

A perfectly fair share of the platform is obtained when all the applications obtain the same stretch. However, this is only possible with offline scheduling and divisible load. With these conditions, the scheduler can adjust the end time of each application to reach the optimum objective. Instead, we consider a classic configuration in distributed computing, with online scheduling and atomic tasks. So, the best tradeoff is obtained by minimizing the maximum stretch among all applications.

We already presented a first design of this policy in  [12]. In this paper, we widely improve the estimation and representation of the stretch, to obtain much better results. In particular, the main problem we face is that computing ${\Theta }_i$ usually requires full knowledge of the platform. This is impractical with a decentralized design, so we assume two reasonable hypothesis:

• Each application has much less tasks than nodes in the platform.

• The distribution of computing power among nodes changes very little.

With these premises, we are able to minimize the maximum stretch without full knowledge of the platform.

The rest of the paper is organized as follows: Section  2 presents the related work on fair scheduling, both in centralized and decentralized environments. Then, Section  3 explains how we solve the problem of minimizing the maximum stretch without full knowledge of the platform. Section  4 gives a brief description of the architecture of STaRS, on which this paper is based. In Sections  5 FSP local policy, 6 FSP global policy, we explain the details of the FSP policy. And finally, Section  7 presents the results of the experiments and in Section  8 we give our conclusions and a description of the future work.