Chris Maeda

Protocol service decomposition for high-performance networking

In this paper we describe a new approach to implementing network protocols that enables them to have high performance and high flexibility, while retaining complete conformity to existing application programming interfaces. The key insight behind our work is that an applications interface to the network is distinct and separable from its interface to the operating system. We have separated these interfaces for two protocol implementations, TCP/IP and UDP/IP, running on the Mach 3.0 operating system and UNIX server. Specifically, library code in the applications address space implements the network protocols and transfers data to and from the network, while an operating system server manages the heavyweight abstractions that applications use when manipulating the network through operations other than send and receive. On DECstation 5000/200 systems connected by 10Mb/sec Ethernet, this approach to protocol decomposition achieves TCP/IP throughput of 1088 KB/second, which is comparable to that of a high-quality in-kernel TCP/IP implementation, and substantially better than a server-based one. Our approach achieves small-packet UDP/IP round trip latencies of 1.23 ms, again comparable to a kernel-based implementation and more than twice as fast as a server-based one.

SPIN —an extensible microkernel for application-specific operating system services

Application domains such as multimedia, databases, and parallel computing, require operating system services with high performance and high functionality. Existing operating systems provide fixed interfaces and implementations to system services and resources. This makes them inappropriate for applications whose resource demands and usage patterns are poorly matched by the services provided. The SPIN operating system enables system services to be defined in an application-specific fashion through an extensible microkernel. It offers applications fine-grained control over a machines logical and physical resources through run-time adaptation of the system to application requirements.

Open implementation design guidelines

Designing reusable software modules can be extremely difficult. The design must be balanced between being general enough to address the needs of a wide range of clients and being focused enough to truly satisfy the requirements of each specific client. One area where it can be particularly difficult to strike this balance is in the implementation strategy of the module. The problem is that general-purpose implementation strategies, tuned for a wide range of clients, aren’t necessarily optimal for each specific client— this is especially an issue for modules that are intended to be reusable and yet provide highperformance. An examination of existing software systems shows that an increasingly important technique for handling this problem is to design the module’s interface in such a way that the client can assist or participate in the selection of the module’s implementation strategy. We call this approach open implementation. When designing the interface to a module that allows its clients some control over its implementation strategy, it is important to retain, as much as possible, the advantages of traditional closed implementation modules. This paper explores issues in the design of interfaces to open implementation modules. We identify key design choices, and present guidelines for deciding which choices are likely to work best in particular situations.

SPIN: an extensible microkernel for application-specific operating system services

Application domains such as multimedia, databases, and parallel computing, require operating system services with high performance and high functionality. Existing operating systems provide fixed interfaces and implementations to system services and resources. This makes them inappropriate for applications whose resource demands and usage patterns are poorly matched by the services provided. The SPIN operating system enables system services to be defined in an application-specific fashion through an extensible microkernel. It offers applications fine-grained control over a machines logical and physical resources through run-time adaptation of the system to application requirements.

Open implementation analysis and design

This paper describes a methodology for designing Open Implementations -software modules that can adapt or change their internals to accommodate the needs of different clients. Analysis techniques are used for capturing domain knowledge, user requirements, and domain properties that influence the module’s eventual implementation. Design techniques are used for determining and refining the interfaces by which clients control the modules implementation strategies. The methodology has evolved over the past two years in several pilot projects.

The need for customizable operating systems

Although modern operating systems provide powerful abstractions to application programs, they often fail to implement those abstractions in a way that provides applications programs, especially specialized application programs, with the best utilization of the physical resources of the computer system. The operating system community has implicitly recognized this problem by providing mechanisms that give client programmers more access to the physical substrate. The Mach External Pager allows clients to replace the paging mechanism. More recent work allows client replacement of the paging policy as well. Scheduler activations share the job of thread management between clients and the system. Apertos allows these and other aspects of operating system implementation to be client-controlled. Object-oriented operating systems under development also provide these kinds of control. We contend that there is a very general issue here, which operating systems have been among the first kinds of software to have to face head-on: some implementation decisions are crucial strategy decisions whose resolution will invariably bias the performance of the resulting implementation. Explicitly recognizing this issue helps to make sense of current trends and suggests new directions to explore. We consider the implications of this issue for operating systems, providing a framework with which to analyze systems such as those mentioned above, and suggesting connections with similar problems in other domains.<<ETX>>

A Metaobject Protocol for Controlling File Cache Management

This paper presents the design of a metaobject protocol (MOP) for controlling file buffer caches in operating systems. The MOP exposes an abstraction of the file cache machinery that is an inherent part of every file system implementation, and thereby allows applications to control cache management decisions for the files that they use. Safety and protection are preserved by carefully designing the MOP so that the operating system retains control both over which applications may access data for each file, and how global resource allocation decisions are made.

Networking performance for microkernels

Performance measurements for network protocols in microkernel systems are typically two to five times slower than comparable macrokernel systems. It is shown that user-level network protocols have performed poorly because they rely on code designed to run in a kernel environment. As a result, they make assumptions about the costs of primitive protocol operations such as scheduling, preemption, and data transfer which can require substantial overhead to satisfy at user level. Good user-level protocol performance can be achieved by restructuring protocol servers to take advantage of microkernel facilities, rather than ignore them.<<ETX>>

Report from the joint SIGGRAPH/SIGCOMM workshop on graphics and networking

1. I n t r o d u c t i o n On January 16-18, 1991, SIGGRAPH and SIGCOMM held a joint workshop in Boulder, CO, on the interaction between computer graphics and computer networking. The purpose of the workshop was to bring together experts in the fields of graphics and networking to promote the study of the ways in which distributed, graphics-based applications interact with network services. The workshop was organized as a result of discussions between Vint Cerf, chair of SICGCOMM, Jim Thomas, chair of SIGGRAPH, and Craig Partridge, also of SIGCOMM, who explored the need for dialogue between those working in computer graphics and networks. As a result of these discussions, Partridge and Thomas laid the groundwork for the workshop and asked Bob Haber of SIGGRAPH and Ralph Droms of SIGCOMM to act as co-chairs. The National Center for Atmospheric Research (NCAR) graciously, offered the use of their facilities for the workshop, and the workshop was held at NCAR in Boulder. The workshop included 32 participants from both the United Kingdom and the United States, representing a full spectrum of academic, research, government and commercial organizations.

Service without servers [operating system architecture]

We propose a new style of operating system architecture appropriate for microkernel-based operating systems: services are implemented as a combination of shared libraries and dedicated server processes. Shared libraries implement performance critical portions of each system service, while dedicated servers implement the parts of each service that do not require high performance or that are difficult to implement in an application. Dedicated servers might be used, for example, to manage shared state that must persist across process lifetimes or to implement high-level abstractions that are difficult or impossible to provide in a library. Our initial experiments show that this approach to operating system structure can yield performance that is comparable to monolithic kernel systems while retaining all the modularity advantages that led industry to adopt microkernel technology in the first place. Since services reside in libraries, an application is free to use the library that is most appropriate. This approach can even yield better performance than monolithic kernel systems by allowing the shared libraries to be closely coupled with the applications, thereby exploiting application-specific knowledge in policy decisions.<<ETX>>