LAIK is an ongoing library for proactive and reactive fault tolerance in HPC applications. It provides index space management and load balancing for existing and new HPC applications.

1. Dai Yang, Josef Weidendorfer, Carsten Trinitis
Technische Universität München
Fakultät für Informatik
Lehrstuhl für Rechnertechnik und Rechnerorganisation
05.05.2017
LAIK: A Library for Fault Tolerant Distribution of
Global Data for Parallel Applications
ENVELOPE – Effizienz und Zuverlässigkeit: Selbstorganisation in HPC-Systemen
PARS Workshop 2017
Leichtgewichtige Anwendungs-Integrierte Datenhaltungs-Komponente

2. • Komplexität
Verbergen der Komplexität heterogener HPC-Systeme vor dem
Anwendungsprogrammierer
• Effizienz
Ermöglichen einer effizienten Nutzung in Bezug auf die Laufzeit der Anwendung und den
Energieverbrauch der zur Verfügung stehenden Ressourcen der Zielplattform
• Zuverlässigkeit
Erhöhung der Zuverlässigkeit und Ausfallsicherheit
2(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
Hintergrund ENVELOPE

3. Probleme:
• Fehlende Dynamik in Anwendungen
• bei zunehmend heterogener Architektur
• eingeschränkte Flexibilität durch den Ressorcenmanager
• Globales Checkpointing & Restart skaliert nicht für Exascale
3(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
Probleme

4. Hintergrund
• Anwendungsintegrierter Ansatz als Teil von ENVELOPE
• Als Vergleich zu dem systemintegrierten Ansatz
• Für existierende und neue Anwendungen
Kerngedanken
• Austauschen/Vergrößern/Verkleinern von Rechenressourcen („Malleable“ Application)
• Inkrementelle Portierbarkeit
• Modularisiert
• Datenorientiert, nicht taskorientiert
• Partitionierung von Indexraum
• SPMD-Modell
• verschachtelte Instanzen auf verschiedenen Ebenen
• z.B. Inter/Intra - Node
4(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
Ziele

5. Module
• Indexraumverwaltung (Kern) Pretschner
• Datenverwaltung
• Kommunikationsmodul
• Steuerungsmodul
Schnittstellen
• Anwendung - LAIK
• LAIK – Steuerung wie MQTT
• LAIK – Kommunikationsbackend wie MPI
• LAIK – Partitionierungsalgorithmen wie getEW
5(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
LAIK (0) – Module und Schnittstellen

6. • Integration in die Anwendung
• Standarddatentypen (1D/2D Matrix) + (künftig) eigene Datenstrukturen
• Standard-Backends (MPI/Shared Memory) + (künftig) eigene Backends
6(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
LAIK (1) – Aufbau und Kommunikations-Backend

7. • reine Partitionierung des Indexraums (Indirektion)
• Lastbalanzierung nach verschiedenen Kriterien:
• Gleichverteilt (Canonical)
• per Gewichtsfunktion
• (künftig) mittels Profilingdaten / Machine Learning
• Fehlertoleranz
• Proaktiv, durch Repartitionierung
• Reaktiv, durch lokales in-memory Checkpointing
• (künftig) auch mittels non-volatile Memory (Intel® Optane™ Technology)
• Highlight – Fehlertoleranz + Lastbalanzierung ist (fast) gleiche Funktionalität
• MPI, Shared Memory, TCP, OpenMP, OpenCL als Kommunikationsbackend geplant
• MQTT und TCP für die Anbindung von Fehlererkennung und Systemmonitoring
7(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
LAIK (2) Funktionalitäten

8. • Read-Write/Read-only/Write-only für beste Performanz und
Datenlokalität
• flexible Kopplung der Datenpartitionen (Bild unten)
• Datenkonsistenz explizit erzwingen, mittels Reduktionsoperation
• Vergrößern/Schrumpfen der Datenpartitionen
• ermöglicht asynchrone Ausführung (z.B. bei Stencil-Code)
8(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
LAIK (3) – Partitioning

9. • Partitionierungstypen
o Master: alle Daten in einer Partition
o Stripe: jede Partition erhält gleich viel Daten (nach Anzahl der Elemente)
o Weighted Stripe: jede Partition erhält soviel Daten, wie der User es angibt
o weitere folgen
• Reduktionsfunktionen
o Max
o Min
o Sum
o Prod
9(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
LAIK (4) – Partitioning

10. • multiple Partitionierung auf verschiedenen Ebenen
• Beispiel: inter/intra-node
• sinnvoll für Exascale, heterogene Systeme
• Veränderung des Indexraums muss möglich sein!
LAIK (5) – Hierarchische Partitionierung
(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017 10

11. LAIK (6) – Lastbalanzierung
• Adaption an sich ändernde
Anzahl von Knoten
(Fehlertoleranz)
• Adaption an sich ändernde
Rechenresourcen (z.B. aufgrund
von ausgefallenen CPU/GPU)
• Adaption an sich ändernden
Rechenbedarf (z.B. verschiedene
Programmphasen)
(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017 11
Ausführung
synchronisieren
(aktuell) All-
Reduce
auslösen
Neue Partitionen
berechnen
Ausführung
starten
Über Programmphasen Nächste Phase

12. LAIK (7) – Fehlertoleranz, Proaktiv
• Adaption an sich ändernde
Anzahl von Knoten
-> Proaktive Fehlertoleranz
-> benötigt Fehlervorhersage
• Recovery bei Spontanausfall
-> Reaktive Fehlertoleranz
-> benötigt Fehlererkennung
(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017 12
Standard MPI unterstützt dieses Vorgehen nicht!
Signal
„drohender
Ausfall“
Synchronisieren
Ausführung
stoppen
Knoten
ausschließen
Repartitionieren

13. LAIK (8) – Fehlertoleranz, Reaktiv
(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017 13
Über Programmphasen Nächste Phase
Knotenausfall
detektiert
Ausführung
synchronisieren
Am Backup-
Knoten
Berechnung
neu ausführen
Knoten
ausschließen
Repartitionieren
• vielfältige Erweiterbarkeit für das Checkpointingverfahren
• (zukünftig) auch asynchrone Recovery
• (zukünftig) anfordern von neuen Knoten als Ersatz

14. 14(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
Beispiel: Sparse Matrix Vector Multiplication (1)
#include "laik.h"
#include "laik-backend-mpi.h"
double getEW(Laik_Index* i, void* d);
int main(int argc, char* argv[])
{
Laik_Instance* inst = laik_init_mpi(&argc, &argv);
Laik_Group* world = laik_world(inst);
// generate diagonal matrix in CSR format
SpM* m = getSPM(…);
// global vector
double* v = getVector(…);
// 1d space for matrix rows and vector <res>
Laik_Space* s = laik_new_space_1d(inst, SIZE);
// result vector
Laik_Data* resD = laik_alloc(world, s, laik_Double);
// block partitioning according to elems in matrix rows
Laik_Partitioning* p;
p = laik_new_base_partitioning(s, LAIK_PT_Block,
LAIK_AB_ReadWrite);
laik_set_index_weight(p, getEW, m);
laik_set_partitioning(resD, p);
…
double* res;
uint64_t count;
Laik_Slice* slc;
int fromRow, toRow;
for(int iter = 0; iter < 10; iter++)
{
// init result vector (only my partition)
laik_map_def1(resD, (void**) &res, &count);
…

15. 15(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
Beispiel: Sparse Matrix Vector Multiplication (2)
slc = laik_my_slice(p);
fromRow = slc->from.i[0];
toRow = slc->to.i[0];
…
}
// push result to master
laik_set_new_partitioning(resD, LAIK_PT_Master,
LAIK_AB_ReadOnly);
if (laik_myid(world) == 0) {
laik_map_def1(resD, (void**) &res, &count);
double sum = 0.0;
for(uint64_t i = 0; i < count; i++) sum += res[i];
printf("Res sum (regular): %fn", sum);
}
// other way to push results to master: use sum
reduction
laik_set_new_partitioning(resD, LAIK_PT_All,
LAIK_AB_Sum);
laik_map_def1(resD, (void**) &res, &count);
slc = laik_my_slice(p);
fromRow = slc->from.i[0];
toRow = slc->to.i[0];
…
laik_set_new_partitioning(resD, LAIK_PT_Master,
LAIK_AB_ReadOnly);
if (laik_myid(world) == 0) {
laik_map_def1(resD, (void**) &res, &count);
double sum = 0.0;
for(uint64_t i = 0; i < count; i++) sum += res[i];
printf("Res sum (reduce): %fn", sum);
}
laik_finalize(inst);

16. • LAIK
https://github.com/envelope-project/laik
• Josef Weidendorfer:
weidendo@in.tum.de
• Dai Yang
d.yang@tum.de
• Carsten Trinitis
carsten.trinitis@tum.de
16(C) LRR TUM | LAIK | Projekt ENVELOPE | PARS Workshop 2017
Infos