Results 1  10
of
21
Abstract Models of Memory Management
, 1995
"... Most specifications of garbage collectors concentrate on the lowlevel algorithmic details of how to find and preserve accessible objects. Often, they focus on bitlevel manipulations such as "scanning stack frames," "marking objects," "tagging data," etc. While these d ..."
Abstract

Cited by 92 (18 self)
 Add to MetaCart
(Show Context)
Most specifications of garbage collectors concentrate on the lowlevel algorithmic details of how to find and preserve accessible objects. Often, they focus on bitlevel manipulations such as "scanning stack frames," "marking objects," "tagging data," etc. While these details are important in some contexts, they often obscure the more fundamental aspects of memory management: what objects are garbage and why? We develop a series of calculi that are just lowlevel enough that we can express allocation and garbage collection, yet are sufficiently abstract that we may formally prove the correctness of various memory management strategies. By making the heap of a program syntactically apparent, we can specify memory actions as rewriting rules that allocate values on the heap and automatically dereference pointers to such objects when needed. This formulation permits the specification of garbage collection as a relation that removes portions of the heap without affecting the outcome of the evaluation. Our highlevel approach allows us to specify in a compact manner a wide variety of memory management techniques, including standard tracebased garbage collection (i.e., the family of copying and mark/sweep collection algorithms), generational collection, and typebased, tagfree collection. Furthermore, since the definition of garbage is based on the semantics of the underlying language instead of the conservative approximation of inaccessibility, we are able to specify and prove the idea that type inference can be used to collect some objects that are accessible but never used.
The Ins and Outs of Clean I/O
, 1995
"... Functional programming languages have banned assignment because of its undesirable properties. The reward of this rigorous decision is that functional programming languages are sideeffect free. There is another side to the coin: because assignment plays a crucial role in Input/Output (I/O), functio ..."
Abstract

Cited by 47 (7 self)
 Add to MetaCart
Functional programming languages have banned assignment because of its undesirable properties. The reward of this rigorous decision is that functional programming languages are sideeffect free. There is another side to the coin: because assignment plays a crucial role in Input/Output (I/O), functional languages have a hard time dealing with I/O. Functional programming languages have therefore often been stigmatised as inferior to imperative programming languages because they cannot deal with I/0 very well. In this paper we show that I/O can be incorporated in a functional programming language without loss of any of the generally accepted advantages of functional programming languages. This discussion is supported by an extensive account of the I/O system offered by the lazy, purely functional programming language Clean. Two aspects that are paramount in its I/O stem make the approach novel with respect to other approaches. These aspects are the technique of explicit multiple environment passing, and the Event I/O framework to program Graphical User I/O in a highly structured and highlevel way. Clean file I/O is as powerful and flexible as it is in common imperative languages (one can read, write, and seek directly in a file). Clean Event I/O provides programmers with a highlevel framework to specify complex Graphical User I/O. It has been used to write applications such as a windowbased text editor, an object based drawing program, a relational database, and a spreadsheet program. These graphical interactive programs are completely machine independent, but still obey the lookandfeel of the concrete window environment being used. The specifications are completely functional and make extensive use of uniqueness typing, higherorder functions, and algebraic data type...
On Regions and Linear Types
"... We explore how two different mechanisms for reasoning about state, linear typing and the type, region and effect discipline, complement one another in the design of a strongly typed functional programming language. The basis for our language is a simple lambda calculus containing firstclass regions ..."
Abstract

Cited by 44 (2 self)
 Add to MetaCart
