Imperative Computation Research Articles

SC-Haskell

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).

Just do it

One of the appeals of pure functional programming is that it is so amenable to equational reasoning. One of the problems of pure functional programming is that it rules out computational effects. Moggi and Wadler showed how to get round this problem by using monads to encapsulate the effects, leading in essence to a phase distinction - a pure functional evaluation yielding an impure imperative computation. Still, it has not been clear how to reconcile that phase distinction with the continuing appeal of functional programming; does the impure imperative part become inaccessible to equational reasoning? We think not; and to back that up, we present a simple axiomatic approach to reasoning about programs with computational effects.

Imperative abstractions for functional actions

We elaborate our relational model of non-strict, imperative computations. The theory is extended to support infinite data structures. To facilitate their use in programs, we extend the programming language by concepts such as procedures, parameters, partial application, algebraic data types, pattern matching and list comprehensions. For each concept, we provide a relational semantics. Abstraction is further improved by programming patterns such as fold, unfold and divide-and-conquer. To support program reasoning, we prove laws such as fold–map fusion, otherwise known from functional programming languages. We give examples to show the use of our concepts in programs.

A Graph Model for Imperative Computation

Scott's graph model is a lambda-algebra based on the observation that continuous endofunctions on the lattice of sets of natural numbers can be represented via their graphs. A graph is a relation mapping finite sets of input values to output values. We consider a similar model based on relations whose input values are finite sequences rather than sets. This alteration means that we are taking into account the order in which observations are made. This new notion of graph gives rise to a model of affine lambda-calculus that admits an interpretation of imperative constructs including variable assignment, dereferencing and allocation. Extending this untyped model, we construct a category that provides a model of typed higher-order imperative computation with an affine type system. An appropriate language of this kind is Reynolds's Syntactic Control of Interference. Our model turns out to be fully abstract for this language. At a concrete level, it is the same as Reddy's object spaces model, which was the first "state-free" model of a higher-order imperative programming language and an important precursor of games models. The graph model can therefore be seen as a universal domain for Reddy's model.

Preface: Volume 69

