Memory limited algorithms for optimal task scheduling on parallel systems

Highlights

• Solves the multi-processor task scheduling problem with communication delays.

• Two new memory limited optimal task scheduling algorithms are proposed.

• Their implementations have a small memory footprint.

• Complimentary approach to the optimal solution, from below and above.

• Computes non-optimal but quality guaranteed solutions on request.

Abstract

To fully benefit from a multi-processor system, tasks need to be scheduled optimally. Given that the task scheduling problem with communication delays, $P|prec,c_{ij}|C_{max}$, is a well known strong NP-hard problem, exhaustive approaches are necessary. The previously proposed A* based algorithm retains its entire state space in memory and often runs out of memory before it finds an optimal solution. This paper investigates and proposes two memory limited optimal scheduling algorithms: Iterative Deepening A* (IDA*) and Depth-First Branch and Bound A* (BBA*). When finding a guaranteed near optimal schedule length is sufficient, the proposed algorithms can be combined, reporting the gap while they run. Problem specific pruning techniques, which are crucial for good performance, are studied for the two proposed algorithms. Extensive experiments are conducted to evaluate and compare the proposed algorithms with previous optimal algorithms.

Introduction

The problem of scheduling tasks with precedence constraints and communication delays onto a set of homogeneous multi-processor system with the objective of minimising the overall finish time is essential and fundamental to speed up task execution on a multiprocessor system. The problem addressed is the classic problem of scheduling task graphs on parallel systems with communication delay, which is $P|\mathrm{prec},c_{ij}|C_{\max }$ in the $\alpha \left|\beta \right|\gamma$ notation  [15], [41]. Optimal scheduling is a well known hard problem (an NP-hard optimisation problem  [34]), as the time needed to solve it optimally grows exponentially with the number of tasks. A number of heuristics have been proposed for this classical problem, but they try to produce good rather than optimal schedules, e.g.  [24], [28], [16], [31], [37], [44], [46], [7], [18]. For the classical scheduling problem, no $\alpha$-approximation is known  [12]. The only known guaranteed approximation algorithm in  [18] has an approximation factor depending on communication costs of the longest path in the schedule. While heuristics often provide good results, there is no guarantee that the solutions are close to optimal, especially for task graphs with high communication costs  [40], [39].

Optimal schedules make a significant difference where the schedule is reused multiple times and in time critical systems with applications to flight control, industrial automation, telecommunication systems, consumer electronics, robotics and multimedia systems. This is especially true for schedules in embedded systems, where they are used many times during their life cycle. The lack of good guaranteed approximation algorithms makes this very relevant. Moreover, having optimal solutions for scheduling instances allows to better judge the quality of heuristics and thereby to gain insights into their behaviour. For other NP-hard problems it can be possible to compute the optimal solution for practically relevant problems in reasonable time, e.g. Travelling Salesman Problem  [1]. With our work on optimal scheduling, we investigate if we can solve larger problem instances in a reasonable amount of time. The work presented in this paper addresses the optimal solution of the $P|\mathrm{prec},c_{ij}|C_{\max }$ scheduling problem. This is one of the classic models for task scheduling with a wealth of results  [22], [23], [43], [8], [10]. As such, solving it optimally has an interest for the community and is also practically used, for example the task-based linear algebra solvers like StarPU  [3], [2] use such a model with a simple scheduling heuristic.

Previous approaches to optimally solve this scheduling problem are based on Mixed Integer Linear Programming (MILP) formulations  [10], [42] and smart state space enumerations using A*  [22]. Both approaches showed strengths and weaknesses. The MILP formulations are less efficient for small numbers of processors and when communication costs are high  [43]. They also require powerful solvers, which are like black boxes and make performance predictions difficult. The compact A* scheduling algorithm is very well suited to inject problem specific knowledge to prune the search space, which is crucial for efficient searches  [38]. However, the approach suffers from the well known drawback of A*: it runs out of memory very quickly. ILP based solvers use Linear Programming (LP) relaxations instead of exhaustive search of the entire solution space as is the case in A* and its proposed memory limited variants. The use of different techniques to solve the scheduling problem addressed here makes it worthwhile to investigate and compare their performance.

The main contributions of this paper are (1) to overcome the memory limitations by proposing two new algorithms: Iterative Deepening A* (IDA*) scheduling algorithm which employs iterative deepening to limit the memory utilisation of the algorithm and the Depth-First Branch and Bound A* (BBA*) which improves the solution as the search traverses through the state space of the $P|\mathrm{prec},c_{ij}|C_{\max }$ scheduling problem; (2) to propose an exhaustive search approach based on the two algorithms that finds a feasible schedule whose quality with respect to the schedule length is guaranteed, updating the current quality while running; (3) to improve the initial lower bound on the schedule length to reduce the number of states revisited by IDA* during iterative deepening. (4) to investigate and propose new pruning techniques for generic and structure specific graphs to significantly reduce the state (solution) space.

The rest of the paper is organised as follows. Section  2 gives the related work on other approaches used to optimally solve this scheduling problem. Section  3 discusses the task scheduling model and Section  4 details the proposed IDA* and BBA* scheduling algorithms and supplies different methods to improve the $f$- function calculations that guide the algorithms. The section also proposes the gap calculation method to find a feasible schedule with a guaranteed quality on the schedule length. Section  5 proposes a method to find a good initial lower bound close to the optimal schedule length in order to speed-up the execution of IDA*. Section  6 analyses existing and investigates novel state space pruning techniques that are essential to speed-up the runtime of the algorithm. Duplicate avoidance without memory and processor normalisation without memory are the pruning techniques proposed in this paper. Section  7 evaluates and compares the performance of the proposed algorithms with previous approaches. Section  8 concludes by highlighting the main results of the paper and the significance in using memory limited algorithms to solve the task scheduling problem.