The SR programming language supports a simple and elegant set of abstractions for its model of distributed computing. The model provides an effective framework for demonstrating to students the different styles of distributed programming. A small Java toolkit based on SR's model is presented in this paper. This toolkit allows instructors to use the popular Java language as a platform in parallel and distributed processing courses.

Synchronization of multiple threads in a Java program using the built-in features of the language has serious pitfalls for the programmer, particularly if a thread is interrupted while waiting inside a monitor. These concerns have lead to a movement to avoid Java monitors altogether and use message passing instead. This paper visits the field of concurrent programming to show that replacing all Java monitors with message passing is an overreaction to these problems.

No abstract available.

At first glance, Java monitors appear easy to use. However, a deeper analysis reveals that they are surprisingly tricky, suffer from subtle race conditions, and are actually a low-level synchronization tool in stark contrast to the reputation Java has as a modern well-engineered language. The programmer is responsible for building safe and robust synchronization structures from Java monitors.

i L L Is Java suitable for teaching concurrent programming?This paper describes the features Java has for this, how well they work, and what is missing.The author has written a library of classes, also described here, to provide the missing features.Supplemented with these classes, Java works well as the concurrent programming language in operating systems and related courses.

A hypermedia laboratory manual for operating systems and concurrent programming, based on the SR programming language, has been writtenand is available for use over the Internet.It is written in HTML and is accessible using Web browsers such as Mosaic and Netscape.Algorithm animations can be run by adding a new external viewer to the browser.Tbe Web helps solves the handout problem faced by many instructors.

In operating systems courses, students study the major algorithms used in operating systems to manage the various objects and resources in a computing system: processes, files, buffer space, processors, messages, main memory, semaphores, and disk storage. Various classical synchronization problems such as the dining philosophers, the readers and writers, and the producers and consumers with bounded buffer are also analyzed. Even though the computing systems being studied are getting more and more powerful, these algorithms and classical problems are usually analyzed using blackboard, chalk, pencil, and paper. This paper describes an X-windows based package called xtango that was used to animate some of the algorithms and classical problems studied in operating systems. One animation typical of those that have been developed is presented. Students can use these animations during study outside the classroom for a better understanding of the algorithms. Instructors can use the animations to facilitate the presentation of the algorithms in the classroom.

In undergraduate operating systems classes, students learn about concurrent process synchronization, including such things as shared data, race conditions, critical sections, mutual exclusion, semaphores, monitors, and the test-and-set hardware instruction. They also study interprocess communication, message passing, rendezvous, and remote procedure calls. Solutions to classical problems, such as the dining philosophers, producers and consumers, bounded buffers, and readers and writers, are presented using the above concepts. However, students need to write programs in a language that provides facilities for concurrent programming in order to appreciate fully the above concepts. This paper describes the SR language and discusses its successful use as an environment for concurrent programming in an undergraduate operating systems class.

Some of the problems that are expected to be encountered in managing virtual memory systems using the newer-technology secondary storage devices are address. The difficulties that two proposed policies have in choosing the most economical program localities of reference to assign to primary memory are analyzed. K. Koh's (1981) criterion for examining the cyclic locality interval (CLI) hierarchy of a program and choosing the least-cost pathway is examined. Koh's criterion is designed for the case of a CLI containing a single inner CLI. The decision to descend the hierarchy is based on the cycle time of the outer CLI. If the outer CLI has two or more inner CLIs, it is possible for Koh's criterion to indicate that it is more economical to descend to one of the inner CLIs without that actually being the case. Choosing which CLI to descend to requires knowledge of its duration, and this is not generally available to the memory management system. An attempt to use Koh's criterion with the loop structure of a program in order to reduce space-time execution cost was not successful.>

An evaluation is made of a way to reduce the cost of program restructuring by having a compiler determine the program's packing in virtual address space from an analysis of its source code. Two features of this method are the duplication of code modules in virtual address space and the inline substitution of the code for a called procedure. This compile-time restructuring algorithm is evaluated using the instruction-only address traces from a collection of programs. In a simulation of a virtual memory system using disks as secondary storage devices, the method is not successful, since it leads to a higher optimum space-time execution cost than that of the unrestructured program. The algorithm did reduce program space-time execution cost for some arbitrarily chosen memory allocations smaller than the optimum. This could be useful in a multiuser, multiprogrammed environment.>