Handling Parallelism in a Concurrency Model

Schill, Mischael; Nanz, Sebastian; Meyer, Bertrand

doi:10.1007/978-3-642-39955-8_4

Cited by 4 publications

(4 citation statements)

References 6 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In future work, we plan to improve the efficiency of D-SCOOP with respect to intraobject parallelism [11,13]. We will investigate concepts such as slicing [22], and the possible integration of software transactional memory [9]. We will also investigate whether performance can be improved, by (safely) relaxing the requirement that one node communicates with another via a single connection.…”

Section: Discussionmentioning

confidence: 99%

An Interference-Free Programming Model for Network Objects

Schill

Poskitt

Meyer

2016

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

Abstract. Network objects are a simple and natural abstraction for distributed object-oriented programming. Languages that support network objects, however, often leave synchronization to the user, along with its associated pitfalls, such as data races and the possibility of failure. In this paper, we present D-SCOOP, a distributed programming model that allows for interference-free and transactionlike reasoning on (potentially multiple) network objects, with synchronization handled automatically, and network failures managed by a compensation mechanism. We achieve this by leveraging the runtime semantics of a multi-threaded object-oriented concurrency model, directly generalizing it with a message-based protocol for efficiently coordinating remote objects. We present our pathway to fusing these contrasting but complementary ideas, and evaluate the performance overhead of the automatic synchronization in D-SCOOP, finding that it comes close to-or outperforms-explicit locking-based synchronization in Java RMI.

show abstract

Section: Discussionmentioning

confidence: 99%

An Interference-Free Programming Model for Network Objects

Schill

Poskitt

Meyer

2016

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

show abstract

“…Schill et al [25] developed a library offering indexed arrays that can be accessed concurrently by multiple SCOOP processors. To prevent data races on an array, each processor must reserve a slice of the array.…”

Section: Related Workmentioning

confidence: 99%

“…Some languages and libraries [8,16,19,25] have already combined mutually exclusive shared data with message passing and observed performance gains on shared memory systems. However, as discussed in Section 6, these approaches either impose restrictions on the shared data or do not provide unified primitives for data access and message passing.…”

Section: Introductionmentioning

confidence: 99%

Safe and Efficient Data Sharing for Message-Passing Concurrency

Morandi

Nanz

Meyer

2014

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

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

show abstract

“…The original monitor concept [13], where a monitor protects all its associated shared resources (its attributes), follows the idea to make the connection between locks and resources explicit. Message-passing programming models, such as the Actor model [12] or SCOOP [20], simply avoid incorrect memory access by not sharing state; in dataintensive parallel applications, this approach incurs much data messaging overhead, which might be prohibitive unless combined with other techniques [24]. Our approach applies to shared-memory environments.…”

Section: Related Workmentioning

confidence: 99%

Dynamic Checking of Safe Concurrent Memory Access using Shared Ownership

Schill¹,

Nanz²,

Meyer³

2014

Preprint

Self Cite

View full text Add to dashboard Cite

In shared-memory concurrent programming, shared resources can be protected using synchronization mechanisms such as monitors or channels. The connection between these mechanisms and the resources they protect is, however, only given implicitly; this makes it difficult both for programmers to apply the mechanisms correctly and for compilers to check that resources are properly protected. This paper presents a mechanism to automatically check that shared memory is accessed properly, using a methodology called shared ownership. In contrast to traditional ownership, shared ownership offers more flexibility by permitting multiple owners of a resource. On the basis of this methodology, we define an abstract model of resource access that provides operations to manage data dependencies, as well as sharing and transfer of access privileges. The model is rigorously defined using a formal semantics, and shown to be free from data races. This property can be used to detect unsafe memory accesses when simulating the model together with the execution of a program. The expressiveness and efficiency of the approach is demonstrated on a variety of programs using common synchronization mechanisms.

show abstract

Handling Parallelism in a Concurrency Model

Cited by 4 publications

References 6 publications

An Interference-Free Programming Model for Network Objects

An Interference-Free Programming Model for Network Objects

Safe and Efficient Data Sharing for Message-Passing Concurrency

Dynamic Checking of Safe Concurrent Memory Access using Shared Ownership

Contact Info

Product

Resources

About