Cloning in ownership

Li, Paley; Cameron, Nicholas; Noble, James

doi:10.1145/2048147.2048175

Cited by 9 publications

(5 citation statements)

References 4 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The above is now accepted by the Rust compiler. The £ ¢ ¡ clone() method is provided by types implementing the £ ¢ ¡ Clone trait and, generally speaking, performs a deep clone up to borrowed references (i.e., roughly approximating a sheep clone [82,98]).…”

Section: Ownershipmentioning

confidence: 99%

“…7.2.2 Ownership. Ownership types and related systems attempt-in a similar fashion to Balloons-to provide strong guarantees about when and where aliasing is permitted between objects [2,21,29,35,37,44,62,82,85,98,99,101,106,118,136]. They have found use in areas such as: parallel and concurrent systems [21,22], specification languages [13,94], real-time systems [5,107], and more.…”

Section: Balloonsmentioning

confidence: 99%

See 1 more Smart Citation

A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust

Pearce

2021

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

Rust is a relatively new programming language that has gained significant traction since its v1.0 release in 2015. Rust aims to be a systems language that competes with C/C++. A claimed advantage of Rust is a strong focus on memory safety without garbage collection. This is primarily achieved through two concepts, namely, reference lifetimes and borrowing . Both of these are well-known ideas stemming from the literature on region-based memory management and linearity / uniqueness . Rust brings both of these ideas together to form a coherent programming model. Furthermore, Rust has a strong focus on stack-allocated data and, like C/C++ but unlike Java, permits references to local variables. Type checking in Rust can be viewed as a two-phase process: First, a traditional type checker operates in a flow-insensitive fashion; second, a borrow checker enforces an ownership invariant using a flow-sensitive analysis. In this article, we present a lightweight formalism that captures these two phases using a flow-sensitive type system that enforces “ type and borrow safety .” In particular, programs that are type and borrow safe will not attempt to dereference dangling pointers. Our calculus core captures many aspects of Rust, including copy- and move-semantics, mutable borrowing, reborrowing, partial moves, and lifetimes. In particular, it remains sufficiently lightweight to be easily digested and understood and, we argue, still captures the salient aspects of reference lifetimes and borrowing. Furthermore, extensions to the core can easily add more complex features (e.g., control-flow, tuples, method invocation). We provide a soundness proof to verify our key claims of the calculus. We also provide a reference implementation in Java with which we have model checked our calculus using over 500B input programs. We have also fuzz tested the Rust compiler using our calculus against 2B programs and, to date, found one confirmed compiler bug and several other possible issues.

show abstract

Section: Ownershipmentioning

confidence: 99%

Section: Balloonsmentioning

confidence: 99%

A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust

Pearce

2021

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

show abstract

“…localOwner(𝐻 , 𝑖, 𝑣) 10 The helper function OkDup(𝐻 , 𝐾, 𝑣) is a standard deep-copying operation. [17,52] For simplicity, we have gathered some rules that trap capability errors at run-time in Fig. 9.…”

Section: Dynamic Semanticsmentioning

confidence: 99%

Dala: A Simple Capability-Based Dynamic Language Design For Data Race-Freedom

Fernandez-Reyes¹,

Gariano²,

Noble³

et al. 2021

Preprint

Self Cite

View full text Add to dashboard Cite

Dynamic languages like Erlang, Clojure, JavaScript, and E adopted data-race freedom by design. To enforce data-race freedom, these languages either deep copy objects during actor (thread) communication or proxy back to their owning thread. We present Dala, a simple programming model that ensures data-race freedom while supporting efficient inter-thread communication. Dala is a dynamic, concurrent, capability-based language that relies on three core capabilities: immutable values can be shared freely; isolated mutable objects can be transferred between threads but not aliased; local objects can be aliased within their owning thread but not dereferenced by other threads. Objects with capabilities can co-exist with unsafe objects, that are unchecked and may suffer data races, without compromising the safety of safe objects. We present a formal model of Dala, prove data racefreedom and state and prove a dynamic gradual guarantee. These theorems guarantee data race-freedom when using safe capabilities and show that the addition of capabilities is semantics preserving modulo permission and cast errors.

show abstract

“…The recurSC formalism is published in the paper "Sheep Cloning with Ownership Types" [52], while the mapSC and descripSC formalisms are published in the paper "Dynamic Semantics of Sheep Cloning: Proving Cloning" [53].…”

Section: Formalising Sheep Cloningmentioning

confidence: 99%

Object Cloning for Ownership Systems

Li¹

View full text Add to dashboard Cite

<p>Modern object-oriented programming languages frequently need the ability to clone, duplicate, and copy objects. The usual approaches taken by languages are rudimentary, primarily because these approaches operate with little understanding of the object being cloned. Deep cloning naively copies every object that has a reachable reference path from the object being cloned, even if the objects being copied have no innate relationship with that object. For more sophisticated cloning operations, languages usually only provide the capacity for programmers to define their own cloning operations for specific objects, and with no help from the type system. Sheep cloning is an automated operation that clones objects by leveraging information about those objects’ structures, which the programmer imparts into their programs with ownership types. Ownership types are a language mechanism that defines an owner for every object in the program. Ownership types create a hierarchical structure for the heap. In this thesis, we construct an extensible formal model for an object-oriented language with ownership types (Core), and use it to explore different formalisms of sheep cloning. We formalise three distinct operational semantics of sheep cloning, and for each approach we include proofs or proof outlines where appropriate, and provide a comparative analysis of each model’s benefits. Our main contribution is the descripSC formal model of sheep cloning and its proof of type soundness. The second contribution of this thesis is the formalism of Mojo-jojo, a multiple ownership system that includes existential quantification over types and context parameters, along with a constraint system for context parameters. We prove type soundness for Mojo-jojo. Multiple ownership is a mechanism which allows objects to have more than one owner. Context parameters in Mojo-jojo can use binary operators such as: intersection, union, and disjointness.</p>

show abstract

Cloning in ownership

Cited by 9 publications

References 4 publications

A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust

A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust

Dala: A Simple Capability-Based Dynamic Language Design For Data Race-Freedom

Object Cloning for Ownership Systems

Contact Info

Product

Resources

About