Scheduling Of Parallel Tasks Research Articles

Efficient scientific workflow scheduling for deadline-constrained parallel tasks in cloud computing environments

Data centers for cloud computing must accommodate numerous parallel task executions simultaneously. Therefore, data centers have many virtual machines (VMs). Minimizing the scheduling length of parallel task sets becomes a critical requirement in cloud computing systems. In this study, we propose an efficient priority and relative distance (EPRD) algorithm to minimize the task scheduling length for precedence constrained workflow applications without violating the end-to-end deadline constraint. This algorithm consists of two processes. First, a task priority queue is established. Then, a VM is mapped for a task in accordance with its relative distance. The proposed method can effectively improve VM utilization and scheduling performance. Extensive rigorous experiments based on randomly generated and real-world workflow applications demonstrate that the resource reduction rate and scheduling length of the EPRD algorithm significantly surpass those of existing algorithms.

Algorithms for Computing the WCRT Bound of OpenMP Task Systems With Conditional Branches

Multi-cores are becoming mainstream hardware platforms for embedded and real-time systems. To fully utilize the processing capacity of multi-cores, software should be parallelized. Recently, much work has been done on real-time scheduling of parallel tasks modeled as directed acyclic graphs (DAG), motivated by the parallel task structures supported by popular parallel programming frameworks such as OpenMP. The DAG-based task models in existing real-time scheduling research assume well-nested graph structures recursively composed by single-source-single-sink parallel and conditional components. However, realistic OpenMP task systems in general have more flexible structures that do not comply with those assumptions. In this article, we model the behavior of general OpenMP task systems with non-well-nested structures. The worst-case response time analysis problem for such systems is more difficult due to the flexible graph structure. As the major technical contribution, we develop two efficient algorithms to compute the worst-case response time bounds, with different trade-offs between efficiency and precision. Evaluation with both randomly generated task graphs and realistic OpenMP programs shows good performance of our approaches in terms of both precision and efficiency.

Real-time scheduling of parallel tasks with tight deadlines

Abstract Real-time systems are shifting from single-core to multi-core processors, on which software must be parallelized to fully utilize their computation power. Recently, different types of scheduling algorithms have been proposed for parallel real-time tasks modeled as directed acyclic graphs (DAG), among which federated scheduling shows its superiority in real-time performance. However, the performance of federated scheduling seriously degrades for tasks with tight relative deadlines (the gap between the relative deadline and the longest path length is small). In this paper, we propose new methods based on federated scheduling to solve this problem by exploring the intra-task structure information. By our new methods, each heavy task is transformed into a set of independent sporadic sub-tasks with the guidance of its intra-task structure information, such that the number of processors required is reduced. We conduct experiments to evaluate our proposed approach against the state-of-the-art methods of different types of scheduling algorithms. Experimental results show that our approach consistently outperforms all of the compared methods under different parameter settings, especially for task sets consisting of tasks with tight deadlines.

Real-Time scheduling and analysis of parallel tasks on heterogeneous multi-cores

Heterogeneous multi-cores and parallel architectures have recently gained much attention owing to utilizing the strength of different architectures for offering higher performance. In this paper, we study the real-time scheduling of the directed acyclic graph (DAG) tasks upon the heterogeneous multi-core platform, i.e., a task contains different types of vertices, and the workload of each vertex must execute on its particular type of cores. Traditional researches use the work-conserving scheduling strategy to schedule such a typed DAG task and lead to pessimistic schedulability tests. To this end, we propose a novel scheduling algorithm for typed DAG tasks, which assigns each vertex a varying criticality that depends on the remaining workload of the vertex, and moreover, the vertex with higher criticality is more urgent to be executed. Under this scheduling strategy, we propose a new worst-case response time (WCRT) bound to verify the schedulability of DAG task supporting heterogeneous computing. Experiments with randomly generated workload show that the accuracy of our new WCRT is about 20% higher on average than the existing bounds.

Response Time Bounds for Typed DAG Parallel Tasks on Heterogeneous Multi-Cores

