Safe Non-blocking Synchronization in Ada 202x
Johann Blieberger, Bernd Burgstaller

TL;DR
This paper introduces a novel high-level language construct called concurrent objects in Ada 202x, enabling safe, non-blocking synchronization through fine-grained, optimistic memory ordering mechanisms, improving scalability and programmability.
Contribution
It presents the first high-level language construct for non-blocking synchronization in Ada, extending its memory model with synchronized types and concurrent objects for better scalability.
Findings
Concurrent objects enable parallel execution of entities.
Memory ordering is controlled via labels on shared data accesses.
The approach improves scalability and safety in concurrent Ada programs.
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…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
