Deadline-Aware MapReduce Job Scheduling with Dynamic Resource Availability

Job scheduling for a MapReduce cluster has been an active research topic in recent years. However, measurement traces from real-world production environment show that the duration of tasks within a job vary widely. The overall elapsed time of a job, i.e. The so-called flow time, is often dictated by one or few slowly-running tasks within a job, generally referred as the stragglers. The cause of stragglers include tasks running on partially/intermittently failing machines or the existence of some localized resource bottleneck(s) within a MapReduce cluster. To tackle this online job scheduling challenge, we adopt the task cloning approach and design the corresponding scheduling algorithms which aim at minimizing the weighted sum of job flow times in a MapReduce cluster based on the Shortest Remaining Processing Time scheduler (SRPT). To be more specific, we first design a 2-competitive offline algorithm when the variance of task-duration is negligible. We then extend this offline algorithm to yield the so-called SRPTMS+C algorithm for the online case and show that SRPTMS+C is (1+a#x220A;) -- speed o(1/a#x220A;2) -- competitive in reducing the weighted sum of job flow times within a cluster. Both of the algorithms explicitly consider the precedence constraints between the two phases within the MapReduce framework. We also demonstrate via trace-driven simulations that SRPTMS+C can significantly reduce the weighted/unweighted sum of job flow times by cutting down the elapsed time of small jobs substantially. In particular, SRPTMS+C beats the Microsoft Mantri scheme by nearly 25% according to this metric.

As one of the most popular frameworks for large-scale analytics processing, Hadoop is facing two challenges: both applications and storage devices become heterogeneous. However, existing data placement and job scheduling schemes pay little attention to such heterogeneity of either application I/O requirements or I/O device capability, thus can greatly degrade system efficiencies. In this paper, we propose ASPS, an Application and Storage-aware data Placement and job Scheduling approach for Hadoop clusters. The idea is to place application data and schedule application tasks considering both application I/O requirements and storage device characteristics. Specifically, ASPS first introduces novel metrics to quantify I/O requirements of applications. Then, based on the quantification, ASPS places data of different applications to the preferred storage devices. Finally, ASPS tries to launch jobs with high I/O requirements on the nodes with the same type of faster devices to improve system efficiency. We have implemented ASPS in Hadoop framework. Experimental results show that ASPS can reduce the completion time of a single application by up to 36% and the average completion time of six concurrent applications by 27%, compared to existing data placement policies and job scheduling approaches.

This paper presents a new approach to scheduling jobs on a service Grid using a genetic algorithm (GA). A fitness function is defined to minimize the average execution time of scheduling N jobs to M(≤ N) machines on the Grid. Two models are proposed to predict the execution time of a single job or multiple jobs on each machine with varied system load. The single service type model is used to schedule jobs of one single service to a machine while the multiple service types model schedules jobs of multiple services to a machine. The predicted execution times from these models are used as input to the genetic algorithm to schedule N jobs to M machines on the Grid. Experiments on a small Grid of four machines have shown a significant reduction of the average execution time by the new job scheduling approach.

In this paper, we study the problem of job dispatching and scheduling, where each job consists of a set of tasks. Each task is processed by a set of machines simultaneously. We consider two important performance metrics, the average job completion time (JCT), and the number of deadline-aware jobs that meet their deadlines. The goal is to minimize the former and maximize the latter. We first propose OneJ to minimize the job completion time (JCT) when there is exactly one single job in the system. Then, we propose an online algorithm called MultiJ, taking OneJ as a subroutine, to minimize the average JCT, and prove it has a good competitive ratio. We then derive another online algorithm QuickJ to maximize the number of jobs that can meet their deadlines. We show that QuickJ is competitive via a worst case analysis. We also conjecture that the competitive ratio of QuickJ is likely to be the best one that any deterministic algorithm can achieve. We also shed light on several important merits of MultiJ and QuickJ, such as no severe coordination overhead, scalability, work conservation, and no job starvation.

MapReduce is now a significant parallel processing model for large-scale data-intensive applications using clusters with commodity hardware. Scheduling of jobs and tasks, and identification of TaskTrackers which are slow in Hadoop clusters are the focus research in the recent years. MapReduce performance is currently limited by its default scheduler, which does not adapt well in heterogeneous environments. In this paper, we propose a scheduling method to identify the TaskTrackers which are running slowly in map and reduce phases of the MapReduce framework in a heterogeneous Hadoop cluster. The proposed method is integrated with the MapReduce default scheduling algorithm. The performance of this method is compared with the unmodified MapReduce default scheduler. We observe that the proposed approach shows improvements in performance to the default scheduler in the heterogeneous environments. Performance improvement was observed as the overall job execution times for different workloads from HiBench benchmark suite were reduced.

It was studied with the problem of scheduling jobs in batches on-line on 2 identical parallel machines with objective to minimize the maximum completion time (the completion time of the last job: makespan), where batches arrive over list and every batch has exactly m jobs, and the processing times are constrained in some interval. When a batch arrives we schedule the jobs in this batch immediately and irrevocably without the knowledge of later batches. The pre-emption is not allowed. An algorithm with scheduling jobs in every batch by LPT rule was proposed. When all the jobs in pre-batch are scheduled we schedule the jobs in the following batch. The worst case was analyzed and the worst case ratio dependent with number of jobs in batch was given, and the conclusion was proved by procedure.

Big Data research can be divided broadly into the scheduling of jobs and controlling the rate at which jobs are generating and running. Hadoop YARN provides better resource management schemes to schedule jobs by having a focus on the reduction of total time required to complete the jobs. This paper provides a study of scheduling algorithms in Hadoop YARN and evaluates the performance of two scheduling algorithm, fair scheduling and capacity scheduling using Yarn Scheduler Load Simulator (SLS). The result of this evaluation can be used further to enhance the capabilities of scheduling algorithm in different type of data sets.

A new approach for dynamic job scheduling in mesh-connected multiprocessor systems, which supports a multiuser environment, is proposed in this paper. Our approach combines a submesh reservation policy with a priority-based scheduling policy to obtain high performance in terms of high throughput, high utilization, and low turn-around times for jobs. This high performance is achieved at the expense of scheduling jobs in a strictly fair, FCFS fashion; in fact, the algorithm is parameterized to allow trade-offs between performance and (short-term) POPS fairness. The proposed scheduler can be used with any submesh allocation policy. A fast and efficient implementation of the proposed scheduler has also been presented. The performance of the proposed scheme has been compared with the FCFS policy, the only existing scheduling strategy for meshes, to demonstrate the effectiveness of the proposed approach. Simulation results indicate that our scheduling strategy outperforms the FCFS policy significantly. Specifically, our strategy significantly reduces the average waiting delay of jobs over the FCFS policy. The fast implementation of the proposed scheduler results in low allocation and deallocation time overhead, as well as low space overhead.

Fair and Delay Adaptive Scheduler (FDAS) is a scheduling mechanism that dynamically adapts to the incoming traffic flows' requirements in term of bandwidth allocation, delay bounds and packet loss restrictions. It performs this utilizing both virtual finish time fluid scheduling along with schedulability and delay sensitive scheduling. The former ensures that the flows receive a fair share of the available output throughput while the later ensures that time critical flows that are about to expire will receive preferential treatment when needed to avoid getting garbled and dropped when possible. FDAS tries to maximize the satisfaction as perceived by incoming traffic flows through balancing between bandwidth fairness and delay bound accommodation. FDAS acts as a hybrid scheduler that tries to overcome fairness allocation problems due to preferential treatment for the soon-to-expire packets which happens in Earliest Deadline First (EDF) schedulers. Meanwhile, it tries to minimize the number of packets that violate their deadlines for transmission and get garbled accordingly that happens on Weighted Fair Queuing (WFQ) and its derivatives. In this paper, we try to answer the question of how many of the flows and how much of their traffic can be accommodated in terms of delay bound and throughput requirements given the incoming mixture of traffic with diverse QoS requirements. FDAS preliminary modeling and optimization is discussed in this paper to answer the above question in a manner that maximizes the overall performance satisfaction as perceived by incoming flows taking into consideration traffic priorities, if any.

Optimizing makespan and resource utilization for multi-DNN training in GPU cluster

Efficient scheduling of jobs for computer systems is a problem of continuing concern. The applicability of scheduling methodology described in the operations research literature is severely restricted by the dimensionality of job characteristics, the number of distinct resource types comprising a computer system, the non-deterministic nature of the system due to both interprocess interaction and contention, and the existence of a multitude of constraints effecting job initiation times, job completion times, and job interactions. In view of the large number of issues which must be considered in job scheduling, a heuristic approach seems appropriate. This paper describes an initial implementation of such an approach based upon a fast, analytically driven, performance prediction tool.

It has become routine for large volumes of data to be generated, stored, and processed across geographically distributed datacenters. To run a single data analytic job on such geo-distributed data, recent research proposed to distribute its tasks across datacenters, considering both data locality and network bandwidth across datacenters. Yet, it remains an open problem in the more general case, where multiple analytic jobs need to fairly share the resources at these geo-distributed datacenters. In this paper, we focus on the problem of assigning tasks belonging to multiple jobs across datacenters, with the specific objective of achieving max-min fairness across jobs sharing these datacenters, in terms of their job completion times. We formulate this problem as a lexicographical minimization problem, which is challenging to solve in practice due to its inherent multi-objective and discrete nature. To address these challenges, we iteratively solve its single-objective subproblems, which can be transformed to equivalent linear programming (LP) problems to be efficiently solved, thanks to their favorable properties. As a highlight of this paper, we have designed and implemented our proposed solution as a fair job scheduler based on Apache Spark, a modern data processing framework. With extensive evaluations of our real-world implementation on Amazon EC2 and large-scale simulations, we have shown convincing evidence that max-min fairness has been achieved and the worst job completion time has been significantly improved using our new job scheduler.

Temperature-induced reliability issues are among the major challenges for multicore architectures. Thermal hot spots and thermal cycles combine to degrade reliability. This research presents new reliability-aware job scheduling and power management approaches for chip multiprocessors. Accurate evaluation of these policies requires a novel simulation framework that can capture architecture-level effects over tens of seconds or longer, while also capturing thermal interactions among cores resulting from dynamic scheduling policies. Using this framework and a set of new thermal management policies, this work shows that techniques that offer similar performance, energy, and even peak temperature can differ significantly in their effects on the expected processor lifetime.

Recent Infrastructure-as-a-Service offers, such as Amazon's EC2 cloud, provide virtualized on-demand computing resources on a pay-per-use model. From the user point of view, the cloud provides an inexhaustible supply of resources, which can be dynamically claimed and released. This drastically changes the problem of resource provisioning and job scheduling. This article presents how billing models can be exploited by provisioning strategies to find a trade-off between fast/expensive computations and slow/cheap ones for indepedent sequential jobs. We study a dozen strategies based on classic heuristics for online scheduling and bin-packing problems, with the double objective of minimizing the wait time (and hence the completion time) of jobs and the monetary cost of the rented resources. We simulate these strategies on real grid workloads in two cases. First, we use the workloads as a whole, which is representative of a large community of users sharing some common resources. Second, we use the workloads extracted for each individual user. These lighter workloads correspond to users submitting work independently from others and paying for their own resources. Our findings show that on large workloads, a little budget increase allows to achieve optimal wait time, while trade-off heuristics may be largely beneficial for individual users with lighter workloads.

Increasing demands for distributed machine learning (DML) have posed significant pressure on data-center networks (DCNs). This promotes the adoption of reconfigurable all-optical interconnects (AOI) in DCNs leveraging optical circuit switching (OCS) for better performance on throughput, energy efficiency, and data transfer latency. Despite their benefits, these OCS-based DCNs (ODCNs) still bear limited flexibility due to the larger switching granularity and longer reconfiguration latency of OCS. To address this issue, this work introduces in-network computing (INC) in an ODCN to realize P4INC-AOI, which can orchestrate INC and AOI to explore their mutual benefits for accelerating the training of DML jobs with less AOI reconfigurations. In the control plane of P4INC-AOI, we address the scheduling of concurrent DML jobs by formulating a mixed integer linear programming (MILP) model and proposing a time-efficient heuristic, to allocate multi-dimensional resources and configure AOI for minimizing the longest job completion time (JCT) across workloads. For the data plane, we extend existing in-network gradient aggregation schemes to accelerate DML jobs more efficiently. We first implement P4INC-AOI and verify its performance in a small-scale ODCN testbed, and further justify its effectiveness with large-scale simulations. Our experimental results demonstrate that compared with an ODCN without INC, P4INC-AOI not only cuts down AOI reconfigurations effectively but also reduces the average JCT of DML jobs in ResNet50 and VGG16 by <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <tex-math notation="LaTeX">$46.66\%$</tex-math> </inline-formula> and <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <tex-math notation="LaTeX">$56.34\%$</tex-math> </inline-formula> , respectively.