Independent Parallel Tasks Research Articles

List and shelf schedules for independent parallel tasks to minimize the energy consumption with discrete or continuous speeds

Scheduling independent tasks on a parallel platform is a widely-studied problem, in particular when the goal is to minimize the total execution time, or makespan (P||Cmax problem in Graham's notations). Also, many applications do not consist of sequential tasks, but rather parallel tasks, either rigid, with a fixed degree of parallelism, or moldable, with a variable degree of parallelism (i.e., for which we can decide at the execution on how many processors they are executed). Furthermore, since the energy consumption of data centers is a growing concern, both from an environmental and economical point of view, minimizing the energy consumption of a schedule is a main challenge to be addressed. One can then decide, for each task, on how many processors it is executed, and at which speed the processors are operated, with the goal to minimize the total energy consumption. We further focus on co-schedules, where tasks are partitioned into shelves, and we prove that the problem of minimizing the energy consumption remains NP-complete when static energy is consumed during the whole duration of the application. We are however able to provide an optimal algorithm for the schedule within one shelf, i.e., for a set of tasks that start at the same time. Several approximation results are derived, both with discrete and continuous speed models, and extensive simulations are performed to show the performance of the proposed algorithms.

Performance and programmability comparison of the thick control flow architecture and current multicore processors

Commercial multicore central processing units (CPU) integrate a number of processor cores on a single chip to support parallel execution of computational tasks. Multicore CPUs can possibly improve performance over single cores for independent parallel tasks nearly linearly as long as sufficient bandwidth is available. Ideal speedup is, however, difficult to achieve when dense intercommunication between the cores or complex memory access patterns is required. This is caused by expensive synchronization and thread switching, and insufficient latency toleration. These facts guide programmers away from straight-forward parallel processing patterns toward complex and error-prone programming techniques. To address these problems, we have introduced the Thick control flow (TCF) Processor Architecture. TCF is an abstraction of parallel computation that combines self-similar threads into computational entities. In this paper, we compare the performance and programmability of an entry-level TCF processor and two Intel Skylake multicore CPUs on commonly used parallel kernels to find out how well our architecture solves these issues that greatly reduce the productivity of parallel software development. Code examples are given and programming experiences recorded.

Blocking analysis of suspension-based protocols for parallel real-time tasks under global fixed-priority scheduling

With the wide use of multiprocessor architecture, parallel tasks have been receiving growing attention in both industry and academia. In real-time systems, the scheduling and synchronization that ensure predictable task execution and resource access are of utmost importance. Although the scheduling of (independent) parallel tasks is widely studied in recent years, few works have been done for the synchronization with intra-task parallelism. In particular, the performance of the classical priority inheritance mechanism is still unfathomed for parallel tasks. In this paper, we extend the Priority Inheritance Protocol (PIP) and the Flexible Multiprocessor Locking Protocol (FMLP) for real-time parallel tasks (i.e., called P-PIP and P-FMLP respectively) under the global fixed-priority scheduling, and present the blocking analysis for both protocols with the state-of-the-art linear optimization technique. Empirical evaluations show that the P-PIP outperformed the P-FMLP with increasing shared resource contentions. • This paper first studies the synchronization of parallel tasks under global scheduling. • This paper proposes a unified analysis framework under the global scheduling. • A Mixed Integer Linear Programming technique is used to reduce analytical pessimism.

The search‐based scheduling algorithm HP* for parallel tasks on heterogeneous platforms

SummaryScheduling is a widely used method in parallel computing, which assigns tasks to compute resources of a parallel environments. In this article, we consider independent parallel tasks to be scheduled onto a heterogeneous execution platform consisting of a set of multicores of different architecture. Each parallel task has an internal potential parallelism which allows a parallel execution on any multicore processors. However, the execution time may differ due a different computation speed of different multicores. In this article, we propose a new search‐based scheduling algorithm Heterogeneous Parallel task scheduling based on A* (called HP*) to solve the problem of scheduling independent parallel tasks onto heterogeneous multicore platforms. Specifically, we propose a heuristic cost function needed for an informed search. Also, three pruning techniques are proposed, which are shown to significantly reduce the search space of HP*. Performance measurements on a heterogeneous platform are performed and the results of HP* are compared to scheduling results of other popular scheduling methods. The performance results with benchmark tasks from the SPLASH‐3 benchmark suite demonstrate the good scheduling results and the improvements achieved by HP*.

Scalability of a parallel Schur complement method given the limitations for memory

In decomposition methods, the memory costs for solving the interface problem are increasing significantly with the number of subdomains increasing. Using of the Schur complement method allows you to reduce the number of iterations when the system is being solved. At the same time, the Schur complement matrix takes up more memory in comparison with global stiffness matrix. This imposes restrictions on the maximum size of the problem for which you can apply this method. Different approaches to reduce the costs and limitations of memory on stage of the construction and solving of the interface system exist. Parallel algorithm of the construction S with distributed storage of the matrix are considered when implementing using OpenMP and MPI technologies. This approach allows not only to reduce the limits on the maximum size of the solved problem, but also to resolve conflicts of shared memory access by increasing the number of independent parallel tasks.

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.

A Behavioral Paradigm to Study Rats Dual‐Task Performance under Head‐Direction and Body‐Location Tracking

SUMMARYDual‐task paradigm is a behavioral procedure in which subjects are required to perform two independent tasks in parallel, each of which involves a distinct stimulus–response association that leads to a unique goal. Although dual tasks are widely used in human studies, they are seldom used in animals. One such rare case was a rat simultaneous temporal processing (STP) task, in which rats were asked to time two different intervals simultaneously . However, there are a few limitations in this paradigm, such that, for example, each of two component tasks was not clearly associated with a unique stimulus–response association. In this report, in order to better characterize temporal dual‐task performance in rats, we developed a modified version of the STP task that comprised two clearly divided component tasks, and equipped our experimental system with a novel video‐based motion tracking system. We show that even under this more rigidly controlled dual‐task setting, rats are able to time two different intervals virtually without interference, and that our tracking system can simultaneously detect head‐direction and body‐location of a rat with high accuracy. These results suggest that the present experimental paradigm should be useful for investigating cognitive processes that underlie dual‐task performance at both the behavioral and neuronal levels.

A distributed approach for accelerating sparse matrix arithmetic operations for high-dimensional feature selection

Matrix computations are both fundamental and ubiquitous in computational science, and as a result, they are frequently used in numerous disciplines of scientific computing and engineering. Due to the high computational complexity of matrix operations, which makes them critical to the performance of a large number of applications, their efficient execution in distributed environments becomes a crucial issue. This work proposes a novel approach for distributing sparse matrix arithmetic operations on computer clusters aiming at speeding-up the processing of high-dimensional matrices. The approach focuses on how to split such operations into independent parallel tasks by considering the intrinsic characteristics that distinguish each type of operation and the particular matrices involved. The approach was applied to the most commonly used arithmetic operations between matrices. The performance of the presented approach was evaluated considering a high-dimensional text feature selection approach and two real-world datasets. Experimental evaluation showed that the proposed approach helped to significantly reduce the computing times of big-scale matrix operations, when compared to serial and multi-thread implementations as well as several linear algebra software libraries.

モーショントラッキング機能を備えたラット二重課題実験系の構築

Dual-task paradigm is a behavioral procedure in which subjects are required to perform two independent tasks in parallel, each of which involves a distinct stimulus-response association that leads to a unique goal. Although dual tasks are widely used in human studies, they are seldom used in animals. One such rare case was a rat simultaneous temporal processing (STP) task, in which rats were asked to time two different intervals simultaneously(1). However, there are a few limitations in this paradigm, such that, for example, each of the two component tasks was not clearly associated with a unique stimulus-response association. In this report, in order to better characterize temporal dual-task performance in rats, we developed a modified version of the STP task that was comprised of two clearly-divided component tasks, and equipped our experimental system with a novel video-based motion tracking system. We show that even under this more rigidly controlled dual-task setting, rats are able to time two different intervals virtually without interference, and that our tracking system can simultaneously detect head-direction and body-location of a rat with high accuracy. These results suggest that the present experimental paradigm should be useful for investigating cognitive processes that underlie dual-task performance at both the behavioral and neuronal levels.

Optimizing Workflow Scheduling using Max-Min Algorithm in Cloud Environment

With the up rise of fourth paradigm, that is discovery of science over a prolonged period of time, scientific workflows commence to amend their status amongst innumerous science subject areas including physics, astronomy, biology, chemistry, earthquake science and many more. In Scientific workflows, a heavy volume of data processing is required and workflows with up to a few million tasks are not unusual. With the advent of Cloud Computing as a new model of service provisioning in distributed systems, a new direction comes in light for executing scientific applications such as Workflows by deploying resources of Cloud. The scheduling of millions of tasks of workflows, while processing with Cloud resources, in a most profitable manner i.e. minimum computation time is still an attractive research area. The existing scheduling algorithms are brushing off the individual dependent and independent tasks. In this research paper, MaxMin algorithm is implemented for scheduling of workflow tasks that is focalized on the consideration of dependent and independent tasks and process independent tasks in parallel that directly gives profit in minimizing computation time. General Terms Cloud Computing, Scheduling Algorithms.

Power and performance management for parallel computations in clouds and data centers

We address scheduling independent and precedence constrained parallel tasks on multiple homogeneous processors in a data center with dynamically variable voltage and speed as combinatorial optimization problems. We consider the problem of minimizing schedule length with energy consumption constraint and the problem of minimizing energy consumption with schedule length constraint on multiple processors. Our approach is to use level-by-level scheduling algorithms to deal with precedence constraints. We use a simple system partitioning and processor allocation scheme, which always schedules as many parallel tasks as possible for simultaneous execution. We use two heuristic algorithms for scheduling independent parallel tasks in the same level, i.e., SIMPLE and GREEDY. We adopt a two-level energy/time/power allocation scheme, namely, optimal energy/time allocation among levels of tasks and equal power supply to tasks in the same level. Our approach results in significant performance improvement compared with previous algorithms in scheduling independent and precedence constrained parallel tasks.

Task graph pre-scheduling, using Nash equilibrium in game theory

Prescheduling algorithms are targeted at restructuring of task graphs for optimal scheduling. Task graph scheduling is a NP-complete problem. This article offers a prescheduling algorithm for tasks to be executed on the networks of homogeneous processors. The proposed algorithm merges tasks to minimize their earliest start time while reducing the overall completion time. To this end, considering each task as a player attempting to reduce its earliest time as much as possible, we have applied the idea of Nash equilibrium in game theory to determine the most appropriate merging. Also, considering each level of a task graph as a player, seeking for distinct parallel processors to execute each of its independent tasks in parallel with the others, the idea of Nash equilibrium in game theory can be applied to determine the appropriate number of processors in a way that the overall idle time of the processors is minimized and the throughput is maximized. The communication delay will be explicitly considered in the comparisons. Our experiments with a number of known benchmarks task graphs and also two well-known problems of linear algebra, LU decomposition and Gauss---Jordan elimination, demonstrate the distinguished scheduling results provided by applying our algorithm. In our study, we consider ten scheduling algorithms: min---min, chaining, A ?, genetic algorithms, simulated annealing, tabu search, HLFET, ISH, DSH with task duplication, and our proposed algorithm (PSGT).

Energy consumption and schedule length minimisation of multiprocessor systems using genetic algorithm

Multiprocessors have emerged as a powerful computing means for running real-time applications, especially where a uniprocessor system would not be sufficient enough to execute all the tasks. The high performance and reliability of multiprocessors have made them a powerful computing resource. Such computing environment requires an efficient algorithm to determine when and on which processor a given task should be executed. This paper focuses the combinational optimisation problem, namely, the problem of minimising schedule length with energy consumption constraint and the problem of minimising energy consumption with schedule length constraint for independent parallel tasks on homogeneous and heterogeneous multiprocessor computers. These problems emphasise the trade-off between power and performance and are defined such that the power-performance product is optimised by fixing one factor and minimising the other and vice versa. The performance of the proposed algorithm with optimal solution is validated analytically and compared with genetic algorithm.

An efficient energy and schedule length model for multiprocessor computers

Multiprocessors have emerged as a powerful computing means for running real-time applications, especially where a uniprocessor system would not be sufficient to execute all the tasks. Such a computing environment requires an efficient algorithm to determine when and on which processor a given task should be executed. An efficient scheduling of parallel tasks onto the multiprocessors is known to be an NP-hard problem. This paper focuses on the combinational optimisation problem, namely the problem of minimising schedule length with energy consumption constraint and the problem of minimising energy consumption with schedule length constraint for independent parallel tasks. These problems emphasise the trade-off between power and performance and are defined such that the power-performance product is optimised by fixing one factor and minimising other and vice versa. The performance of the proposed algorithm with optimal solution is validated analytically and compared with Particle Swarm Optimisation (PSO) and Genetic Algorithm (GA).

Optimizing layer-based scheduling algorithms for parallel tasks with dependencies

Programming with parallel tasks leads to task graphs with dependencies representing a parallel program. Scheduling algorithms are employed to find an efficient execution order of the parallel tasks. A large variety of scheduling algorithms exist, including layer-based scheduling algorithms for homogeneous target platforms that build consecutive layers of independent parallel tasks and schedule each layer separately. Although these scheduling algorithms provide good results in terms of scheduling algorithm runtime and schedule execution time, the resulting schedules leave room for optimization. This article proposes an optimization for arbitrary layer-based scheduling algorithms, which is called Move-blocks algorithm. Given a layer-based schedule of the parallel tasks, this algorithm moves blocks of parallel tasks into preceding layers in order to reduce the overall execution time of a task-based application. Suitable blocks of parallel tasks are identified by the algorithm Find-blocks, which is employed together with the Move-blocks algorithm. The algorithm Move-blocks is applied to four well-known scheduling algorithms. A detailed evaluation for a wide range of test cases is given. Copyright © 2010 John Wiley & Sons, Ltd.

Agent-based platform to support the execution of parallel tasks

Parallel computing has been radically evolving in the recent years from the supercomputer multi-processor centralised point of view to the modern distributed approaches such as grid computing. The availability of relatively obsolete or underused hardware and the increasing LAN and WAN interconnection speed have motivated the success of those new paradigms. In this paper, we propose the use of agent technology to improve the management, flexibility and reusability of grid-like parallel computing architectures. We present a general purpose agent-based architecture which is able to manage and execute independent parallel tasks through one or several heterogeneous computer networks – or even Internet nodes – exploiting state of the art agent mobility capabilities. A particular application of the proposed architecture to support the execution of a complex knowledge acquisition task is also introduced, showing a high scalability and a very low overhead.

Scheduling Parallel Tasks with Communication Overhead in an Environment with Multiple Machines

This paper investigates the problem of nonpreemptively scheduling independent parallel tasks in an environment with multiple machines, which is motivated from the recent studies in scheduling tasks in a multi-machine environment. In this scheduling environment, each machine contains a number of identical processors and each parallel task can simultaneously require a number of processors for its processing in any single machine. Whenever tasks are processed in parallel in a parallel machine, message communication among processors is often inevitable. The problem of finding a shortest schedule length on scheduling independent parallel tasks with the consideration of communication overhead in a multi-machine environment is NP-hard. The aim of this paper is to propose a heuristic algorithm for this kind of problem and to analyze the performance bound of this heuristic algorithm.

An average-case analysis of online non-clairvoyant scheduling of independent parallel tasks

We analyze the average-case performance of an online non-clairvoyant scheduling algorithm for independent parallel tasks. The algorithm schedules tasks without prior knowledge of the future tasks and the execution times of the tasks that are not yet completed. By using reasonable assumptions, we find an asymptotic average-case performance bound and develop a method to calculate the bound for arbitrary probability distribution of task sizes. In particular, we show that when task sizes are uniformly distributed in the range [ 1 .. C ] , an asymptotic average-case performance bound of M M - ( 3 - ( 1 + 1 / C ) C + 1 ) C - 1 can be achieved, where M is the number of processors. The above asymptotic average-case performance bound achieves its maximum value when C = M , which is approximately 1 / ( e - 2 ) = 1.3922112 for large M. We also present extensive numerical and simulation data to demonstrate the accuracy of our analytical bound.

Scheduling Precedence Constrained Parallel Tasks on Multiprocessors Using the Harmonic System Partitioning Scheme

We present an algorithm for scheduling precedence constrained parallel tasks on multiprocessors with noncontiguous processor allocation. The algorithm is called LLH(subscript m) (Level-by-level and List scheduling using the Harmonic system partitioning scheme), where m≥1 is a positive integer, which is a parameter for the harmonic system partitioning scheme. Three basic techniques are employed in algorithm LLH(subscript m). First, a task graph is divided into levels, and tasks are scheduled level by level to follow the precedence constraints. Second, tasks in the same level are scheduled using algorithm H(subscript m) developed in [16] for scheduling independent parallel tasks. The list scheduling method is used to implement algorithm H(subscript m). Third, the harmonic system partitioning scheme is used for processor allocation. It is shown here that for wide task graphs and some common task size distributions, as the size of a computation and m increase, and as the task sizes become smaller, the average-case performance ratio of algorithm LLH(subscript m) approaches one.

Computing optimal preemptive schedules for parallel tasks: linear programming approaches

We study the problem of scheduling a set of n independent parallel tasks on m processors, where in addition to the processing time there is a size associated with each task indicating that the task can be processed on any subset of processors of the given size. Based on a linear programming formulation, we propose an algorithm for computing a preemptive schedule with minimum makespan, and show that the running time of the algorithm depends polynomially on m and only linearly on n. Thus for any fixed m, an optimal preemptive schedule can be computed in O(n) time. We also present extensions of this approach to other (more general) scheduling problems with malleable tasks, due dates and maximum lateness minimization.