Safe non-blocking synchronization in Ada2x

Johann Blieberger, bernd Burgstaller

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

The mutual-exclusion property of locks stands in the way to scalability of parallel programs on many-core architectures. Locks do not allow progress guarantees, because a task may fail inside a critical section and keep holding a lock that blocks other tasks from accessing shared data. With non-blocking synchronization, the drawbacks of locks are avoided by synchronizing access to shared data by atomic read-modify-write operations. To incorporate non-blocking synchronization in Ada 202x, programmers must be able to reason about the behavior and performance of tasks in the absence of protected objects and rendezvous. We therefore extend Ada’s memory model by synchronized types, which support the expression of memory ordering operations at a sufficient level of detail. To mitigate the complexity associated with non-blocking synchronization, we propose concurrent objects as a novel high-level language construct. Entities of a concurrent object execute in parallel, due to a fine-grained, optimistic synchronization mechanism. Synchronization is framed by the semantics of concurrent entry execution. The programmer is only required to label shared data accesses in the code of concurrent entries. Labels constitute memory-ordering operations expressed through aspects and attributes. To the best of our knowledge, this is the first approach to provide a non-blocking synchronization construct as a first-class citizen of a high-level programming language. We illustrate the use of concurrent objects by several examples.

Original languageEnglish
Title of host publicationReliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings
EditorsAntónio Casimiro, Pedro M. Ferreira
PublisherSpringer Verlag
Pages53-69
Number of pages17
ISBN (Print)9783319924311
DOIs
Publication statusPublished - 2018 Jan 1
Event23rd International Conference on Reliable Software Technologies, Ada-Europe 2018 - Lisbon, Portugal
Duration: 2018 Jun 182018 Jun 22

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume10873 LNCS
ISSN (Print)0302-9743
ISSN (Electronic)1611-3349

Other

Other23rd International Conference on Reliable Software Technologies, Ada-Europe 2018
CountryPortugal
CityLisbon
Period18/6/1818/6/22

Fingerprint

Synchronization
Concurrent
Data storage equipment
Labels
High level languages
Mutual Exclusion
Rendezvous
Many-core
Memory Model
Parallel Programs
Computer programming languages
Programming Languages
Scalability
Semantics
Attribute
Sufficient
Object

All Science Journal Classification (ASJC) codes

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Blieberger, J., & Burgstaller, B. (2018). Safe non-blocking synchronization in Ada2x. In A. Casimiro, & P. M. Ferreira (Eds.), Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings (pp. 53-69). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 10873 LNCS). Springer Verlag. https://doi.org/10.1007/978-3-319-92432-8_4
Blieberger, Johann ; Burgstaller, bernd. / Safe non-blocking synchronization in Ada2x. Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings. editor / António Casimiro ; Pedro M. Ferreira. Springer Verlag, 2018. pp. 53-69 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{b40219cd1f5e407581610561c6d14b9b,
title = "Safe non-blocking synchronization in Ada2x",
abstract = "The mutual-exclusion property of locks stands in the way to scalability of parallel programs on many-core architectures. Locks do not allow progress guarantees, because a task may fail inside a critical section and keep holding a lock that blocks other tasks from accessing shared data. With non-blocking synchronization, the drawbacks of locks are avoided by synchronizing access to shared data by atomic read-modify-write operations. To incorporate non-blocking synchronization in Ada 202x, programmers must be able to reason about the behavior and performance of tasks in the absence of protected objects and rendezvous. We therefore extend Ada’s memory model by synchronized types, which support the expression of memory ordering operations at a sufficient level of detail. To mitigate the complexity associated with non-blocking synchronization, we propose concurrent objects as a novel high-level language construct. Entities of a concurrent object execute in parallel, due to a fine-grained, optimistic synchronization mechanism. Synchronization is framed by the semantics of concurrent entry execution. The programmer is only required to label shared data accesses in the code of concurrent entries. Labels constitute memory-ordering operations expressed through aspects and attributes. To the best of our knowledge, this is the first approach to provide a non-blocking synchronization construct as a first-class citizen of a high-level programming language. We illustrate the use of concurrent objects by several examples.",
author = "Johann Blieberger and bernd Burgstaller",
year = "2018",
month = "1",
day = "1",
doi = "10.1007/978-3-319-92432-8_4",
language = "English",
isbn = "9783319924311",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer Verlag",
pages = "53--69",
editor = "Ant{\'o}nio Casimiro and Ferreira, {Pedro M.}",
booktitle = "Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings",
address = "Germany",

}

