Parallel Scheduling of Task Trees with Limited Memory

Abstract

Abstract:This paper investigates the execution of tree-shaped task graphs using multiple processors. Each edge of such a tree represents some large data. A task can only be executed if all input and output data fit into memory, and a data can only be removed from memory after the completion of the task that uses it as an input data. Such trees arise, for instance, in the multifrontal method of sparse matrix factorization. The peak memory needed for the processing of the entire tree 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 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 inapproximability results even for unit weight trees. We design a series of practical heuristics achieving different trade-offs between the minimization of peak memory usage and makespan. Some of these heuristics are able to process a tree while keeping the memory usage under a given memory limit. The different heuristics are evaluated in an extensive experimental evaluation using realistic trees. Key-words:Approximation algorithms, memory usage, multi-criteria optimization, Nousétendons ce problème en considérant plusieurs processeurs, ce qui est d'un intérêtévident pour le problème de la factorisation de grandes matrices. Avec plusieurs processeurs se posé egalement le problème de la minimisation du temps nécessaire pour traiter l'arbre. Nous montrons que comme attendu, ce problème est bien plus compliqué que dans le cas séquentiel. Nousétudions la complexité de ce problème et nous fournissons des résultats d'inaproximabilité, même dans le cas de poids unitaires. Nous proposons plusieurs heuristiques qui obtiennent différents compromis entre mémoire et temps d'exécution. Certaines d'entre elles sont capables de traiter l'arbre tout en gardant la consommation mémoire inférieureà une limite donnée. Nous analysons les performances de toutes ces heuristiques par une large campagne de simulations utilisant des arbres réalistes.

Partitioning Tree-Shaped Task Graphs for Distributed Platforms With Limited Memory

“…The first heuristic, SplitSubtrees is adapted from [33], where the goal was to reduce the makespan while limiting the memory in a shared-memory environment. It creates a two-level partition with one connected component containing the root, executed first on a single processor (and called the sequential set), followed by the parallel processing of p − 1 independent subtrees.…”

“…In this case, we only consider the use of Step 1 directly followed by Step 3. The reference heuristic becomes SplitSubtrees, which was directly adapted from ideas from [33], resulting in a two-level split of the tree. Figure 11 reports the final makespan, after applying one heuristic of Step 1 followed by SplitAgain.…”

Limiting the memory footprint when dynamically scheduling DAGs on shared-memory platforms

“…In several cases, the underlying task graph is a tree, with all dependences oriented towards the root, which notably simplifies the problem: this is the case for sparse direct solvers [13] but also in quantum chemistry computations [14]. For such trees, memory-aware parallel schedulers have been proposed [15] and the effect of processor mapping on memory consumption have recently been studied [7]. The problem of general task graphs handling large data has been identified by Ramakrishnan et al [6] who introduced clean-up jobs to reduce the memory footprint and propose some simple heuristics.…”

Scheduling series-parallel task graphs to minimize peak memory

“…The first condition to verify is C1: Σ(p, π) ≤ Σ(p, γ). When t p is not defined, this condition directly derives from Equation (8). Consider now that t p is defined.…”

“…Peak memory minimization problem has been addressed for applications whose task graphs are rooted trees [13,14,16,18]. This work aspires to be helpful in scheduling applications whose task graphs are series parallel [3,9,20], as theoretical understanding of the underlying layout problem is needed to reduce the peak memory in a parallel execution environment (see for example a previous study [8]). This paper is organized as follows.…”