Mos: A multicomputer distributed operating system

This paper describes the goals and the internal structure of MOS, a Multicomputer distributed Operating System. MOS is a general-purpose time-sharing operating system which makes a cluster of loosely connected independent homogeneous computers behave as a single-machine UNIX system. The main goals of the system include network transparency, decentralized control, site autonomy and dynamic process migration. The main objective in the design of the system was to reduce the complexity of the system, while maintaining good performance. The internal structure of the system can be characterized by modularity, a high degree of information hiding, hierarchical organization and remote procedure calls.     

A simple system for constructing distributed,mixed-language programs

The Mixed-Language Programming (MLP) System is a simple system that facilitates construction of sequential programs in which procedures can be written in different programming languages to exploit heterogeneity in language functionality. In addition, MLP provides a simple remote procedure call (RPC) facility that allows heterogeneity in machine functionality to be exploited. To minimize implementation cost, the system does not solve all of the problems related to mixed-language programming; rather, MLP is designed to handle common situations well. Among the unique aspects of MLP are its advanced facilities, which allow complex situations to be handled with user intervention; for example, these facilities allow arguments of a type not defined by a language to be used by procedures written in that language. This paper overviews the use of MLP and describes its implementation. In addition, two programs that have been written using the MLP system—a small database system and a collection of plot routines—are discussed. The system executes on a collection of Vaxes and Suns running Berkeley UNIX. Currently supported languages are C, Pascal and Icon.     

The peregrine high-performance RPC system

The Peregrine RPC system provides performance very close to the optimum allowed by the hardware limits, while still supporting the complete RPC model. Implemented on an Ethernet network of Sun-3/60 workstations, a null RPC between two user-level threads executing on separate machines requires 573μs. This time compares well with the fastest network RPC times reported in the literature, ranging from about 1100 to 2600 μs, and is only 309 μs above the measured hardware latency for transmitting the call and result packets in our environment. For large multi-packet RPC calls, the Peregrine user-level data transfer rate reaches 8.9 Mbit/s, approaching the Ethernet's 10 Mbit/s network transmission rate. Between two user-level threads on the same machine, a null RPC requires 149 μs. This paper identifies some of the key performance optimizations used in Peregrine, and quantitatively assesses their benefits.     

DEMOS/MP: The development of a distributed operating system

The DEMOS/MP operating system has moved from a supercomputer with a simple addressing structure to a network of microcomputers. This transformation was done without significant changes to the semantics of the original DEMOS, i.e. existing DEMOS programs should run on DEMOS/MP. The changes to DEMOS were simplified by the structure of its primitive objects and the functions over those objects. The structure of DEMOS links and processes were the major contributors to the simplicity. The changes made to produce DEMOS/MP involved the internal structure of link, modification to parts of the kernel, and limited changes to the various system processes.     

通用远程过程调用的设计与实现

在分布式计算系统中，远程过程调用ＲＰＣ是种流行的进程间通信机制。ＲＰＣ简单灵活，且功能较强。上前大多数ＲＰＣ机制是同步的，严重地影响了分布式应用的并行性。我们设计和实现了一个通用的ＲＰＣ。本文讨论了设计的要点和方法，并对通用ＲＰＣ的实现作了介绍。     

The Lynx distributed programming language: Motivation, design and experience

A programming language can provide much better support for interprocess communication than a library package can. Most message-passing languages limit this support to communication between the pieces of a single program, but this need not be the case. Lynx facilitates convenient, typesafe message passing not only within applications, but also between applications and among distributed collections of servers. Specifically, it addresses issues of compiler statelessness, late binding, and protection that allow run-time interaction between processes that were developed independently and that do not trust each other. Implementation experience with Lynx has yielded important insights into the relationship between distributed operating systems and language run-time support packages and into the inherent costs of high-level message-passing semantics.     

有关远程过程调用的几个重要问题的讨论

远程过程调用作为构造分布式系统的一个重要工具已经得到了广泛的应用,本文详细讨论了有关ＲＰＣ的七个重要问题：网络传输协议、类型一致性、错误处理、孤儿问题、效率问题、性能问题、互操作性。     

Remote rendezvous

BNR Pascal is a systems programming language intended for the implementation of the systems software of distributed computing systems. It supports the Ada Rendezvous model of tasking and communication, uniformly extended to support communications between tasks distributed over the computing nodes of a system. BNR Pascal was designed and implemented in 1980, and has since been used to implement the operating systems and real-time applications software for Northern Telecom's Meridian family of products. In total, more than 2 million lines of BNR Pascal exist. This paper describes the BNR Pascal remote rendezvous: the extension of rendezvous to interprocessor communication. It discusses the implementation of remote rendezvous, describing the advantages and disadvantages of several options. Finally, it details BNR's experience in using remote rendezvous in building substantial, practical distributed systems used in products.     

Dragonmail: An exercise in distributed computing

A conversation-based message system groups related messages into conversations and orders messages within conversations according to the context in which they were submitted. This paper describes the implementation of a comprehensive conversation-based message system, called Dragonmail, that extends an earlier prototype in two ways. First, it integrates conversations with conventional memo-based mail in a way that preserves the semantics of the conversation abstraction. Secondly, it provides for the distribution of software components across multiple hosts to support remote interfaces.     

