Safe and Efficient Data Sharing for Message-Passing Concurrency

Abstract

International audienceMessage passing provides a powerful communication abstraction in both distributed and shared memory environments. It is particularly successful at preventing problems arising from shared state, such as data races, as it avoids sharing in general. Message passing is less effective when concurrent access to large amounts of data is needed, as the overhead of messaging may be prohibitive. In shared memory environments, this issue could be alleviated by supporting direct access to shared data; but then ensuring proper synchronization becomes again the dominant problem. This paper proposes a safe and efficient approach to data sharing in message-passing concurrency models based on the idea of distinguishing active and passive computational units. Passive units do not have execution capabilities but offer to active units exclusive and direct access to the data they encapsulate. The access is transparent due to a single primitive for both data access and message passing. By distinguishing active and passive units, no additional infrastructure for shared data is necessary. The concept is applied to SCOOP, an object-oriented concurrency model, where it reduces execution time by several orders of magnitude on data-intensive parallel programs

A Graph-Based Semantics Workbench for Concurrent Asynchronous Programs

“…They are also unlikely to be the last, as new language features continue to be proposed, prototyped, and integrated, e.g. [27]. Despite the possible ramifications to behavioural and safety properties of existing programs, little work has been done to support formal and automatic comparisons of the program executions permitted by these different semantics.…”

A semantics comparison workbench for a concurrent, asynchronous, distributed programming language

“…We are currently working on extending Scoop-Gts to cover some more advanced and esoteric features of Scoop and D-Scoop (e.g. exception handling [MNM12], compensation [SPM16], passive handlers [MNM14]), and plan to extend the benchmark set to produce a comprehensive conformance test suite for the Scoop family of semantics. We are continuing to look for ways of refactoring Scoop-Gts to improve performance and broaden the class of programs it can handle practically, noting the impact that the shapes of rules and control programs can have on Groove's running time [ZR14].…”

“…Furthermore, the latest semantics is unlikely to be the last, as new language features continue to be proposed and integrated with the existing abstractions, e.g. shared memory [MNM14] and distributed programming extensions [SPM16]. Together, these can be seen as a family of semantics for the Scoop language, but a family that is partially-conflicting.…”

Chocola

“…Next, we highlight approaches to share memory between actors. Sharing actors [44] and passive processors [49] can share memory between multiple readers, but only one writer is allowed. Domains [19] are containers that can be accessed from multiple actors, but writing must happen asynchronously.…”