A semantic model of reference counting and its abstraction (detailed summary)

@inproceedings{Hudak1986ASM,
  title={A semantic model of reference counting and its abstraction (detailed summary)},
  author={Paul Hudak},
  booktitle={LFP '86},
  year={1986}
}
  • P. Hudak
  • Published in LFP '86 8 August 1986
  • Computer Science
Most interpreters for functional languages (as well as Lisp) employ at some level in the implementation a notion of sharing, whether manifested indirectly through an environment or directly via pointers. Sharing is essential to an efficient implementation, saving time by not recomputing values, and saving space by having only one copy of each value. From the perspective of lambda calculus, sharing arises whenever a beta-reduction results in substitution for more than one occurrence of a… 

Implementation of the typed call-by-value λ-calculus using a stack of regions

The translation is proved correct with respect to a store semantics, which models as a region-based run-time system for polymorphically typed call-by-value λ-calculus.

Semantic models and abstract interpretation techniques for inductive data structures and pointers

This tutorial examines existing mathematical models and static analysis algorithms as well as their relations and distinguishes two classes ofsemantic models of languages with imperative data structures: store-based and storeless models.

Semantics of memory management for polymorphic languages

This work proves the soundness of the static semantics with respect to the dynamic semantics and shows how these same techniques may be used to establish thesoundness of various memory management strategies, including type-based, tag-free garbage collection; tailcall elimination; and environment strengthening.

Linearity and Laziness

Wadler's proposal involves the use of a type system based on the linear logic of Girard that allows the programmer to specify the “natural” imperative operations without at the same time sacrificing the crucial property of referential transparency.

M-Structures: Extending a Parallel, Non-strict, Functional Language with State

A solution is to introduce assignments, as in ML and Scheme; however, for meaningful semantics, they resort to strict, sequential evaluation.

A storeless model of aliasing and its abstractions using finite representations of right-regular equivalence relations

  • A. Deutsch
  • Computer Science
    Proceedings of the 1992 International Conference on Computer Languages
  • 1992
The author starts from a novel semantic model of data aliasing, then elaborates new results in formal language theory in order to represent its invariants, and finally uses these results to derive an efficient and online algorithm for statically determining dynamic aliasing properties of structured data.

A Formal Semantics for Finalizers

An operational approach is used to develop a new abstract model that explicitly represents memory management actions in a garbage-collected programming language based on the λ-calculus, and employs the model to describe and explore a semantics for finalizers.

Polymorphic type, region and effect inference

A new static system which reconstructs the types, regions and effects of expressions in an implicitly typed functional language that supports imperative operations on reference values, and proves the correctness of the reconstruction algorithm with respect to the static semantics.

How to make destructive updates less destructive

A static criterion based on abstract interpretation which checks that any side-effect which a function may exert via a destructive update remains invisible remains invisible is developed.

Code Generation Using a Formal Model of Reference Counting

The main motivation for the model of reference counting is in soundly translating programs from a high-level functional language to efficient code with a compact footprint in a small subset of a low-level imperative language like C.
...

References

SHOWING 1-10 OF 13 REFERENCES

Detecting global variables in denotational specifications

The criteria and transformation are useful for transforming denotational definitions into compilers and interpreters for imperative machines, for optimizing applicative programs, and for judging the suitability of semantic notations for describing imperative languages.

Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory

Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints

A program denotes computations in some universe of objects. Abstract interpretation of programs consists in using that denotation to describe computations in another universe of abstract objects, so

The global storage needs of a subcomputation

This paper partitions attributes into classes, the problem being to determine if there exists an evaluation order that allows each class to share a global storage area, and extends to handle symbol tables for block structured languages.

The aggregate update problem in functional programming systems

Both static and dynamic techniques for avoiding copying in aggregates are presented, and it is argued that they allow one to program functionally using aggregates, without loss of efficiency over conventional programs.

Shifting garbage collection overhead to compile time

This paper discusses techniques which enable automatic storage reclamation overhead to be partially shifted to compile time. The paper assumes a transaction oriented collection scheme, as proposed by

A flexible approach to interprocedural data flow analysis and programs with recursive data structures

A new approach to data flow analysis of procedural programs and programs with recursive data structures is described. The method depends on simulation of the interpreter for the subject programming

An empirical study of list structure in Lisp

Pointers to atoms are found to obey, roughly, Zipf's law, which governs word frequencies in natural languages; pointers to lists usually point to a location physically nearby in memory.

Abstract interpretation and optimising transformations for applicative programs