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

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.
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.
Extension of Pascal by coroutines and its application to quasi‐parallel programming and simulation
TLDR
An extension of Pascal by coroutines as a basic tool to make quasi‐parallel programming possible by predefined procedures by semantical means without modification of the syntax of the language.
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.
A simple nucleus written in modula‐2: A case study
  • J. Hoppe
  • Computer Science
    Softw. Pract. Exp.
  • 1980
TLDR
It is concluded that programming of a nucleus in an appropriate high‐level language is simpler than in an assembly language.
...
...