Heterogeneous multi-cores utilize the strength of different architectures for executing particular types of workload, and usually offer higher performance and energy efficiency. In this paper, we study the worst-case response time (WCRT) analysis of \emph{typed} scheduling of parallel DAG tasks on heterogeneous multi-cores, where the workload of each vertex in the DAG is only allowed to execute on a particular type of cores. The only known WCRT bound for this problem is grossly pessimistic and suffers the \emph{non-self-sustainability} problem. In this paper, we propose two new WCRT bounds. The first new bound has the same time complexity as the existing bound, but is more precise and solves its \emph{non-self-sustainability} problem. The second new bound explores more detailed task graph structure information to greatly improve the precision, but is computationally more expensive. We prove that the problem of computing the second bound is strongly NP-hard if the number of types in the system is a variable, and develop an efficient algorithm which has polynomial time complexity if the number of types is a constant. Experiments with randomly generated workload show that our proposed new methods are significantly more precise than the existing bound while having good scalability.

Real-Time Scheduling of DAG Tasks with Arbitrary Deadlines

Real-time and embedded systems are shifting from single-core to multi-core processors, on which the software must be parallelized to fully utilize the computation capacity of the hardware. Recently, much work has been done on real-time scheduling of parallel tasks modeled as directed acyclic graphs (DAG). However, most of these studies assume tasks to have implicit or constrained deadlines. Much less work considered the general case of arbitrary deadlines (i.e., the relative deadline is allowed to be larger than the period), which is more difficult to analyze due to intra-task interference among jobs. In this article, we study the analysis of Global Earliest Deadline First (GEDF) scheduling for DAG parallel tasks with arbitrary deadlines. We develop new analysis techniques for GEDF scheduling of a single DAG task and this new analysis techniques can guarantee a better capacity augmentation bound 2.41 (the best known result is 2.5) in the case of a single task. Furthermore, the proposed analysis techniques are also extended to the case of multiple DAG tasks under GEDF and federated scheduling. Finally, through empirical evaluation, we justify the out-performance of our schedulability tests compared to the state-of-the-art in general.

Intra-Task Priority Assignment in Real-Time Scheduling of DAG Tasks on Multi-Cores

Real-time scheduling and analysis of parallel tasks modeled as directed acyclic graphs (DAG) have been intensively studied in recent years. However, no existing work has explored the execution order of eligible vertices within a DAG task. In this paper, we show that this intra-task vertex execution order has a large impact on system schedulability and propose to control the execution order by vertex-level priority assignment. We develop analysis techniques to bound the worst-case response time for the proposed scheduling strategy and design heuristics for proper priority assignment to improve system schedulability as much as possible. We further extend the proposed approach to the general setting of multiple recurrent DAG tasks. Experiments with both realistic parallel benchmark applications and randomly generated workload show that our method consistently outperforms state-of-the-art methods with different task graph structures and parameter configurations.

Decomposition-Based Real-Time Scheduling of Parallel Tasks on Multicores Platforms

Multicore processors have become mainstream computation platforms not only for general and high-performance computers but also for real-time embedded systems. To fully utilize the computation power of multicores, software must be parallelized. Recently, there has been a rapidly increasing interest in real-time scheduling of parallel real-time tasks, but the field is still much less mature than traditional real-time scheduling of sequential tasks. In this article, we study the real-time scheduling and techniques for parallel real-time tasks based on decomposition, where a task graph is transferred to a set of independent sporadic tasks. In particular, we propose new decomposition strategies that better explore the structure feature of each task to improve schedulability. We develop schedulability tests for the global earliest deadline first (EDF) scheduling algorithm based on decomposition and three types of its variants, with their own pros and cons in different aspects. We conduct experiments to evaluate the real-time performance of our proposed scheduling algorithms against the state-of-the-art scheduling and analysis methods of different types.

Complexity and Inapproximability Results for Parallel Task Scheduling and Strip Packing

