Task Precedence Graph Research Articles

Resource-Constrained Replication Strategies for Hierarchical and Heterogeneous Tasks

In large-scale cloud computing systems, a task is often divided into multiple subtasks which can be executed in parallel in different machines. As a result, the task completion time is constrained by the completion time of the slowest subtask. To reduce the task completion time, the strategy of replicating the straggling subtasks has been employed in cloud computing frameworks such as MapReduce and Hadoop. Analyzing mathematically the performance of such replication strategies has recently received great attention. However, most of the analytical work focuses on the case where the completion times of the subtasks are identically distributed. This assumption may not hold in practice due to the modularization and encapsulation of the computation of a task, resulting in different service requirements for different subtasks. In this paper, we consider the case where the completion times of the subtasks of a task are drawn from heterogeneous/empirical distributions. Furthermore, we consider the case where jobs consist of hierarchical tasks that are required to be executed in a specific order described by a task precedence graph. We propose a novel framework to investigate how to allocate replication resources among the subtasks such that the overall task completion time is minimized. Specifically, we devise a Lagrange multiplier-based method and a water-filling-like algorithm for integer programs. We show via analysis and simulations the optimality and efficiency of our proposed algorithms, and explore the tradeoff between cost and latency from introducing replications in a task graph.

Deadlock-Free Consecutive Task Assignment of Multiple Heterogeneous Unmanned Aerial Vehicles

This paper presents an integrated approach based on graph theory for solving the deadlock problem in the cooperative task assignment of multiple heterogeneous unmanned aerial vehicles, which is concerned with the cooperative decision making and control. Because of heterogeneity, one task cannot be performed by arbitrary vehicles in the heterogeneous group. A vehicle that performs multiple tasks on targets needs to change its path, waiting for others if another vehicle that executes a former or simultaneous task has not finished or arrived. This creates risks of deadlock. Two or more vehicles may fall into a situation of infinite waiting due to shared resources and precedence constraints among various tasks. In this work, a task-precedence graph of solutions is constructed and analyzed for detecting deadlocks. And transposing operations are used to unlock solutions that involved in deadlocks. In addition, the topological sort of tasks is used in the path elongation of vehicles. Thus, deadlock-free solutions are obtained, and the path coordination is done. Computational experiments are conducted to check the performance of the approach, and the results validate the effectiveness.

Scheduling imprecise task graphs for real-time applications

Many of the real-time tasks within embedded real-time control applications fall into the imprecise category. Such tasks are iterative in nature, with output precision improving as execution time increases (up to a point). These tasks can be terminated early at the cost of poorer quality output. Many imprecise tasks in CPS are dependent, with one task feeding other tasks in a task precedence graph (TPG). A task output quality depends on the quality of its input data as well as on the execution time that is allotted to it. In this paper, we study the allocation/scheduling of imprecise TPGs on multiprocessors to maximise output quality where resources (time and energy) are limited. Our heuristic algorithms can effectively reclaim resources when tasks finish earlier than their estimated worst-case execution time. Dynamic voltage scaling is used to manage energy consumption and keep it under a specified bound.

Optimal Scheme for Search State Space and Scheduling on Multiprocessor Systems

A scheduling algorithm aims to minimize the overall execution time of the program by properly allocating and arranging the execution order of the tasks on the core processors such that the precedence constraints among the tasks are preserved. In this paper, we present a new scheduling algorithm by using geometry analysis of the Task Precedence Graph (TPG) based on A* search technique and uses a computationally efficient cost function for guiding the search with reduced complexity and pruning techniques to produce an optimal solution for the allocation/scheduling problem of a parallel application to parallel and multiprocessor architecture. The main goal of this work is to significantly reduce the search space and achieve the optimality or near optimal solution. We implemented the algorithm on general task graph problems that are processed on most of related search work and obtain the optimal scheduling with a small number of states. The proposed algorithm reduced the exhaustive search by at least 50% of search space. The viability and potential of the proposed algorithm is demonstrated by an illustrative example.

On a parallel machine scheduling problem with precedence constraints

We characterize a nontrivial special case with a polynomial-time algorithm for a well-known parallel machine scheduling problem with precedence constraints, with a fixed number of machines, and with tasks of unit length. The special case is related to instances with given maximum path length and maximum degree of the task precedence graph. The method is based on the observation that the number of tasks is either small and bounded by a constant depending on the maximum path length and maximum degree, or alternatively, the number of tasks is large, giving a "dense" schedule.

Modeling Clustered Task Graphs for Scheduling Large Parallel Programs in Distributed Systems

