Scheduling tree-shaped task graphs to minimize memory and makespan

TL;DR

This paper explores scheduling tree-shaped task graphs on multiple processors to optimize memory usage and execution time, extending known single-processor algorithms to a more complex multi-processor context with new complexity results and heuristics.

Contribution

It introduces the multi-processor scheduling problem for tree-shaped graphs, analyzes its computational complexity, and proposes heuristics with extensive experimental evaluation.

Findings

The problem is computationally hard with inapproximability results.

Heuristics can effectively balance memory and makespan.

Experimental results demonstrate practical performance of proposed methods.

Abstract

This paper investigates the execution of tree-shaped task graphs using multiple processors. Each edge of such a tree represents a large IO file. A task can only be executed if all input and output files fit into memory, and a file can only be removed from memory after it has been consumed. Such trees arise, for instance, in the multifrontal method of sparse matrix factorization. The maximum amount of memory needed depends on the execution order of the tasks. With one processor the objective of the tree traversal is to minimize the required memory. This problem was well studied and optimal polynomial algorithms were proposed. Here, we extend the problem by considering multiple processors, which is of obvious interest in the application area of matrix factorization. With the multiple processors comes the additional objective to minimize the time needed to traverse the tree, i.e., to minimize the makespan. Not surprisingly, this problem proves to be much harder than the sequential one. We study the computational complexity of this problem and provide an inapproximability result even for unit weight trees. Several heuristics are proposed, each with a different optimization focus, and they are analyzed in an extensive experimental evaluation using realistic trees.