Deny capabilities for safe, fast actors

@article{Clebsch2015DenyCF,
  title={Deny capabilities for safe, fast actors},
  author={Sylvan Clebsch and Sophia Drossopoulou and Sebastian Blessing and Andy McNeil},
  journal={Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control},
  year={2015}
}
  • S. Clebsch, S. Drossopoulou, Andy McNeil
  • Published 26 October 2015
  • Computer Science
  • Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control
Abstract Combining the actor-model with shared memory for performance is efficient but can introduce data-races. Existing approaches to static data-race freedom are based on uniqueness and immutability, but lack flexibility and high performance implementations. Our approach, based on deny properties, allows reading, writing and traversing unique references, introduces a new form of write uniqueness, and guarantees atomic behaviours. 
Implementing Safe Sharing Features for Encore
Actor isolation is an important property in parallel and concurrent programs that utilize the actor model. However, when expressing certain patterns isolation can sometimes be too strong and forces
Soundness of a Concurrent Collector for Actors (Extended Version)
TLDR
This work presents a model of ORCA which is parametric to the host language and its type system, and gives invariants preserved by ORCA, and proves its soundness and completeness.
Towards Gradual Checking of Reference Capabilities
TLDR
This work in progress proposes to mix the ideas from the reference capability literature with gradual typing, leading to gradual reference capabilities, an all-in or nothing game for reference capability languages.
Reference Capabilities for Trait Based Reuse and Concurrency Control
The proliferation of shared mutable state in object-orientedprogramming complicates software development as two seeminglyunrelated operations may interact via an alias and produceunexpected results
Towards Gradual Checking of Reference Capabilities Work in Progress
TLDR
This work in progress proposes to mix the ideas from the reference capability literature with gradual typing, leading to gradual reference capabilities.
Correctness of a Concurrent Object Collector for Actor Languages
TLDR
This work presents a model of ORCA which is parametric to the host language and its type system, and gives invariants preserved by ORCA, and proves its soundness and completeness.
Rusty Links in Local Chains
TLDR
This work sketches how more more “local” ownership could be added to Rust, permitting multiple mutable references to objects, provided each reference is bounded by the object’s lifetime.
Reference Capabilities for Concurrency Control
The proliferation of shared mutable state in object-oriented programming complicates software development as two seemingly unrelated operations may interact via an alias and produce unexpected resu
Flexible recovery of uniqueness and immutability (Extended Version)
TLDR
An imperative object calculus where types are annotated with qualifiers for aliasing and mutation control, that is, using the type context to justify strengthening types, greatly improving its power by permitting to recover uniqueness and immutability properties even in presence of other references.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 37 REFERENCES
Minimal Ownership for Active Objects
TLDR
A minimal variant of ownership types is proposed that preserves the required race freedom invariant yet enables data transfer by reference between active objects in many cases, and a cheap clone operation where copying is necessary.
Uniqueness and reference immutability for safe parallelism
TLDR
This paper presents a type system to restrict the updates to memory to prevent these unintended side-effects of concurrent programming, and provides a novel combination of immutable and unique types that ensures safe parallelism and deterministic execution.
Ownership, Uniqueness, and Immutability
TLDR
This work reports on the consolidation of the resulting discoveries into a single programming language, Joe 3, which imposes little additional syntactic overhead, yet can encode powerful patterns such as fractional permissions and the reference modes of Flexible Alias Protection.
Alias burying: Unique variables without destructive reads
An unshared object can be accessed without regard to possible conflicts with other parts of a system, whether concurrent or single‐threaded. A unique variable (sometimes known as a ‘free’ or ‘linear’
Kilim: Isolation-Typed Actors for Java
TLDR
Kilim is a framework that employs a combination of techniques to help create robust, massively concurrent systems in mainstream languages such as Java: (i) ultra-lightweight, cooperatively-scheduled threads, (ii) a message-passing framework and (iii) isolation-aware messaging.
Checking Interference with Fractional Permissions
TLDR
An operational semantics of a simple imperative language with structured parallelism is given and it is proved that the permission system enables parallelism to proceed with deterministic results.
Capabilities for Uniqueness and Borrowing
TLDR
A new approach to uniqueness is introduced, to use capabilities for enforcing both at-most-once consumption of unique references, and a flexible notion of uniqueness, based on simple, unstructured capabilities.
Types for Safe Locking
TLDR
This paper presents a core, first-order type system focused on race conditions for a concurrent, imperative language, and considers extensions with polymorphism, existential types, and a partial order on lock types.
Robust composition: towards a unified approach to access control and concurrency control
TLDR
This dissertation presents a framework for enabling those interactions between components needed for the cooperation the authors intend, while minimizing the hazards of destructive interference, in E, a distributed, persistent, secure programming language.
Native actors: a scalable software platform for distributed, heterogeneous environments
TLDR
Thorough performance evaluations reveal an extraordinary small memory footprint in realistic application scenarios, while runtime performance not only outperforms existing mature actor implementations, but exceeds the scaling behavior of low-level message passing libraries such as OpenMPI.
...
1
2
3
4
...