We study the Parallel Task Scheduling problem $Pm|size_j|C_{\max}$ with a constant number of machines. This problem is known to be strongly NP-complete for each $m \geq 5$, while it is solvable in pseudo-polynomial time for each $m \leq 3$. We give a positive answer to the long-standing open question whether this problem is strongly $NP$-complete for $m=4$. As a second result, we improve the lower bound of $\frac{12}{11}$ for approximating pseudo-polynomial Strip Packing to $\frac{5}{4}$. Since the best known approximation algorithm for this problem has a ratio of $\frac{4}{3} + \varepsilon$, this result narrows the gap between approximation ratio and inapproximability result by a significant step. Both results are proven by a reduction from the strongly $NP$-complete problem 3-Partition.

Chemical Reaction Multi-Objective Optimization for Cloud Task DAG Scheduling

Cloud computing systems often have two conflicting objective, maximizing service performance, and minimizing computing cost. The excellent task scheduling and resource allocation strategies can improve the cost/utility ratio efficiently. It is an NP-hard problem to optimize task scheduling of precedence-constrained parallel tasks represented by a directed acyclic graph (DAG) on the cloud system. In order to address this problem, a chemical reaction multi-objective optimization algorithm (CRMO) is proposed in this paper. The CRMO executes four chemical reaction operators (named on-wall ineffective collision, inter-molecular ineffective collision, decomposition, and synthesis) for cloud tasks DAG scheduling. The experimental results show that CRMO can produce outstanding cloud task scheduling solutions set.

Cloud rendering learning platform technology research for visual analysis of large scale 3D multimedia data

This paper designs and implements a cloud rendering system. The system supports application of server cluster load balancing, static extension of rendering machine, and design architecture of parallel task scheduling. At the same time, we put forward a new design idea, and we implement a set of communication rules of multi-task renderer and cloud rendering system. On the system, users could browse 3D scene online by mobile terminal equipments. The task of PC terminal users and mobile terminal users to access remote scenes could be high speed and real-time rendering by this system. In the end of this paper, we analyze the efficiency of our algorithm. Our system can achieve a better effect on the number of concurrent users and the average response delay. The average frame rate of system can reach 30–40 frames per second. Experimental results show that the proposed algorithm performs favorably against the state-of-the-art methods on the public test datasets.

Contention-Aware Reliability Efficient Scheduling on Heterogeneous Computing Systems

Energy efficiency and system reliability are the two main measurements in modern high-performance computing. The majority of previous recent studies have focused on realizing parallel task scheduling with low energy consumption or fast execution time. These approaches were developed with the classic scheduling model. However, the contention model is gaining increasing recognition as a more practical tool to create accurate and efficient schedules. This study proposes a contention-aware reliability management with deadline and energy budget constraints (CARMEB) algorithm for parallel task scheduling in heterogeneous computing systems. CARMEB involves three phases, namely, task priority calculation, communication edge allocation, and slack reclaiming. Results are validated by conducting extensive experiments, including randomly generated task graphs and three types of task graphs in real-world applications. This study demonstrates that our algorithm significantly improves system reliability.

Non-clairvoyant scheduling of independent parallel tasks on single and multiple multicore processors

We investigate the problem of non-clairvoyant scheduling of independent parallel tasks on single and multiple multicore processors. For a single multicore processor, we derive an asymptotic worst-case performance bound for a non-clairvoyant offline scheduling algorithm called largest task first (LTF). The result improves our previous result on a single parallel computing system. For multiple multicore processors, we derive an asymptotic worst-case performance bound for the LTF algorithm. To the best of our knowledge, there has been little result on scheduling parallel tasks on multiple parallel computing systems. For multiple multicore processors, we also derive an asymptotic average-case performance bound for a non-clairvoyant online scheduling algorithm called random task first (RTF). The result extends our earlier result on a single parallel computing system. Extensive simulation results are also demonstrated.

Managing Complex Workflows in Bioinformatics: An Interactive Toolkit With GPU Acceleration.

