Datum
2018-09-10Autor
Bungart, MarcoSchlagwort
004 Informatik FehlertoleranzElastizitätSupercomputerFramework <Informatik>ProgrammierspracheMetadata
Zur Langanzeige
Dissertation
Fehlertoleranz und Elastizität für ein Framework zur globalen Lastenbalancierung
(Fault tolerance and Elasticity for a Global Load Balancing framework)
Zusammenfassung
Die Anzahl an Rechenknoten in Hochleistungsrechnern wächst stetig. In solchen Systemen nimmt die Bedeutung von Fehlertoleranz zu, da die Wahrscheinlichkeit eines permanenten Knotenausfalls ebenfalls stetig wächst.
Fehlertoleranz gegenüber permanenten Knotenausfällen wird typischerweise durch Checkpointing auf Systemebene realisiert. Findet das Checkpointing jedoch auf Anwendungsebene statt, können Laufzeitvorteile erzielt werden. Diese Implementierungen sind allerdings zeitintensiv und fehleranfällig. Anwendungen, die gegenüber solcher permanenten Knotenausfälle resistent sind, werden im weiteren Verlauf dieser Arbeit fehlertolerant genannt.
Neben der Fehlertoleranz steht auch die optimale Auslastung von Hochleistungsrechnern im Fokus der Forschung. Die Auslastung kann durch dynamische Umverteilung der Rechenressourcen zur Laufzeit verbessert werden. Hierzu müssen die Applikationen in der Lage sein, zur Laufzeit Rechenressourcen freizugeben und neue Rechenressourcen in die Berechnung aufzunehmen. Solche Applikationen werden elastisch genannt.
In dieser Arbeit entwickeln wir einen Algorithmus zur Realisierung von Fehlertoleranz und Elastizität für Taskpools. Die Fehlertoleranz arbeitet auf Applikationsebene und repliziert relevante Daten regelmäßig in den Hauptspeicher eines anderen Rechenknotens. Werden neue Rechenressourcen zu einer laufenden Berechnung hinzugefügt, so werden die hinzugefügten Rechenressourcen über die Lastenbalancierung des Taskpools mit Arbeit versorgt. Zu diesem Algorithmus entwickeln wir mehrere Varianten.
Wir haben unseren Algorithmus und seine Varianten als wiederverwendbares Framework in der parallelen Programmiersprache X10 implementiert.
Die experimentelle Auswertung mit drei verschiedenen Benchmarks hat ergeben, dass unser Framework und seine Varianten einen Overhead gegenüber einer nicht-fehlertoleranten Implementierung zwischen 4,17% und 55,72% haben. Für die Wiederherstellung ausgefallener Rechenknotens sowie das elastische Hinzufügen neuer Knoten konnten wir keine messbaren Laufzeiteinbußen feststellen.
Fehlertoleranz gegenüber permanenten Knotenausfällen wird typischerweise durch Checkpointing auf Systemebene realisiert. Findet das Checkpointing jedoch auf Anwendungsebene statt, können Laufzeitvorteile erzielt werden. Diese Implementierungen sind allerdings zeitintensiv und fehleranfällig. Anwendungen, die gegenüber solcher permanenten Knotenausfälle resistent sind, werden im weiteren Verlauf dieser Arbeit fehlertolerant genannt.
Neben der Fehlertoleranz steht auch die optimale Auslastung von Hochleistungsrechnern im Fokus der Forschung. Die Auslastung kann durch dynamische Umverteilung der Rechenressourcen zur Laufzeit verbessert werden. Hierzu müssen die Applikationen in der Lage sein, zur Laufzeit Rechenressourcen freizugeben und neue Rechenressourcen in die Berechnung aufzunehmen. Solche Applikationen werden elastisch genannt.
In dieser Arbeit entwickeln wir einen Algorithmus zur Realisierung von Fehlertoleranz und Elastizität für Taskpools. Die Fehlertoleranz arbeitet auf Applikationsebene und repliziert relevante Daten regelmäßig in den Hauptspeicher eines anderen Rechenknotens. Werden neue Rechenressourcen zu einer laufenden Berechnung hinzugefügt, so werden die hinzugefügten Rechenressourcen über die Lastenbalancierung des Taskpools mit Arbeit versorgt. Zu diesem Algorithmus entwickeln wir mehrere Varianten.
Wir haben unseren Algorithmus und seine Varianten als wiederverwendbares Framework in der parallelen Programmiersprache X10 implementiert.
Die experimentelle Auswertung mit drei verschiedenen Benchmarks hat ergeben, dass unser Framework und seine Varianten einen Overhead gegenüber einer nicht-fehlertoleranten Implementierung zwischen 4,17% und 55,72% haben. Für die Wiederherstellung ausgefallener Rechenknotens sowie das elastische Hinzufügen neuer Knoten konnten wir keine messbaren Laufzeiteinbußen feststellen.
The number of computational nodes in a HPC cluster rises constantly. In such systems fault tolerance gains importance since the probability of a permanent node failure increases.
Fault tolerance with respect to permanent node failures is typically achieved through checkpointing on system-level. Checkpointing on application-level may achieves execution time improvements. Its implementation is, however, time-consuming and error-prone. Applications that can tolerate permanent node failures are called fault-tolerant in this thesis.
In addition to fault tolerance, techniques to improve cluster utilization are a major topic of current research. The utilization can be improved through a dynamic redistribution of computational resources among application at runtime. For this, the applications must be able to remove resources from and add new resources to their computation at runtime. Applications supporting this feature are called elastic.
In this work, we develop an algorithm to provide fault tolerance and elasticity for task pools. It implements application-level fault tolerance and replicates relevant data of a node into the main memory of another. When new nodes are added to a running computation, they receive work through the load balancing mechanism of the underlying task pool.
We develop different variants of our algorithm. The algorithm is implemented as a reusable framework in the parallel programming language X10.
An experimental evaluation with three different benchmarks showed that our framework and its variants achieve an overhead between 4.17% and 55.72% compared to a non-fault-tolerant implementation. For the restore of failed nodes and the elastic addition of new nodes, experimental results show no measurable execution time losses.
Fault tolerance with respect to permanent node failures is typically achieved through checkpointing on system-level. Checkpointing on application-level may achieves execution time improvements. Its implementation is, however, time-consuming and error-prone. Applications that can tolerate permanent node failures are called fault-tolerant in this thesis.
In addition to fault tolerance, techniques to improve cluster utilization are a major topic of current research. The utilization can be improved through a dynamic redistribution of computational resources among application at runtime. For this, the applications must be able to remove resources from and add new resources to their computation at runtime. Applications supporting this feature are called elastic.
In this work, we develop an algorithm to provide fault tolerance and elasticity for task pools. It implements application-level fault tolerance and replicates relevant data of a node into the main memory of another. When new nodes are added to a running computation, they receive work through the load balancing mechanism of the underlying task pool.
We develop different variants of our algorithm. The algorithm is implemented as a reusable framework in the parallel programming language X10.
An experimental evaluation with three different benchmarks showed that our framework and its variants achieve an overhead between 4.17% and 55.72% compared to a non-fault-tolerant implementation. For the restore of failed nodes and the elastic addition of new nodes, experimental results show no measurable execution time losses.
Zitieren
@phdthesis{doi:10.17170/kobra-2018122577,
author={Bungart, Marco},
title={Fehlertoleranz und Elastizität für ein Framework zur globalen Lastenbalancierung},
school={Kassel, Universität Kassel, Fachbereich Elektrotechnik / Informatik},
month={09},
year={2018}
}
0500 Oax 0501 Text $btxt$2rdacontent 0502 Computermedien $bc$2rdacarrier 1100 2018$n2018 1500 1/ger 2050 ##0##http://hdl.handle.net/123456789/11022 3000 Bungart, Marco 4000 Fehlertoleranz und Elastizität für ein Framework zur globalen Lastenbalancierung :Fault tolerance and Elasticity for a Global Load Balancing framework / Bungart, Marco 4030 4060 Online-Ressource 4085 ##0##=u http://nbn-resolving.de/http://hdl.handle.net/123456789/11022=x R 4204 \$dDissertation 4170 5550 {{Fehlertoleranz}} 5550 {{Elastizität}} 5550 {{Supercomputer}} 5550 {{Framework <Informatik>}} 5550 {{Programmiersprache}} 7136 ##0##http://hdl.handle.net/123456789/11022
2019-01-08T12:52:42Z 2019-01-08T12:52:42Z 2018-09-10 doi:10.17170/kobra-2018122577 http://hdl.handle.net/123456789/11022 ger Namensnennung-Nicht-kommerziell 3.0 Deutschland Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Deutschland http://creativecommons.org/licenses/by-nc-sa/3.0/de/ Fehlertoleranz Elastizität X10 GLB 004 Fehlertoleranz und Elastizität für ein Framework zur globalen Lastenbalancierung Dissertation Die Anzahl an Rechenknoten in Hochleistungsrechnern wächst stetig. In solchen Systemen nimmt die Bedeutung von Fehlertoleranz zu, da die Wahrscheinlichkeit eines permanenten Knotenausfalls ebenfalls stetig wächst. Fehlertoleranz gegenüber permanenten Knotenausfällen wird typischerweise durch Checkpointing auf Systemebene realisiert. Findet das Checkpointing jedoch auf Anwendungsebene statt, können Laufzeitvorteile erzielt werden. Diese Implementierungen sind allerdings zeitintensiv und fehleranfällig. Anwendungen, die gegenüber solcher permanenten Knotenausfälle resistent sind, werden im weiteren Verlauf dieser Arbeit fehlertolerant genannt. Neben der Fehlertoleranz steht auch die optimale Auslastung von Hochleistungsrechnern im Fokus der Forschung. Die Auslastung kann durch dynamische Umverteilung der Rechenressourcen zur Laufzeit verbessert werden. Hierzu müssen die Applikationen in der Lage sein, zur Laufzeit Rechenressourcen freizugeben und neue Rechenressourcen in die Berechnung aufzunehmen. Solche Applikationen werden elastisch genannt. In dieser Arbeit entwickeln wir einen Algorithmus zur Realisierung von Fehlertoleranz und Elastizität für Taskpools. Die Fehlertoleranz arbeitet auf Applikationsebene und repliziert relevante Daten regelmäßig in den Hauptspeicher eines anderen Rechenknotens. Werden neue Rechenressourcen zu einer laufenden Berechnung hinzugefügt, so werden die hinzugefügten Rechenressourcen über die Lastenbalancierung des Taskpools mit Arbeit versorgt. Zu diesem Algorithmus entwickeln wir mehrere Varianten. Wir haben unseren Algorithmus und seine Varianten als wiederverwendbares Framework in der parallelen Programmiersprache X10 implementiert. Die experimentelle Auswertung mit drei verschiedenen Benchmarks hat ergeben, dass unser Framework und seine Varianten einen Overhead gegenüber einer nicht-fehlertoleranten Implementierung zwischen 4,17% und 55,72% haben. Für die Wiederherstellung ausgefallener Rechenknotens sowie das elastische Hinzufügen neuer Knoten konnten wir keine messbaren Laufzeiteinbußen feststellen. The number of computational nodes in a HPC cluster rises constantly. In such systems fault tolerance gains importance since the probability of a permanent node failure increases. Fault tolerance with respect to permanent node failures is typically achieved through checkpointing on system-level. Checkpointing on application-level may achieves execution time improvements. Its implementation is, however, time-consuming and error-prone. Applications that can tolerate permanent node failures are called fault-tolerant in this thesis. In addition to fault tolerance, techniques to improve cluster utilization are a major topic of current research. The utilization can be improved through a dynamic redistribution of computational resources among application at runtime. For this, the applications must be able to remove resources from and add new resources to their computation at runtime. Applications supporting this feature are called elastic. In this work, we develop an algorithm to provide fault tolerance and elasticity for task pools. It implements application-level fault tolerance and replicates relevant data of a node into the main memory of another. When new nodes are added to a running computation, they receive work through the load balancing mechanism of the underlying task pool. We develop different variants of our algorithm. The algorithm is implemented as a reusable framework in the parallel programming language X10. An experimental evaluation with three different benchmarks showed that our framework and its variants achieve an overhead between 4.17% and 55.72% compared to a non-fault-tolerant implementation. For the restore of failed nodes and the elastic addition of new nodes, experimental results show no measurable execution time losses. open access Fault tolerance and Elasticity for a Global Load Balancing framework Bungart, Marco 2018-11-30 xx, 135 Seiten Kassel, Universität Kassel, Fachbereich Elektrotechnik / Informatik Fohry, Claudia (Prof. Dr.) Rauber, Thomas (Prof. Dr.) Fehlertoleranz Elastizität Supercomputer Framework <Informatik> Programmiersprache publishedVersion
Die folgenden Lizenzbestimmungen sind mit dieser Ressource verbunden: