Experience with processes and monitors in Mesa

  title={Experience with processes and monitors in Mesa},
  author={Butler W. Lampson and David D. Redell},
  journal={Commun. ACM},
The use of monitors for describing concurrency has been much discussed in the literature. When monitors are used in real systems of any size, however, a number of problems arise which have not been adequately dealt with: the semantics of nested monitor calls; the various ways of defining the meaning of WAIT; priority scheduling; handling of timeouts, aborts and other exceptional conditions; interactions with process creation and destruction; monitoring large numbers of small objects. These… 

Figures from this paper

Experience and Evolution of ConcurrentSmalltalk

This paper re-examined issues related to concurrency control and the behavior of a block context, and the evolution of the solutions for overcoming these shortcomings is described along with the model of computation in ConcurrentSmalltalk.

Monitor classification

A taxonomy of monitors is presented that encompasses all the extant monitors and suggests others not found in the literature or in existing programming languages.

Run-time fault detection in monitor based concurrent programming

An extension to the monitor construct for detecting run-time errors in monitor operations, developed in Java with a prototypical implementation of the proposed monitor construct with run- time fault detection mechanisms.

Message passing between sequential processes: The reply primitive and the administrator concept

Paradigms are presented for process structuring found to be commonly useful for message passing and the rationale behind certain choices are given.

Specification and implementation of resilient, atomic data types

This work defines what it means for abstract data types to be atomic and resilient, and discusses issues that arise in implementing such types, and describes a particular linguistic mechanism provided in the Argus programming language.

Intervention Schedules for Real-Time Programming

  • C. Abbott
  • Computer Science
    IEEE Transactions on Software Engineering
  • 1984
A way of programming real-time systems is described which inverts the usual image of parallel processes: instead of processes which are ordinarily running and which wait occasionally in order to

Preserving Abstraction in Concurrent Programming

It is argued that the best compromise between these goals is a combination of a fine-grain locking mechanism together with a method for explicitly defining concurrency properties for selected interfaces.

Concepts and Notations for Concurrent Programming

This paper identifies the major concepts and describes some of the more important language notations for writing concurrent programs and three general classes of concurrent programming languages are identified and compared.

Correctness Criteria and Concurrency Control for Real-Time Systems: A Survey

An array of correctness criteria and concurrency control techniques with regard to their applicability in soft, rm, and hard-deadline RTS are surveyed.

Communicating memory transactions

A programming model is presented that is the first to have opaque transactions, safe asynchronous message passing, and an efficient implementation and a novel definition of safe message passing that may be of independent interest.



Signaling in monitors

It is shown that all of the conventions are equivalent except for immediate return, which is strictly weaker than the others, and a modification of immediate return which corrects its weakness and retains its desirable features is proposed.

An implementation of monitors

An implementation of monitors in BCPL is described and it is shown how the scope rules of BCPL can be used to provide most of the requisite compile time checking.

On structuring operating systems with monitors

Whether Hoare's monitor proposal for structuring operating systems could usefully be applied in the design of substantial operating systems for medium or large computers is considered.

On the transfer of control between contexts

We describe a single primitive mechanism for transferring control from one module to another, and show how this mechanism, together with suitable facilities for record handling and storage

Monitors: an operating system structuring concept

This paper develops Brinch-Hansen's concept of a monitor as a method of structuring an operating system. It introduces a form of synchronization, describes a possible method of implementation in

MODULA: a language for modular multiprogramming

Modula is a language intended primarily for programming dedicated computer systems, including process control systems on smaller machines, which is largely based on Pascal, but in addition to conventional block structure it introduces a so‐called module structure.

The programming language Concurrent Pascal

  • P. B. Hansen
  • Computer Science
    IEEE Transactions on Software Engineering
  • 1975
The main contribution of Concurrent Pascal is to extend the monitor concept with an explicit hierarchy of access rights to shared data structures that can be stated in the program text and checked by a compiler.

On the duality of operating system structures

It is demonstrated that these two categories are duals of each other and that a system which is constructed according to one model has a direct counterpart in the other, and the principal conclusion is that neither model is inherently preferable.

A structured specification of a hierarchical operating system

This paper applies the concepts of hierarchical levels of abstraction and structured programming to the design of a large program system. An operating system for a multi-processor installation is

Communicating sequential processes

This paper suggests that input and output are basic primitives of programming and that parallel composition of communicating sequential processes is a fundamental program structuring method. When