Bioinformatics research continues to advance at an increasing scale with the help of techniques such as next-generation sequencing and the availability of tool support to automate bioinformatics processes. With this growth, a large amount of biological data gets accumulated at an unprecedented rate, demanding high-performance and high-throughput computing technologies for processing such datasets. Use of hardware accelerators, such as graphics processing units (GPUs) and distributed computing, accelerates the processing of big data in high-performance computing environments. They enable higher degrees of parallelism to be achieved, thereby increasing the throughput. In this paper, we introduce BioWorkflow, an interactive workflow management system to automate the bioinformatics analyses with the capability of scheduling parallel tasks with the use of GPU-accelerated and distributed computing. This paper describes a case study carried out to evaluate the performance of a complex workflow with branching executed by BioWorkflow. The results indicate the gains of $\times 2.89$ magnitude by utilizing GPUs and gains in speed by average $\times 2.832$ magnitude (over $n = 5$ scenarios) by parallel execution of graph nodes during multiple sequence alignment calculations. Combined speed-ups are achieved $\times 1.71$ times for complex workflows. This confirms the expected higher speed-ups when having parallelism through GPU-acceleration and concurrent execution of workflow nodes than the mainstream sequential workflow execution. The tool also provides a comprehensive user interface with better interactivity for managing complex workflows; a system usability scale score of 82.9 is confirmed high usability for the system.

Blocking Analysis for Spin Locks in Real-Time Parallel Tasks

In recent years, there has been significant interest in developing real-time schedulers for parallel tasks. Most of that research has concentrated on idealized task models where tasks do not access any shared resources protected with locks. In this paper, we consider the problem of scheduling parallel tasks which experience contention due to shared resources. In particular, we provide a schedulability test for federated scheduling by deriving blocking time analyses for parallel tasks that access shared resources protected by FIFO-ordered and priority-ordered spin locks. Our numerical evaluation on randomly generated task sets indicates that priority-ordered locks generally provide better schedulability results than FIFO-ordered locks. We also incorporated both FIFO-ordered and priority-ordered spin lock implementations into a federated scheduling platform, which is able to schedule parallel tasks written with OpenMP. Via empirical evaluations, we found that priority-ordered locks also have better performance than FIFO-ordered locks in practice.

Online scheduling of moldable parallel tasks

In this paper, we study an online scheduling problem with moldable parallel tasks on m processors. Each moldable task can be processed simultaneously on any number of processors of a parallel computer, and the processing time of a moldable task depends on the number of processors allotted to it. Tasks arrive one by one. Upon arrival of each task, the scheduler has to determine both the number of processors and the starting time for the task. Moreover, these decisions cannot be changed in the future. The objective is to attain a schedule such that the longest completion time over all tasks, i.e., the makespan, is minimized. First, we provide a general framework to show that any $$\rho $$ -bounded algorithm for scheduling of rigid parallel tasks (the number of processors for a task is fixed a prior) can be extended to yield an algorithm for scheduling of moldable tasks with a competitive ratio of $$4\rho $$ if the ratio $$\rho $$ is known beforehand. As a consequence, we achieve the first constant competitive ratio, 26.65, for the moldable parallel tasks scheduling problem. Next, we provide an improved algorithm with a competitive ratio of at most 16.74.

Алгоритм построения расписаний выполнения параллельных задач на группах кластеров с процессорами различной производительности и его анализ в среднем

In this article the on-line problem of scheduling parallel tasks on related computational clusters with processors of different capacities was studied in average case. In the problem the objective is to make a schedule on k clusters with w processors each of N tasks, where the task i,i≤N requires time hi on cluster with nominal capacity of processors and wi≤w processors. We presume for all 1≤i≤N that wi has uniform distribution on (0,w] and that hi has uniform distribution on (0,1]. The processors on different clusters have different capacities v1,…,vk. The task with nominal time hi will require wi processors be computed in time hi/vj on cluster number j. Let sum volume of computations W be the sum of volumes of computations for each task. Let L be the minimal time at which all clusters will compute all the tasks, assigned to them, where each task is assigned to one cluster. The expected value of free volume of computations E(Vsp) is used to analyze the quality of an algorithm, where Vsp=∑1≤i≤kviL-W. It was shown that for every algorithm for scheduling parallel tasks on related clusters E(Vsp)=Ω(w√N). An online scheduling algorithm Limited Hash Scheduling was proposed that distribute tasks to limited areas. This algorithm works in a closed-end mode and has a mathematical expectation of a free calculation volume equal to O(w√(N ln N)). The idea of the algorithm is to schedule tasks of close required number of required processors into different limited in time and the number of allowed to use processors areas on clusters.