We explore how two different mechanisms for reasoning about state, linear typing and the type, region and effect discipline, complement one another in the design of a strongly typed functional programming language. The basis for our language is a simple lambda calculus containing firstclass regions, which are explicitly passed as arguments to functions, returned as results and stored in userdefined data structures. In order to ensure appropriate memory safety properties, we draw upon the literature on linear type systems to help control access to and deallocation of regions. In fact, we use two different interpretations of linear types, one in which multipleuse values are freely copied and discarded and one in which multipleuse values are explicitly referencecounted, and show that both interpretations give rise to interesting invariants for manipulating regions. We also explore new programming paradigms that arise by mixing firstclass regions and conventional linear data stru...
Applications of Linear Logic to Computation: An Overview
, 1993
"... This paper is an overview of existing applications of Linear Logic (LL) to issues of computation. After a substantial introduction to LL, it discusses the implications of LL to functional programming, logic programming, concurrent and objectoriented programming and some other applications of LL, li ..."
Abstract

Cited by 42 (3 self)
 Add to MetaCart
This paper is an overview of existing applications of Linear Logic (LL) to issues of computation. After a substantial introduction to LL, it discusses the implications of LL to functional programming, logic programming, concurrent and objectoriented programming and some other applications of LL, like semantics of negation in LP, nonmonotonic issues in AI planning, etc. Although the overview covers pretty much the stateoftheart in this area, by necessity many of the works are only mentioned and referenced, but not discussed in any considerable detail. The paper does not presuppose any previous exposition to LL, and is addressed more to computer scientists (probably with a theoretical inclination) than to logicians. The paper contains over 140 references, of which some 80 are about applications of LL. 1 Linear Logic Linear Logic (LL) was introduced in 1987 by Girard [62]. From the very beginning it was recognized as relevant to issues of computation (especially concurrency and stat...
Semantics of memory management for polymorphic languages
 In 1st Workshop on Higher Order Operational Techniques in Semantics, A. Gordon and A. Pitts, Eds. Publications of the Newton Institute
, 1997
"... The views and conclusions contained in this document arethose of the authors and should not be interpreted as representing o cial policies, either expressed or implied, of the Advanced We present a static and dynamic semantics for an abstract machine that evaluates expressions of a polymorphic progr ..."
Abstract

Cited by 42 (8 self)
 Add to MetaCart
(Show Context)
The views and conclusions contained in this document arethose of the authors and should not be interpreted as representing o cial policies, either expressed or implied, of the Advanced We present a static and dynamic semantics for an abstract machine that evaluates expressions of a polymorphic programming language. Unlike traditional semantics, our abstract machine exposes many important issues of memory management, such as value sharing and control representation. We prove the soundness of the static semantics with respect to the dynamic semantics using traditional techniques. We then show how these same techniques may be used to establish the soundness of various memory management strategies, including typebased, tagfree garbage collection� tailcall elimination � and environment strengthening. Keywords: management Type theory and operational semantics are remarkably e ective tools for programming
Reference Counting as a Computational Interpretation of Linear Logic
 Journal of Functional Programming
, 1996
"... We develop formal methods for reasoning about memory usage at a level of abstraction suitable for establishing or refuting claims about the potential applications of linear logic for static analysis. In particular, we demonstrate a precise relationship between type correctness for a language based o ..."
Abstract

Cited by 35 (0 self)
 Add to MetaCart
(Show Context)
We develop formal methods for reasoning about memory usage at a level of abstraction suitable for establishing or refuting claims about the potential applications of linear logic for static analysis. In particular, we demonstrate a precise relationship between type correctness for a language based on linear logic and the correctness of a referencecounting interpretation of the primitives that the language draws from the rules for the `of course' operation. Our semantics is `lowlevel' enough to express sharing and copying while still being `highlevel ' enough to abstract away from details of memory layout. This enables the formulation and proof of a result describing the possible runtime reference counts of values of linear type. Contents 1 Introduction 1 2 Operational Semantics with Memory 4 3 A Programming Language Based on Linear Logic 9 4 Semantics 14 5 Properties of the Semantics 24 6 Linear Logic and Memory 27 7 Discussion 32 A Proofs of the Main Theorems 36 Acknowledgements...
Modal proofs as distributed programs (Extended Abstract)
 EUROPEAN SYMPOSIUM ON PROGRAMMING
, 2004
"... We develop a new foundation for distributed programming languages by defining an intuitionistic, modal logic and then interpreting the modal proofs as distributed programs. More specifically, the proof terms for the various modalities have computational interpretations as remote procedure calls, c ..."
Abstract

Cited by 28 (0 self)
 Add to MetaCart
(Show Context)
We develop a new foundation for distributed programming languages by defining an intuitionistic, modal logic and then interpreting the modal proofs as distributed programs. More specifically, the proof terms for the various modalities have computational interpretations as remote procedure calls, commands to broadcast computations to all nodes in the network, commands to use portable code, and finally, commands to invoke computational agents that can find their own way to safe places in the network where they can execute. We prove some simple metatheoretic results about our logic as well as a safety theorem that demonstrates that the deductive rules act as a sound type system for a distributed programming language.
Operational Interpretations of Linear Logic
, 1998
"... Two different operational interpretations of intuitionistic linear logic have been proposed in the literature. The simplest interpretation recomputes nonlinear values every time they are required. It has good memorymanagement properties, but is often dismissed as being too inefficient. Alternative ..."
Abstract

Cited by 27 (0 self)
 Add to MetaCart
Two different operational interpretations of intuitionistic linear logic have been proposed in the literature. The simplest interpretation recomputes nonlinear values every time they are required. It has good memorymanagement properties, but is often dismissed as being too inefficient. Alternatively, one can memoize the results of evaluating nonlinear values. This avoids any recomputation, but has weaker memorymanagement properties. Using a novel combination of typetheoretic and operational techniques we give a concise formal comparison of the two interpretations. Moreover, we show that there is a subset of linear logic where the two operational interpretations coincide. In this subset, which is sufficiently expressive to encode callbyvalue lambdacalculus, we can have the best of both worlds: a simple and efficient implementation, and good memorymanagement properties. Keywords: linear logic, operational semantics, callbyvalue lambda calculus, memory management. 1 Introductio...
A Type Theory for Memory Allocation and Data Layout (Extended Version)
 In Proceedings of the 30th ACM SIGPLANSIGACT Symposium on Principles of Programming Languages
, 2002
"... Ordered type theory is an extension of linear type theory in which variables in the context may be neither dropped nor reordered. This restriction gives rise to a natural notion of adjacency. We show that a language based on ordered types can use this property to give an exact account of the layout ..."
Abstract

Cited by 27 (3 self)
 Add to MetaCart
Ordered type theory is an extension of linear type theory in which variables in the context may be neither dropped nor reordered. This restriction gives rise to a natural notion of adjacency. We show that a language based on ordered types can use this property to give an exact account of the layout of data in memory. The fuse constructor from ordered logic describes adjacency of values in memory, and the mobility modal describes pointers into the heap. We choose a particular allocation model based on a common implementation scheme for copying garbage collection and show how this permits us to separate out the allocation and initialization of memory locations in such a way as to account for optimizations such as the coalescing of multiple calls to the allocator.
Modal proofs as distributed programs
 13th European Symposium on Programming
, 2003
"... We develop a new foundation for distributed programming languages by defining an intuitionistic, modal logic and then interpreting the modal proofs as distributed programs. More specifically, the proof terms for the various modalities have computational interpretations as remote procedure calls, com ..."
Abstract

Cited by 20 (1 self)
 Add to MetaCart
(Show Context)
We develop a new foundation for distributed programming languages by defining an intuitionistic, modal logic and then interpreting the modal proofs as distributed programs. More specifically, the proof terms for the various modalities have computational interpretations as remote procedure calls, commands to broadcast computations to all nodes in the network, commands to use portable code, and finally, commands to invoke computational agents that can find their own way to safe places in the network where they can execute. We prove some simple metatheoretic results about our logic as well as a safety theorem that demonstrates that the deductive rules act as a sound type system for a distributed programming language. 1