Uniqueness and reference immutability for safe parallelism

Gordon, Colin S.; Parkinson, Matthew; Parsons, Jared; Bromfield, Aleks; Duffy, J.M.

doi:10.1145/2384616.2384619

Cited by 64 publications

(83 citation statements)

References 42 publications

(28 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We believe our results on sharing idioms can achieve similar success informing the design of ownership type systems. Results on the frequency of sharing of immutable objects and isolation have already demonstrated great utility [13]. Our detailed results on immutability/isolation, singletons and other global structures also point to further advances in type and annotation systems; they indicate that lightweight annotations that capture simple sharing relations show promise.…”

Section: Introductionmentioning

confidence: 55%

Collecting a heap of shapes

Barr

Bird

Marron

2013

Proceedings of the 2013 International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

The program heap is fundamentally a simple mathematical concept -a set of objects and a connectivity relation on them. However, a large gap exists between the set of heap structures that could be constructed and those that programmers actually build. To understand this gap, we empirically study heap structures and sharing relations in large object-oriented programs. To scale and make sense of real world heaps, any analysis must employ abstraction; our abstraction groups sets of objects by role and the aliasing present in pointer sets. We find that the heaps of real-world programs are, in practice, fundamentally simple structures that are largely constructed from a small number of simple structures and sharing idioms, such as the sharing of immutable or unique (e.g. singleton) objects. For instance, we find that, under our abstraction, 53-75% of pointers build tree structures and we classify all but 7-18% of aliasing pointers. These results provide actionable information for rethinking the design of annotation systems, memory allocation/collection, and program analyses.

show abstract

Section: Introductionmentioning

confidence: 55%

Collecting a heap of shapes

Barr

Bird

Marron

2013

Proceedings of the 2013 International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

show abstract

“…Concurrent abstract predicates has been extended with higher-order features, using Views extended with step-indexing to prove soundness [30]. The Views Framework has been extended to reason about C with interesting permission annotations to ensure isolation between threads [17]. Views are also helping in the development of sound logics for local reasoning about intrinsically structured data, such as file systems [16]; in this setting, decomposing data into fragments that record how they are connected is central, and is elegantly justified by the semantic entailment of Views.…”

Section: Discussionmentioning

confidence: 99%

Views

et al. 2013

View full text Add to dashboard Cite

Compositional abstractions underly many reasoning principles for concurrent programs: the concurrent environment is abstracted in order to reason about a thread in isolation; and these abstractions are composed to reason about a program consisting of many threads. For instance, separation logic uses formulae that describe part of the state, abstracting the rest; when two threads use disjoint state, their specifications can be composed with the separating conjunction. Type systems abstract the state to the types of variables; threads may be composed when they agree on the types of shared variables.In this paper, we present the "Concurrent Views Framework", a metatheory of concurrent reasoning principles. The theory is parameterised by an abstraction of state with a notion of composition, which we call views. The metatheory is remarkably simple, but highly applicable: the rely-guarantee method, concurrent separation logic, concurrent abstract predicates, type systems for recursive references and for unique pointers, and even an adaptation of the Owicki-Gries method can all be seen as instances of the Concurrent Views Framework. Moreover, our metatheory proves each of these systems is sound without requiring induction on the operational semantics.

show abstract

“…Given these difficulties, a viable approach for efficiently providing SC is to restrict the use of shared-memory in programming languages [11,10,7,16]. Boyapati et al [11,10] use ownership types to only allow a shared-memory access when holding appropriate locks.…”

Section: Related Work and Conclusionmentioning

confidence: 99%

“…Determinstic Parallel Java [7] statically guarantees detereminism and data-racefreedom (and hence SC) through a sophisticated type-and effect system. Similarly, Gordon et al [16] propose a type system where mutations to objects are only performed by threads that own a unique pointer to that object. However, these approaches create a significant programmer burden in terms of type annotations to ensure SC.…”

Section: Related Work and Conclusionmentioning

confidence: 99%

SC-Haskell

Vollmer

Scott

Musuvathi

et al. 2017

Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

A core, but often neglected, aspect of a programming language design is its memory (consistency) model. Sequential consistency (SC) is the most intuitive memory model for programmers as it guarantees sequential composition of instructions and provides a simple abstraction of shared memory as a single global store with atomic read and writes. Unfortunately, SC is widely considered to be impractical due to its associated performance overheads.Perhaps contrary to popular opinion, this paper demonstrates that SC is achievable with acceptable performance overheads for mainstream languages that minimize mutable shared heap. In particular, we modify the Glasgow Haskell Compiler to insert fences on all writes to shared mutable memory accessed in nonfunctional parts of the program. For a benchmark suite containing 1,279 programs, SC adds a geomean overhead of less than 0.4% on an x86 machine.The efficiency of SC arises primarily due to the isolation provided by the Haskell type system between purely functional and thread-local imperative computations on the one hand, and imperative computations on the global heap on the other. We show how to use new programming idioms to further reduce the SC overhead; these create a virtuous cycle of less overhead and even stronger semantic guarantees (static data-race freedom).

show abstract

Uniqueness and reference immutability for safe parallelism

Cited by 64 publications

References 42 publications

Collecting a heap of shapes

Collecting a heap of shapes

Views

SC-Haskell

Contact Info

Product

Resources

About