A modula‐2 kernel for supporting monitors

@article{Terry1986AMK,
  title={A modula‐2 kernel for supporting monitors},
  author={Patrick D. Terry},
  journal={Software: Practice and Experience},
  year={1986},
  volume={16}
}
  • P. Terry
  • Published 1 May 1986
  • Computer Science
  • Software: Practice and Experience
The concept of the monitor as a device for handling the problems of mutual exclusion and synchronization in a set of concurrent processes is now well understood. In addition to being of considerable theoretical interest, the monitor concept has been found suitable for the design of several practical operating systems. This paper discusses an implementation of monitors using a kernel written in Modula‐2. 
6 Citations
Process scheduling in Modula-2
TLDR
Hemmendinger contends that these schedulers are inherently unfair in their distribution of processor time, and that it is possible that ready-to-run processes can be prevented from executing.
Signalling regions: Multiprocessing in a shared memory reconsidered
TLDR
This paper will re‐examine the monitor concept in its original context and proposes a language structure called a signalling region that together with the notion of encapsulation by modules solves the immediate resumption problem and avoids the nested monitor problem.
A robust monitor construct with runtime fault detection
TLDR
An extension to the monitor construct for detecting runtime errors in monitor operations is proposed and a prototypical implementation of the proposed monitor construct with runtime fault detection mechanisms has been developed in Java.
Unfair process scheduling in Modula-2
TLDR
The unfairness of this process scheduler is surprising, in view of Wirth's statement that the scheduler "must embody a process administration that distributes the processor's time in a fair strategy among the processes".
Run-time fault detection in monitor based concurrent programming
TLDR
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.

References

SHOWING 1-10 OF 15 REFERENCES
An implementation of monitors
TLDR
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.
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-2 and the monitor concept
TLDR
The monitor concept [Hoa74] is one approach towards ensuring a reliable concurrent programming environment that encapsulates the shared data area and the procedures that will act on this data.
On the design of monitors with priority conditions
TLDR
This paper investigates the implementation of priority conditions for monitors under UCSD Pascal and proposes two such status queries which are both useful and efficient and it is shown that the Implementation of Hoare's "alarmclock" monitor is made simpler and more efficient through the use of these queries.
Modula-2 process facilities
TLDR
The features offered by Modula-2 (Wirth, 1979) are explored, in terms of which quasi-concurrency may be implemented at the user's fancy, using routines in a "module", which then become part of a library.
Implementing data abstractions and monitors in UCSD Pascal
TLDR
This paper discusses practical techniques for realizing these programming constructs in the UCSD dialect of Pascal in order to implement both data abstractions and monitors.
Concepts and Notations for Concurrent Programming
TLDR
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.
Pascal‐plus—another language for modular multiprogramming
TLDR
Pascal‐Plus is an extended version of Pascal, incorporating the envelope construct which is an aid to program modularization and data abstraction, the process, monitor and condition constructs, and a simulation monitor which provides pseudo‐time control facilities for multiprocessing programs.
The programming language Concurrent Pascal
  • P. B. Hansen
  • Computer Science
    IEEE Transactions on Software Engineering
  • 1975
TLDR
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.
The problem of nested monitor calls
TLDR
This article describes the problem of implementation of moni to r -based systems and discusses some (inadequate) solutions; its aim is to solicit better solutions from workers in the field.
...
...