Backup Tasks Research Articles

Design adaptive task allocation scheduler to improve MapReduce performance in heterogeneous clouds

This paper conducted a thorough research on one of the critical technologies in cloud computing, the MapReduce programming model. Some of the past research results showed that one of the methods for enhancing MapReduce performance is the execution through allocating identical tasks to each cloud node. However, such allocation is not applicable for the environment of a heterogeneous cloud. Due to the different computing power and system resources between the nodes, such uniform distribution of tasks will lower the performance between nodes, and hence this paper makes improvements on the original speculative execution method of Hadoop (called Hadoop Speculative) and LATE Scheduler by proposing a new scheduling scheme known as Adaptive Task Allocation Scheduler (ATAS). The ATAS adopts more accurate methods to determine the response time and backup tasks that affect the system, which is expected to enhance the success ratio of backup tasks and thereby effectively increase the system’s ability to respond. We conducted three different simulation experiments, in which execution time of the LATE Scheduler and ATAS could be reduced by a maximum of 12% and 30%, increased the average tasks throughput by a maximum of 13% and 33%, and reduced the average tasks latency by a maximum of 25% and 36% compared to Hadoop Speculative; the ATAS can effectively enhance the processing performance of MapReduce to be compared with LATE Scheduler in a heterogeneous cloud environment.

Performance analysis of backup-task scheduling with deadline time in cloud computing

In large-scale parallel job processing for cloud computing, a huge task is divided into subtasks, which are processed independently on a cluster of machines called workers. Since the task processing lasts until all the subtasks are completed, a slow worker machine makes the overall task-processing time long, degrading the task-level throughput. In order to alleviate the performance degradation, MapReduce conducts backup execution, in which the master node schedules the remaining in-progress subtasks when the whole task operation is close to completion. In this paper, we investigate the effect of backup tasks on the task-level throughput. We consider the backup-task scheduling in which a backup subtask for a worker starts when the subtask-processing time of the worker reaches the deadline time. We analyze the task-level processing-time distribution by considering the maximum subtask-processing time among workers. The task throughput and the amount of all the workers' processing times are derived when the worker-processing-time (WPT) follows a hyper-exponential, Weibull, and Pareto distribution. We also propose an approximate method to derive performance measures based on extreme value theory. The approximations are validated by Monte Carlo simulation. Numerical examples show that the performance improvement by backup tasks significantly depends on workers' processing time distribution.

Research of Hadoop Task Speculative Execution Based on Process Migration

Current Hadoop platform task speculative execution can’t guarantee the backup task execution speed. This paper proposes a Hadoop speculative execution mechanism based on process migration. The backup task initializes the Task state with ExecutionState object which is formed according to the original task status. Thus, the backup task can continue the task instead of restarting a new task, this makes sure the backup task is more efficient than the original task. The results of running jobs on the hadoop platform prove that task speculative execution based on progress migration improves the efficiency greatly.

Research on MapReduce Task Dynamic Balancing Strategy Based on File Label

MapReduce is one of the core framework of Hadoop, it’s computing performance has been widely concerned and researched. In heterogeneous environment, unreasonable map task assignments and inefficient resource utilization lead to multiple backup tasks and the job total execution time is poor.For these problems, this paper proposes a new map task assignment strategy, which is map task dynamic balancing strategy based on file label. The strategy marks on job according to the different types, estimates node computing capabilities and historical processing efficiency of each label task, ensures map task which was assigned can execute successfully. Experiments show that, the strategy can effectively reduce number of backup tasks in map phase, and to some extent optimize the total execution time of the job.

Energy-aware standby-sparing for fixed-priority real-time task sets

For mission- and safety-critical real-time embedded systems, energy efficiency and reliability are two important design objectives that must be often achieved simultaneously. Recently, the standby-sparing scheme that uses a primary processor and a spare processor has been exploited to provide fault tolerance while keeping the energy consumption under control through DVS and DPM techniques. In this paper, we consider the standby-sparing technique for fixed-priority periodic real-time tasks. We propose a dual-queue mechanism through which the executions of backup tasks are maximally delayed, as well as online algorithms to manage energy consumption. Our experimental results show that the proposed scheme provides energy savings over time-redundancy based techniques while offering reliability improvements.