Blieberger, J & Burgstaller, B 2018, Safe non-blocking synchronization in Ada2x. in A Casimiro & PM Ferreira (eds), Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 10873 LNCS, Springer Verlag, pp. 53-69, 23rd International Conference on Reliable Software Technologies, Ada-Europe 2018, Lisbon, Portugal, 18/6/18. https://doi.org/10.1007/978-3-319-92432-8_4

Safe non-blocking synchronization in Ada2x. / Blieberger, Johann; Burgstaller, bernd.

Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings. ed. / António Casimiro; Pedro M. Ferreira. Springer Verlag, 2018. p. 53-69 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 10873 LNCS).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

TY - GEN

T1 - Safe non-blocking synchronization in Ada2x

AU - Blieberger, Johann

AU - Burgstaller, bernd

PY - 2018/1/1

Y1 - 2018/1/1

N2 - The mutual-exclusion property of locks stands in the way to scalability of parallel programs on many-core architectures. Locks do not allow progress guarantees, because a task may fail inside a critical section and keep holding a lock that blocks other tasks from accessing shared data. With non-blocking synchronization, the drawbacks of locks are avoided by synchronizing access to shared data by atomic read-modify-write operations. To incorporate non-blocking synchronization in Ada 202x, programmers must be able to reason about the behavior and performance of tasks in the absence of protected objects and rendezvous. We therefore extend Ada’s memory model by synchronized types, which support the expression of memory ordering operations at a sufficient level of detail. To mitigate the complexity associated with non-blocking synchronization, we propose concurrent objects as a novel high-level language construct. Entities of a concurrent object execute in parallel, due to a fine-grained, optimistic synchronization mechanism. Synchronization is framed by the semantics of concurrent entry execution. The programmer is only required to label shared data accesses in the code of concurrent entries. Labels constitute memory-ordering operations expressed through aspects and attributes. To the best of our knowledge, this is the first approach to provide a non-blocking synchronization construct as a first-class citizen of a high-level programming language. We illustrate the use of concurrent objects by several examples.

AB - The mutual-exclusion property of locks stands in the way to scalability of parallel programs on many-core architectures. Locks do not allow progress guarantees, because a task may fail inside a critical section and keep holding a lock that blocks other tasks from accessing shared data. With non-blocking synchronization, the drawbacks of locks are avoided by synchronizing access to shared data by atomic read-modify-write operations. To incorporate non-blocking synchronization in Ada 202x, programmers must be able to reason about the behavior and performance of tasks in the absence of protected objects and rendezvous. We therefore extend Ada’s memory model by synchronized types, which support the expression of memory ordering operations at a sufficient level of detail. To mitigate the complexity associated with non-blocking synchronization, we propose concurrent objects as a novel high-level language construct. Entities of a concurrent object execute in parallel, due to a fine-grained, optimistic synchronization mechanism. Synchronization is framed by the semantics of concurrent entry execution. The programmer is only required to label shared data accesses in the code of concurrent entries. Labels constitute memory-ordering operations expressed through aspects and attributes. To the best of our knowledge, this is the first approach to provide a non-blocking synchronization construct as a first-class citizen of a high-level programming language. We illustrate the use of concurrent objects by several examples.

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

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

U2 - 10.1007/978-3-319-92432-8_4

DO - 10.1007/978-3-319-92432-8_4

M3 - Conference contribution

SN - 9783319924311

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 53

EP - 69

BT - Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings

A2 - Casimiro, António

A2 - Ferreira, Pedro M.

PB - Springer Verlag

ER -

Blieberger J, Burgstaller B. Safe non-blocking synchronization in Ada2x. In Casimiro A, Ferreira PM, editors, Reliable Software Technologies – Ada-Europe 2018 - 23rd Ada-Europe International Conference on Reliable Software Technologies, Proceedings. Springer Verlag. 2018. p. 53-69. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/978-3-319-92432-8_4