Programming models and runtimes

Georges Da Costa; Alexey L. Lastovetsky; Jorge G. Barbosa; Juan Carlos Díaz-Martín; Juan Luis García-Zapata; Matthias Janetschek; Emmanuel Jeannot; João Leitão; Ravi Reddy Manumachu; Radu Prodan; Juan A. Rico-Gallego; Peter Van Roy; Ali Shoker; Albert Van Der Linde

doi:10.1049/PBPC024E_ch2

Programming models and runtimes

Georges Da Costa, Alexey L. Lastovetsky, Jorge G. Barbosa, Juan Carlos Díaz-Martín, Juan Luis García-Zapata, Matthias Janetschek, Emmanuel Jeannot, João Leitão, Ravi Reddy Manumachu, Radu Prodan, Juan A. Rico-Gallego, Peter Van Roy, Ali Shoker, Albert Van Der Linde

Research output: Chapter in Book/Report/Conference proceeding › Chapter › peer-review

1 Citation (Scopus)

Abstract

Several millions of execution flows will be executed in ultrascale computing systems (UCS), and the task for the programmer to understand their coherency and for the runtime to coordinate them is unfathomable. Moreover, related to UCS large scale and their impact on reliability, the current static point of view is not more sufficient. A runtime cannot consider to restart an application because of the failure of a single node as statically several nodes will fail every day. Classical management of these failures by the programmers using checkpoint restart is also too limited due to the overhead at such a scale. The article explores programming models and runtimes required to facilitate the task of scaling and extracting performance on continuously evolving platforms, while providing resilience and fault-tolerant mechanisms to tackle the increasing probability of failures throughout the whole software stack.

Original language	English
Title of host publication	Ultrascale Computing Systems
Publisher	Institution of Engineering and Technology
Pages	9-64
Number of pages	56
ISBN (Electronic)	9781785618345
ISBN (Print)	9781785618338
DOIs	https://doi.org/10.1049/PBPC024E_ch2
Publication status	Published - 1 Jan 2019

Keywords

Checkpoint restart
Checkpointing
Distributed programming
Failure management
Fault-tolerant mechanisms
Programming models
Runtimes
Software fault tolerance
Software stack
Ultrascale computing systems

Access to Document

10.1049/PBPC024E_ch2

Cite this

Da Costa, G., Lastovetsky, A. L., Barbosa, J. G., Díaz-Martín, J. C., García-Zapata, J. L., Janetschek, M., Jeannot, E., Leitão, J., Manumachu, R. R., Prodan, R., Rico-Gallego, J. A., Van Roy, P., Shoker, A., & Van Der Linde, A. (2019). Programming models and runtimes. In Ultrascale Computing Systems (pp. 9-64). Institution of Engineering and Technology. https://doi.org/10.1049/PBPC024E_ch2

@inbook{2022253d49aa4ca88fee20a236e90634,

title = "Programming models and runtimes",

abstract = "Several millions of execution flows will be executed in ultrascale computing systems (UCS), and the task for the programmer to understand their coherency and for the runtime to coordinate them is unfathomable. Moreover, related to UCS large scale and their impact on reliability, the current static point of view is not more sufficient. A runtime cannot consider to restart an application because of the failure of a single node as statically several nodes will fail every day. Classical management of these failures by the programmers using checkpoint restart is also too limited due to the overhead at such a scale. The article explores programming models and runtimes required to facilitate the task of scaling and extracting performance on continuously evolving platforms, while providing resilience and fault-tolerant mechanisms to tackle the increasing probability of failures throughout the whole software stack.",

keywords = "Checkpoint restart, Checkpointing, Distributed programming, Failure management, Fault-tolerant mechanisms, Programming models, Runtimes, Software fault tolerance, Software stack, Ultrascale computing systems",

author = "{Da Costa}, Georges and Lastovetsky, {Alexey L.} and Barbosa, {Jorge G.} and D{\'i}az-Mart{\'i}n, {Juan Carlos} and Garc{\'i}a-Zapata, {Juan Luis} and Matthias Janetschek and Emmanuel Jeannot and Jo{\~a}o Leit{\~a}o and Manumachu, {Ravi Reddy} and Radu Prodan and Rico-Gallego, {Juan A.} and {Van Roy}, Peter and Ali Shoker and {Van Der Linde}, Albert",

year = "2019",

month = jan,

day = "1",

doi = "10.1049/PBPC024E_ch2",

language = "English",

isbn = "9781785618338",

pages = "9--64",

booktitle = "Ultrascale Computing Systems",

publisher = "Institution of Engineering and Technology",

address = "United Kingdom",

}

TY - CHAP

T1 - Programming models and runtimes

AU - Da Costa, Georges

AU - Lastovetsky, Alexey L.

AU - Barbosa, Jorge G.

AU - Díaz-Martín, Juan Carlos

AU - García-Zapata, Juan Luis

AU - Janetschek, Matthias

AU - Jeannot, Emmanuel

AU - Leitão, João

AU - Manumachu, Ravi Reddy

AU - Prodan, Radu

AU - Rico-Gallego, Juan A.

AU - Van Roy, Peter

AU - Shoker, Ali

AU - Van Der Linde, Albert

PY - 2019/1/1

Y1 - 2019/1/1

N2 - Several millions of execution flows will be executed in ultrascale computing systems (UCS), and the task for the programmer to understand their coherency and for the runtime to coordinate them is unfathomable. Moreover, related to UCS large scale and their impact on reliability, the current static point of view is not more sufficient. A runtime cannot consider to restart an application because of the failure of a single node as statically several nodes will fail every day. Classical management of these failures by the programmers using checkpoint restart is also too limited due to the overhead at such a scale. The article explores programming models and runtimes required to facilitate the task of scaling and extracting performance on continuously evolving platforms, while providing resilience and fault-tolerant mechanisms to tackle the increasing probability of failures throughout the whole software stack.

AB - Several millions of execution flows will be executed in ultrascale computing systems (UCS), and the task for the programmer to understand their coherency and for the runtime to coordinate them is unfathomable. Moreover, related to UCS large scale and their impact on reliability, the current static point of view is not more sufficient. A runtime cannot consider to restart an application because of the failure of a single node as statically several nodes will fail every day. Classical management of these failures by the programmers using checkpoint restart is also too limited due to the overhead at such a scale. The article explores programming models and runtimes required to facilitate the task of scaling and extracting performance on continuously evolving platforms, while providing resilience and fault-tolerant mechanisms to tackle the increasing probability of failures throughout the whole software stack.

KW - Checkpoint restart

KW - Checkpointing

KW - Distributed programming

KW - Failure management

KW - Fault-tolerant mechanisms

KW - Programming models

KW - Runtimes

KW - Software fault tolerance

KW - Software stack

KW - Ultrascale computing systems

UR - http://www.scopus.com/inward/record.url?scp=85115674567&partnerID=8YFLogxK

U2 - 10.1049/PBPC024E_ch2

DO - 10.1049/PBPC024E_ch2

M3 - Chapter

AN - SCOPUS:85115674567

SN - 9781785618338

SP - 9

EP - 64

BT - Ultrascale Computing Systems

PB - Institution of Engineering and Technology

ER -

Programming models and runtimes

Abstract

Keywords

Access to Document

Other files and links

Fingerprint

Cite this