멀티코어 프로세서상의 실시간 태스크들을 위한 중복 실행에 기반한 저전력 결함포용 스케줄링

제시된 기법은 실시간 태스크들의 데드라인들을 만족하고 또한 기본-백업 태스크 모델을 사용하여 영구 결함을 포용하면서 멀티코어 프로세서의 에너지 소모량을 최소화하도록 태스크들을 스케줄링한다. 기존의 방법들이 기본 태스크와 백업 태스크의 중복 수행 시간을 최소화하도록 태스크들을 스케줄링했지만, 제시된 기법에서는 코어 속도를 최대한 줄이기 위해서 기본 태스크와 백업 태스크의 중복 수행 시간을 최대화하여 에너지 소모량을 감소시켰다. 제시된 기법이 에너지 소모량을 최소화시킴을 수학적으로 분석하였고, 또한 성능평가 실험을 통해서 제시된 기법이 기존 방법의 에너지 소모량을 최대 77%까지 감소시킴을 보였다. The proposed scheme schedules given real-time tasks so that energy consumption of multicore processors would be minimized while meeting tasks' deadline and tolerating a permanent fault based on the primary-backup task model. Whereas the previous methods minimize the overlapped time of a primary task and its backup task, the proposed scheme maximizes the overlapped time so as to decrease the core speed as much as possible. It is analytically verified that the proposed scheme minimizes the energy consumption. Also, the proposed scheme saves up to 77% energy consumption of the previous method through experimental performance evaluation.

Improving MapReduce Performance Using Smart Speculative Execution Strategy

MapReduce is a widely used parallel computing framework for large scale data processing. The two major performance metrics in MapReduce are job execution time and cluster throughput. They can be seriously impacted by straggler machines-machines on which tasks take an unusually long time to finish. Speculative execution is a common approach for dealing with the straggler problem by simply backing up those slow running tasks on alternative machines. Multiple speculative execution strategies have been proposed, but they have some pitfalls: (i) Use average progress rate to identify slow tasks while in reality the progress rate can be unstable and misleading, (ii) Cannot appropriately handle the situation when there exists data skew among the tasks, (iii) Do not consider whether backup tasks can finish earlier when choosing backup worker nodes. In this paper, we first present a detailed analysis of scenarios where existing strategies cannot work well. Then we develop a new strategy, maximum cost performance (MCP), which improves the effectiveness of speculative execution significantly. To accurately and promptly identify stragglers, we provide the following methods in MCP: (i) Use both the progress rate and the process bandwidth within a phase to select slow tasks, (ii) Use exponentially weighted moving average (EWMA) to predict process speed and calculate a task's remaining time, (iii) Determine which task to backup based on the load of a cluster using a cost-benefit model. To choose proper worker nodes for backup tasks, we take both data locality and data skew into consideration. We evaluate MCP in a cluster of 101 virtual machines running a variety of applications on 30 physical servers. Experiment results show that MCP can run jobs up to 39 percent faster and improve the cluster throughput by up to 44 percent compared to Hadoop-0.21.

Performance analysis of large-scale parallel-distributed processing with backup tasks for cloud computing

In cloud computing, a large-scale parallel-distributed processing service is provided where a huge task is split into a number of subtasks and those subtasks are processed on a cluster of machines called workers. In such a processing service, a worker which takes a long time for processing a subtask makes the response time long (the issue of stragglers). One of efficient methods to alleviate this issue is to execute the same subtask by another worker in preparation for the slow worker (backup tasks). In this paper, we consider the efficiency of backup tasks. We model the task-scheduling server as a single-server queue, in which the server consists of a number of workers. When a task enters the server, the task is split into subtasks, and each subtask is served by its own worker and an alternative distinct worker. In this processing, we explicitly derive task processing time distributions for the two cases that the subtask processing time of a worker obeys Weibull or Pareto distribution. We compare the mean response time and the total processing time under backup-task scheduling with those under normal scheduling. Numerical examples show that the efficiency of backup-task scheduling significantly depends on workers' processing time distribution.