This volume contains the proceedings of the 9th Conference on Category Theory and Computer Science (CTCS'02), which was held at the University of Ottawa from August 15-17, 2002. The purpose of this conference series is the advancement of the foundations of computing using the tools of category theory. Indeed, category theory provides one of the key tools in the analysis of the interaction between logic and the theory of computation. The extent to which category theory has influenced these areas can be seen from the following list of topics, which are typical of the interests of this conference: • coalgebras and computing • concurrent and distributed systems • constructive mathematics • declarative programming and term rewriting • domain theory and topology • foundations of computer security • linear logic • modal and temporal logics • models of computation • program logics, data refinement, and specification • programming language semantics • type theory The list is by no means exhaustive. The vitality of the field is well displayed by the extremely high quality and the diversity of the 18 papers in this volume. For the first time in the history of CTCS, this year's conference was preceded by a “Graduate Student Preconference”, which took place from August 12-14 and which offered introductory courses in areas of importance to the conference. The response to this preconference was extraordinary, with more than 50 students and interested others taking part. This certainly suggests that the field of research of this conference will be strong and active for many years to come. The preconference offered courses in: • Introductory category theory (Susan Niefield) • Categorical logic (Philip Scott) • Concurrency theory (Peter Selinger) • Coalgebraic methods (Jiri Adamek) • Game theory (Robin Cockett) • Linear logic (Rick Blute) To hold this preconference, we received substantial funding from the Centre de Recherches Mathematiques (CRM). We thank them and Jacques Hurtubise, the Director of CRM, for their kind support. Without the help of many individuals in many different capacities, this conference would not have been possible. The editors would especially like to thank the following people: • The organizing committee: ◦ E. Moggi, Chair, (Genova) ◦ S. Abramsky (Oxford) ◦ P. Dybjer (Chalmers) ◦ B. Jay (Sydney) ◦ A. Pitts (Cambridge) • Local organizers: ◦ Rick Blute ◦ Philip Scott • The programme committee: ◦ Rick Blute, Chair (Ottawa) ◦ Robin Cockett (Calgary) ◦ Thierry Coquand (Chalmers) ◦ Andrea Corradini (Pisa) ◦ Thomas Ehrhard (Luminy) ◦ Ryu Hasegawa (Tokyo) ◦ Martin Hofmann (Munich) ◦ Bart Jacobs (Nijmegen) ◦ Michael Johnson (Macquarie) ◦ Dusko Pavlovic (Kestrel Institute) ◦ Alex Simpson (Edinburgh) • Lecturers in the student preconference: ◦ Susan Niefield (Union) ◦ Philip Scott (Ottawa) ◦ Robin Cockett (Calgary) ◦ Rick Blute (Ottawa) ◦ Jiri Adamek (Braunschweig) ◦ Peter Selinger (Ottawa)

Relating operational and denotational semantics for input/output effects

We study the longstanding problem of semantics for input/output (I/O) expressed using side-effects. Our vehicle is a small higher-order imperative language, with operations for interactive character I/O and based on ML syntax. Unlike previous theories, we present both operational and denotational semantics for I/O effects. We use a novel labelled transition system that uniformly expresses both applicative and imperative computation. We make a standard definition of bisimilarity and prove bisimilarity is a congruence using Howe's method.Next, we define a metalanguage [Mscr ] in which we may give a denotational semantics to [Oscr ]. [Mscr ] generalises Crole and Pitts' FIX-logic by adding in a parameterised recursive datatype, which is used to model I/O. [Mscr ] comes equipped both with an operational semantics and a domain-theoretic semantics in the category [Cscr ][Pscr ][Pscr ][Oscr ] of cppos (bottom-pointed posets with joins of ω-chains) and Scott continuous functions. We use the [Cscr ][Pscr ][Pscr ][Oscr ] semantics to prove that [Mscr ] is computationally adequate for the operational semantics using formal approximation relations. The existence of such relations is based on recent work of Pitts (Pitts 1994b) for untyped languages, and uses the idea of minimal invariant objects due to Freyd.A monadic-style textual translation into [Mscr ] induces a denotational semantics on [Oscr ]. Our final result validates the denotational semantics: if the denotations of two [Oscr ] programs are equal, then the [Oscr ] programs are in fact operationally equivalent.

Running programs backwards: The logical inversion of imperative computation

Abstract Imperative programs can be inverted directly from their forward-directed program code with the use of logical inference. The relational semantics of imperative computations treats programs as logical relations over the observable state of the environment, which is taken to be the state of the variables in memory. Program relations denote both forward and backward computations, and the direction of the computation depends upon the instantiation pattern of arguments in the relation. This view of inversion has practical applications when the relational semantics is treated as a logic program. Depending on the logic programming inference scheme used, execution of this relational program can compute the inverse of the imperative program. A number of nontrivial imperative computations can be inverted with minimal logic programming tools.

Imperative functional programming

Our intuitive idea of a function is that it describes the dependence of one quantity upon another. There is no condition on what kind of quantities are involved. They could be integers, Turing machines, binary search trees, window hierarchies, digital circuits or whatever. The possibilities are endless. The idea of functional programming is that functions are described applicatively, by plugging together other functions. This recursive dependence of functions on other functions bottoms out with the primitive operators. If the primitive operators are “effective,” i.e., they can be used to calculate, compute, construct or build one quantity from another, then all functions expressed applicatively are similarly effective. Imperative functional programming is the application of these ideas to imperative computations. Quantities here are imperative computations and functions denote dependences between imperative computations. Effectiveness of a function means that a computation produced from it can be effectively carried out whenever the input computations can be effectively carried out. It is often felt that imperative computations and functional programming are in conflict. Adding imperative computations to a functional programming language is found to destroy its “referential transparency.” See, for example, [Abelson et al., 1985, Sec. 3.1] for a discussion of the issue. However, in languages where such issues arise, imperative computations are thrown together by extending or modifying functional computation. The idea that functions denote dependences is lost in the process. In contrast, imperative functional programming does not involve altering functional computation in any way. It merely applies it to a new context, that of imperative compu-