Modules,objects and distributed programming: Issues in RPC and remote object invocation

Distributed programming can be greatly simplified by language support for distributed communication, such as that provided by remote procedure call (RPC) or remote object invocation. This paper examines design and implementation issues in these systems, and focuses on the influence of the communication system on a distributed program. To make the discussion concrete, we introduce a single application as implemented in two environments: Modula-2+, an extension of Modula-2 with RPC, and Emerald, an object-based language that supports remote object invocation. We show that small differences in the implementation of the communication system can have a significant impact on how distributed applications are structured.     

Layered distributed operating system

The improved efficiency of microelectronics and the development of digital transmission systems have allowed experimentation with distributed computing architectures. The requirements of a distributed operating system are outlined, and the principles and architecture used in the system are explained. A method is described of managing the system directories, and an analysis is given of the results obtained.     

Unix环境下基于RMI的分布式计算研究与实践

在分析远程过程调用（RPC）原理的基础上,引入Java远程方法调用（RMI）的概念,并详细讨论了Java RMI的体系结构和运作机制。还给出了一个Unix环境下的分布计算示例。     

An implementation of distributed shared memory

Shared memory is a simple yet powerful paradigm for structuring systems. Recently, there has been an interest in extending this paradigm to non-shared memory architectures as well. For example, the virtual address spaces for all objects in a distributed object-based system could be viewed as constituting a global distributed shared memory. We propose a set of primitives for managing distributed shared memory. We present an implementation of these primitives in the context of an object-based operating system as well as on top of Unix.     

基于群机系统的Ada编译程序

为了使Ａｄａ程序运行在松散耦合分布式系统并且降低程度员开发分布Ａｄａ的程序的工,设计并实现了基于该环境下的Ａｄａ编译程序。     

A class of high performance Maekawa-type algorithms for distributed systems under heavy demand

Summary Distributed Mutual Exclusion algorithms have been mainly compared using the number of messages exchanged per critical section execution. In such algorithms, no attention has been paid to the serialization order of the requests. Indeed, they adopt FCFS discipline. Conversely, the insertion of priority serialization disciplines, such as Short-Job-First, Head-Of-Line, Shortest-Remaining-Job-First etc., can be useful in many applications to optimize some performance indices. However, such priority disciplines are prone to starvation. The goal of this paper is to investigate and evaluate the impact of the insertion of a priority discipline in Maekawa-type algorithms. Priority serialization disciplines will be inserted by means of agated batch mechanism which avoids starvation. In a distributed algorithm, such a mechanism needs synchronizations among the processes. In order to highlight the usefulness of the priority based serialization discipline, we show how it can be used to improve theaverage response time compared to the FCFS discipline. The gated batch approach exhibits other advantages: algorithms are inherently deadlock-free and messages do not need to piggyback timestamps. We also show that, under heavy demand, algorithms using gated batch exchange less messages than Maekawa-type algorithms per critical section excution. Roberto Baldoni was born in Rome on February 1, 1965. He received the Laurea degree in electronic engineering in 1990 from the University of Rome La Sapienza and the Ph.D. degree in Computer Science from the University of Rome La Sapienza in 1994. Currently, he is a researcher in computer science at IRISA, Rennes (France). His research interests include operating systems, distributed algorithms, network protocols and real-time multimedia applications. Bruno Ciciani received the Laurea degree in electronic engineering in 1980 from the University of Rome La Sapienza. From 1983 to 1991 he has been a researcher at the University of Rome Tor Vergata. He is currently full professor in Computer Science at the University of Rome La Sapienza. His research activities include distributed computer systems, fault-tolerant computing, languages for parallel processing, and computer system performance and reliability evaluation. He has published in IEEE Trans. on Computers, IEEE Trans. on Knowledge and Data Engineering, IEEE Trans. on Software Engineering and IEEE Trans. on Reliability. He is the author of a book titled Manufactoring Yield Evaluation of VLSI/WSI Systems to be published by IEEE Computer Society Press.This research was supported in part by the Consiglio Nazionale delle Ricerche under grant 93.02294.CT12This author is also supported by a grant of the Human Capital and Mobility project of the European Community under contract No. 3702 CABERNET     

分布计算系统的进展与问题

本文简要叙述了分布计算系统的发展过程、现状和有待解决的问题。     

The design of an operating system for a scalable parallel computing engine

There are substantial benefits to be gained from building computing systems from a number of processors working in parallel. One of the frequently-stated advantages of parallel and distributed systems is that they may be scaled to the needs of the user. This paper discusses some of the problems associated with designing a general-purpose operating system for a scalable parallel computing engine and then describes the solutions adopted in our experimental parallel operating system. We explain why a parallel computing engine composed of a collection of processors communicating through point-to-point links provides a suitable vehicle in which to realize the advantages of scaling. We then introduce a parallel-processing abstraction which can be used as the basis of an operating system for such a computing engine. We consider how this abstraction can be implemented and retain the ability to scale. As a concrete example of the ideas presented here we describe our own experimental scalable parallel operating-system project, concentrating on the Wisdom nucleus and the Sage file system. Finally, after introducing related work, we describe some of the lessons learnt from our own project.