HAT: history-based auto-tuning MapReduce in heterogeneous environments

In MapReduce model, a job is divided into a series of map tasks and reduce tasks. The execution time of the job is prolonged by some slow tasks seriously, especially in heterogeneous environments. To finish the slow tasks as soon as possible, current MapReduce schedulers launch a backup task on other nodes for each of the slow tasks. However, traditional MapReduce schedulers cannot detect slow tasks correctly since they cannot estimate the progress of tasks accurately (Hadoop home page http://hadoop.apache.org/ , 2011; Zaharia et al. in 8th USENIX symposium on operating systems design and implementation, ACM, New York, pp. 29---42, 2008). To solve this problem, this paper proposes a History-based Auto-Tuning (HAT) MapReduce scheduler, which calculates the progress of tasks accurately and adapts to the continuously varying environment automatically. HAT tunes the weight of each phase of a map task and a reduce task according to the value of them in history tasks and uses the accurate weights of the phases to calculate the progress of current tasks. Based on the accurate-calculated progress of tasks, HAT estimates the remaining time of tasks accurately and further launches backup tasks for the tasks that have the longest remaining time. Experimental results show that HAT can significantly improve the performance of MapReduce applications up to 37% compared with Hadoop and up to 16% compared with LATE scheduler.

ABCGrid: Application for Bioinformatics Computing Grid

We have developed a package named Application for Bioinformatics Computing Grid (ABCGrid). ABCGrid was designed for biology laboratories to use heterogeneous computing resources and access bioinformatics applications from one master node. ABCGrid is very easy to install and maintain at the premise of robustness and high performance. We implement a mechanism to install and update all applications and databases in worker nodes automatically to reduce the workload of manual maintenance. We use a backup task method and self-adaptive job dispatch approach to improve performance. Currently, ABCGrid integrates NCBI_BLAST, Hmmpfam and CE, running on a number of computing platforms including UNIX/Linux, Windows and Mac OS X. The source code, executables and documents can be downloaded from http://abcgrid.cbi.pku.edu.cn

Training neural-net controllers with the help of trajectories generated with fuzzy rules (demonstrated with the truck backup task)

In controls, it is known that control path planning is a task quite different from that of “next-step” control action generation. This is, for example, why training a neural-net controller for the truck backup task is so tedious; the appropriate backing trajectories have to be discovered by trial and error before the net can be depended on to behave well in a “next-step” manner. In this paper we suggest and demonstrate that this awkwardness can be circumvented by supplying a certain amount of overall system knowledge with use of trajectories (system paths) generated with fuzzy logic, and training the neural-net controller to learn how to generate next-step control actions more or less in conformance with those trajectories. The fuzzy rules and membership functions need not be optimum. The neural-net controller trained in this way performs in a manner superior to that of the fuzzy controller. We demonstrate these circumstances with the truck backup task, using a functional-link net, and making use of only 4 trajectories generated with fuzzy rules.

Error recovery in a real-time multiprocessor system

In this paper, a new scheme for recovering errors due to transient faults in a real-time multiprocessor system is presented. The scheme, called dynamic redundancy at the task level, is implemented in a real-time multitasking environment. Utilizing the facilities in the operating system, the scheme makes backup tasks for the primary tasks as redundancy. The paper introduces an algorithm to generate a fault tolerant schedule for the tasks so that they recover errors as retry or checkpointing does. A reliability model is proposed to evahuste the effectiveness of the scheme.

G8.1: Error Recovery in Distributed Computer Networks to Process Control

In a distributed computer network dynamic redundance can be used to improve system reliability. After detection of a node or module failure processing is taken over by a backup task located on another computer of the network. Before resumption of processing a prior system state has to be restored. Thereby the interactions of tasks have to be considered. In order to accelerate the restoration procedure it is important that each task can determine the extent of backtracking and the restart moment only on the basis of informations about its own interactions. The known “Chase Protocol” has been adopted to control the restoration process. Thereby it has shown, that in distinct error situations a task local decision about recovery points is only possible, if all informations about interactions have been saved. Finally the problems are discussed, which restrict the use of a backward recovery technique in the context of process control