Reference Capabilities for Concurrency Control

Castegren, Elias; Wrigstad, Tobias

doi:10.4230/lipics.ecoop.2016.5

Cited by 11 publications

(7 citation statements)

References 0 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Finally, we note the connection to the safe type qualifier introduced by the Kappa type system [4], which ranges over both actors and locks (and immutables etc.). A value with a safe type can be accessed concurrently without risk of data-races, but how this is achieved depends on the type of the value at runtime.…”

Section: Abstracting Over Synchronisation Methodsmentioning

confidence: 99%

“…In previous work, we designed Kappa [4], a type system in which the boundary of a unit of encapsulation can be statically identified. An entire encapsulated unit can be wrapped inside some synchronisation mechanism, e.g., a lock or an asynchronous actor interface, and consequently all operations inside the boundary are guaranteed to be data-race free.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Actors without Borders: Amnesty for Imprisoned State

Castegren

Wrigstad

2017

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

In concurrent systems, some form of synchronisation is typically needed to achieve data-race freedom, which is important for correctness and safety. In actor-based systems, messages are exchanged concurrently but executed sequentially by the receiving actor. By relying on isolation and non-sharing, an actor can access its own state without fear of data-races, and the internal behavior of an actor can be reasoned about sequentially.However, actor isolation is sometimes too strong to express useful patterns. For example, letting the iterator of a data-collection alias the internal structure of the collection allows a more efficient implementation than if each access requires going through the interface of the collection. With full isolation, in order to maintain sequential reasoning the iterator must be made part of the collection, which bloats the interface of the collection and means that a client must have access to the whole data-collection in order to use the iterator.In this paper, we propose a programming language construct that enables a relaxation of isolation but without sacrificing sequential reasoning. We formalise the mechanism in a simple lambda calculus with actors and passive objects, and show how an actor may leak parts of its internal state while ensuring that any interaction with this data is still synchronised.

show abstract

Section: Abstracting Over Synchronisation Methodsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Actors without Borders: Amnesty for Imprisoned State

Castegren

Wrigstad

2017

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

show abstract

“…Linear Haskell [3] does not use a gradual approach. Instead, they feature quantification over multiplicities and parameterised arrows, which allows the common function Encore [6,7] and Pony [9] are capability-based languages that statically ensure data-race freedom. In these languages, all references need to be annotated to provide such guarantee.…”

Section: Related Workmentioning

confidence: 99%

“…Taking inspiration from the capability-based Encore language VMIL'19, October 22, 2019, Athens, Greece 2019. [6,7] and reusing the example above, one could add reference capabilities to the collection class to either forbid sharing or making the collection alias-free as follows,…”

Section: Introductionmentioning

confidence: 99%

Towards Gradual Checking of Reference Capabilities

Fernandez-Reyes,

Gariano,

Noble

et al. 2019

Preprint

Self Cite

View full text Add to dashboard Cite

Concurrent and parallel programming is difficult due to the presence of memory side-effects, which may introduce data races. Type qualifiers, such as reference capabilities, can remove data races by restricting sharing of mutable data.Unfortunately, reference capability languages are an all-in or nothing game, i.e., all the types must be annotated with reference capabilities. In this work in progress, we propose to mix the ideas from the reference capability literature with gradual typing, leading to gradual reference capabilities.

show abstract

“…Kappa is a type system for concurrent object-oriented programming [5]. Its most important guarantee is that no two concurrent operations will access the same memory address, unless both operations only use this address for reading.…”

Section: Background: Kappa and Encorementioning

confidence: 99%

Bestow and atomic: Concurrent programming using isolation, delegation and grouping

Castegren

Wallin

Wrigstad

2018

Journal of Logical and Algebraic Methods in Programming

Self Cite

View full text Add to dashboard Cite

Any non-trivial concurrent system warrants synchronisation, regardless of the concurrency model. Actorbased concurrency serialises all computations in an actor through asynchronous message passing. In contrast, lock-based concurrency serialises some computations by following a lock-unlock protocol for accessing certain data.Both systems require sound reasoning about pointers and aliasing to exclude data-races. If actor isolation is broken, so is the single-thread-of-control abstraction. Similarly for locks, if a datum is accessible outside of the scope of the lock, the datum is not governed by the lock.In this paper we discuss how to balance aliasing and synchronisation. In previous work, we defined a type system that guarantees data-race freedom of actor-based concurrency and lock-based concurrency. This paper extends this work by the introduction of two programming constructs; one for decoupling isolation and synchronisation and one for constructing higher-level atomicity guarantees from lower-level synchronisation. We focus predominantly on actors, and in particular the Encore programming language, but our ultimate goal is to define our constructs in such a way that they can be used both with locks and actors, given that combinations of both models occur frequently in actual systems.We discuss the design space, provide several formalisations of different semantics and discuss their properties, and connect them to case studies showing how our proposed constructs can be useful. We also report on an on-going implementation of our proposed constructs in Encore.In previous work, we designed Kappa [5], a type system in which the boundary of a unit of encapsulation can be statically identified. An entire encapsulated unit can be wrapped inside some synchronisation mechanism, e.g., a lock or an asynchronous actor interface, and consequently all operations inside the boundary are guaranteed to be data-race free. An important goal of this work is facilitating object-oriented reuse in concurrent programming: internal objects are oblivious to how their data-race freedom is guaranteed, and the building blocks can be reused without change regardless of their external synchronisation. Further, making synchronisation tractable simplifies concurrent programming as the portions of a system that are accessed concurrently will be identified, and compilers can verify that the program behaves in accordance with the programmer's intention, with respect to concurrent accesses.This paper explores two extensions to the Kappa system, which we explain in the context of the actor model (although they are equally applicable to a system using locks). The first extension, bestow, allows references to an object to escape its unit of encapsulation without escaping its unit of synchronisation; all external operations on private state will be implicitly delegated to the owner of that state, either via message passing, or by acquiring a lock specific to the owner of the private state. This enables several useful programming patterns without relax...

show abstract

Reference Capabilities for Concurrency Control

Cited by 11 publications

References 0 publications

Actors without Borders: Amnesty for Imprisoned State

Actors without Borders: Amnesty for Imprisoned State

Towards Gradual Checking of Reference Capabilities

Bestow and atomic: Concurrent programming using isolation, delegation and grouping

Contact Info

Product

Resources

About