In EDS ansehen

Implicit ownership types for memory management

Gespeichert in:
Bibliographische Detailangaben
Titel: Implicit ownership types for memory management
Autoren: Zhao, Tian1 tzhao@uwm.edu, Baker, Jason2 jason.baker0@gmail.com, Hunt, James3 jjh@aicas.com, Noble, James4 kjx@mcs.vuw.ac.nz, Vitek, Jan2 jv@cs.purdue.edu
Quelle: Science of Computer Programming. May2008, Vol. 71 Issue 3, p213-241. 29p.
Schlagwörter: *COMPUTER memory management, *JAVA programming language, *MATHEMATICAL analysis, *COMPUTER storage devices
Abstract: Abstract: The Real-time Specification for Java (RTSJ) introduced a range of language features for explicit memory management. While the RTSJ gives programmers fine control over memory use and allows linear allocation and constant-time deallocation, the RTSJ relies upon dynamic runtime checks for safety, making it unsuitable for safety critical applications. We introduce ScopeJ, a statically-typed, multi-threaded, object calculus in which scopes are first class constructs. Scopes reify allocation contexts and provide a safe alternative to automatic memory management. Safety follows from the use of an ownership type system that enforces a topology on run-time patterns of references. ScopeJ’s type system is novel in that ownership annotations are implicit. This substantially reduces the burden for developers and increases the likelihood of adoption. The notion of implicit ownership is particularly appealing when combined with pluggable type systems, as one can apply different type constraints to different components of an application depending on the requirements without changing the source language. In related work we have demonstrated the usefulness of our approach in the context of highly-responsive systems and stream processing. [Copyright &y& Elsevier]
Datenbank: Academic Search Index
Beschreibung
Abstract:Abstract: The Real-time Specification for Java (RTSJ) introduced a range of language features for explicit memory management. While the RTSJ gives programmers fine control over memory use and allows linear allocation and constant-time deallocation, the RTSJ relies upon dynamic runtime checks for safety, making it unsuitable for safety critical applications. We introduce ScopeJ, a statically-typed, multi-threaded, object calculus in which scopes are first class constructs. Scopes reify allocation contexts and provide a safe alternative to automatic memory management. Safety follows from the use of an ownership type system that enforces a topology on run-time patterns of references. ScopeJ’s type system is novel in that ownership annotations are implicit. This substantially reduces the burden for developers and increases the likelihood of adoption. The notion of implicit ownership is particularly appealing when combined with pluggable type systems, as one can apply different type constraints to different components of an application depending on the requirements without changing the source language. In related work we have demonstrated the usefulness of our approach in the context of highly-responsive systems and stream processing. [Copyright &y& Elsevier]
ISSN:01676423
DOI:10.1016/j.scico.2008.04.001