Power-efficient scheduling of parallel real-time tasks on performance asymmetric multicore processors

The use of computing devices has increased dramatically in recent time, which results in huge power consumption. This situation has made the power consumption a critical metric for evaluating the performance of a computing device. In this paper, we have addressed the real-time scheduling problem of parallel tasks on a performance asymmetric multicore processor with m cores with intent to reduce the power consumption. The proposed algorithm – parallel EDF – first divides the tasks into m segments and then executes these distributed tasks in earliest deadline first (EDF) fashion. Dynamic voltage and frequency scaling (DVFS) is also applied for power savings. We have evaluated the performance of the parallelEDF scheduling algorithm with Equally Fit (EF) algorithm on 70nm based performance asymmetric multicore processor. The results reveal that up to 28% power can be saved at high system utilization level (about 80% system utilization). We have formally modeled the parallelEDF algorithm using high-level Petri nets (HLPN) while these models are also verified using the Satisfiability Modulo Theory (SMT), and Z3 Solver.

Mixed-criticality federated scheduling for parallel real-time tasks

A mixed-criticality system comprises safety-critical and non-safety-critical tasks sharing a computational platform. Thus, different levels of assurance are required by different tasks in terms of real-time performance. As the computational demands of real-time tasks increase, tasks may require internal parallelism in order to complete within stringent deadlines. In this paper, we consider the problem of mixed-criticality scheduling of parallel real-time tasks and propose a novel mixed-criticality federated scheduling (MCFS) algorithm for parallel tasks modeled by a directed acyclic graph. MCFS is based on federated intuition for scheduling parallel real-time tasks. It strategically assigns cores and virtual deadlines to tasks to achieve good schedulability. For high-utilization tasks (utilization $$\ge $$ 1), we prove that MCFS provides a capacity augmentation bound of $$2+\sqrt{2}$$ and $$(5+\sqrt{5})/2$$ for dual- and multi-criticality, respectively. We show that MCFS has a capacity augmentation bound of $$11m/(3m-3)$$ for dual-criticality systems with both high- and low-utilization tasks. For high-utilization tasks, we further provide a MCFS-Improve algorithm that has the same bound but can admit many more task sets in practice. Results of numerical experiments show that MCFS-Improve significantly improves over MCFS for many different workload settings. We also present an implementation of a MCFS runtime system in Linux that supports parallel programs written in OpenMP. Our implementation provides graceful degradation and recovery features. We conduct empirical experiments to demonstrate the practicality of our MCFS approach.

An intelligent approach for optimizing Energy consumption and Schedule length of Embedded multiprocessors1

In contemporary and future embedded as well as high-performance microprocessors, power consumption is one of the most important design considerations. Because in current technologies, the dynamic power consumption dominates the static power consumption, voltage scaling is an effective technique to reduce the power consumption. In multiprocessor systems, an efficient scheduling of sequential and parallel tasks onto the processors is known to be NP- Hard problem. In this paper, the problem of minimizing schedule length with energy consumption constraint and the problem of minimizing energy consumption with schedule length constraint on homogeneous and heterogeneous multiprocessor computers through inde- pendent sequential and parallel tasks are proposed. These problems emphasize the tradeoff between power and performance and are defined such that the power-performance product is optimized by fixing one factor and minimizing the other and vice versa. The performances of the proposed algorithm with optimal solutions are validated using Discrete Particle Swarm Optimization (DPSO). The proposed algorithms achieve 47.5% of power savings and 45.5% of energy saving with 23.5% increased schedule length when the processors operate its maximum frequency.