The recent development of distributed processing platforms, such as clusters of workstations, makes the use of distributed applications more extensive. A fundamental issue affecting performance in distributed systems is the scheduling of tasks to processors. The problem of solving the scheduling of parallel programs modelled with a task precedence graph (TPG) has been extensively studied. Scheduling algorithms of TPGs can be solved by a one-step method when a fixed number of processors is considered or through a two-step method by first creating an unbounded number of groups of tasks (clusters) and subsequently assigning these clusters to a bounded number of processors. The goal of this work is to present a new mapping algorithm called TASC (Task ASsignment exploiting Concurrency) to solve this second step of assigning clusters to processors. The effectiveness of TASC is established through simulation for a set of synthetic graphs that model real applications.

A TABU SEARCH APPROACH TO TASK SCHEDULING ON HETEROGENEOUS PROCESSORS UNDER PRECEDENCE CONSTRAINTS

Parallel programs may be represented as a set of interrelated sequential tasks. When multiprocessors are used to execute such programs, the parallel portion of the application can be speeded up by an appropriate allocation of processors to the tasks of the application. Given a parallel application defined by a task precedence graph, the goal of task scheduling (or processor assignment) is thus the minimization of the makespan of the application. In a heterogeneous multiprocessor system, task scheduling consists of determining which tasks will be assigned to each processor, as well as the execution order of the tasks assigned to each processor. In this work, we apply the tabu search metaheuristic to the solution of the task scheduling problem on a heterogeneous multiprocessor environment under precedence constraints. The topology of the Mean Value Analysis solution package for product form queueing networks is used as the framework for performance evaluation. We show that tabu search obtains much better results, i.e., shorter completion times, improving from 20 to 30% the makespan obtained by the most appropriate algorithm previously published in the literature.

A Heuristic of Scheduling Parallel Tasks and Its Analysis

This paper investigates the problem of nonreconfigurable, nonpreemptive scheduling of parallel tasks in a homogeneous system of processors. Given a task precedence graph where each task T may be executed on up to $\delta (T)$ processors, the problem is to find a schedule such that the makespan is minimized. A scheduling policy is nonreconfigurable if when more processors become available after a task T has been scheduled on p processors, $p < \delta (T)$, they cannot join the execution of task T. It is nonpreemptive if each task is executed without interruption until completion once the task has started execution. The problem of scheduling parallel tasks is NP-hard. The performance ratio of the makespan produced by the original list scheduling algorithm proposed by Graham [SIAM J. Appl. Math., 17 (1969), pp. 416–429] to the optimal makespan is $\Delta + \frac{m - \Delta} {m}$ [Inform. Process. Lett., 37 (1991), pp. 291–297], where m and $\Delta $ are the number of processors in the system and the maximum ...

MAPPING BINARY PRECEDENCE TREES TO HYPERCUBES

This paper addresses the problem of mapping the modules of a task precedence graph to the processing elements of a parallel computer. The goal of the mapping is to minimize the total execution time of the task, sum of the computation and communications time, within a processor network of limited size. We consider the special instance where the precedence graph is a binary precedence tree. We present a linear time procedure for mapping an almost full binary precedence tree of n nodes to any p processor hypercube, with unit dilation cost and optimal execution time. The computation time under the mapping is seen to be O ( n/p ) and the communications time is seen to be log p.

Two-processor system for LU factorization of five-diagonal matrix

A parallel algorithm is described for LU decomposition of five-diagonal matrices suitable for implementation on a general purpose multiprocessor system. Solving grain size and load-balancing problems were of primary importance in the proposed algorithm. According to the task precedence graph for the proposed mathematical model, the conclusion is reached that the optimal number of processors in the multiprocessor system is two. Thanks to good load-balancing obtained by the proposed mathematical model the number of communications is not extensive, so really high parallelism is obtained. Two different architectures are proposed: the first is of bus-connect type with sharable memory; in the second the connection between the processors is realized by dual-port RAM. The processors are of single-board computer (SBC) type.

Performance evaluation of fork and join synchronization primitives

The paper presents a performance model of fork and join synchronization primitives. The primitives are used in parallel programs executed on distributed systems. Three variants of the execution of parallel programs with fork and join primitives are considered and queueing models are proposed to evaluate their performance on a finite number of processors. Synchronization delays incurred by the programs are represented by a state-dependent server with service rate depending on a particular synchronization scheme. Closed form results are presented for the two processor case and a numerical method is proposed for many processors. Fork-join queueing networks having more complex structure i.e., processors arranged in series and in parallel, are also analyzed in the same manner. The networks can model the execution of jobs with a general task precedence graph corresponding to a nested structure of the fork-join primitives. Some performance indices of the parallel execution of programs are studied. The results show that the speedup which can be obtained theoretically in a parallel system may be decreased significantly by synchronization constraints.