SR is a language for programming distributed systems ranging from operating systems to application programs. On the basis of our experience with the initial version, the language has evolved considerably. In this paper we describe the current version of SR and give an overview of its implementation. The main language constructs are still resources and operations. Resources encapsulate processes and variables that they share; operations provide the primary mechanism for process interaction. One way in which SR has changed is that both resources and processes are now created dynamically. Another change is that inheritance is supported. A third change is that the mechanisms for operation invocation-call and send-and operation implementation-proc and in-have been extended and integrated. Consequently, all of local and remote procedure call, rendezvous, dynamic process creation, asynchronous message passing, multicast, and semaphores are supported. We have found this flexibility to be very useful for distributed programming. Moreover, by basing SR on a small number of well-integrated concepts, the language has proved easy to learn and use, and it has a reasonably efficient implementation.

One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for systems with shared memory, is the monitor . Over the past twenty years many kinds of monitors have been proposed and implemented, and many modern programming languages provide some form of monitor for concurrency control. This paper presents a taxonomy of monitors that encompasses all the extant monitors and suggests others not found in the literature or in existing programming languages. It discusses the semantics and performance of the various kinds of monitors suggested by the taxonomy, and it discusses programming techniques suitable to each.

An important problem in analyzing distributed computations is the amount of information. In event-based models, even for simple applications, the n umber of events is large and t he c a usal structure is complex. Event a bstraction can be used to r e d uce the a p parent complexity o f a distributed computation.This paper discusses one important aspect of event a bstraction: causality among a bstract events. Following Lamport 24 , two c a usality relations are de ned on abstract events, called weak and strong precedence. A general theoretical framework based on logical vector time is developed in which s e v eral meaningful timestamps for abstract events are derived. These timestamps can be used to e ciently determine c a usal relationships between arbitrary abstract events. The class of convex abstract events i s i d enti ed as a subclass of abstract events t hat i s general enough to be widely applicable and restricted enough to simplify timestamping s c hemes used for characterizing w eak precedence. We explain why s u ch a simpli cation seems not possible for strong precedence.

No abstract