2K : A

Fabio Kon

Re ective, Component-Based Operating System for Rapidly Changing Environments

Ashish Singhaiy Roy H. Campbell Dulcineia Carvalho Robert Moore Department of Computer Science University of Illinois at Urbana-Champaign Francisco Ballesteros Universidad Carlos III { Madrid
nemo@gsyc.inf.uc3m.es

{f-kon,singhai,roy,dcarvalh,rbmoore}@cs.uiuc.edu

Modern computing environments face both low-frequency infrastructural changes, such as software and hardware upgrades, and frequent changes, such as uctuations in the network bandwidth and CPU load. However, existing operating systems are not designed to cope with rapidly changing environments. They provide no mechanism to permit the insertion of self-adapting components that can optimize system performance according to diversity, software and hardware changes, and variations in the environment. They are not designed to accommodate dynamic updates of software, or to deal with component inter-dependence. This paper describes the philosophy behind 2K , a re ective, component-based operating system, and shows how it can be used to manage dynamism. In 2K , adaptation is driven by architectural awareness: the system software includes models of its own structure, state, and behavior. To implement adaptation, 2K incorporates a re ective middleware layer that admits on-the- y customization through dynamic loading of new components. Our research investigates the deployment, within this framework, of dynamic policies and mechanisms for security, mobility, load balancing, fault tolerance, and quality of service for multimedia and real-time applications.

Abstract

1 Introduction
This position paper reviews the design issues of communication middleware, modern distributed operating systems, and environments that are characterized by rapid changes. It proposes 2K , a component-based operating system that uses re ection to manage change. Modern computer systems must accommodate a highly dynamic environment. For example, the bandwidth available to a mobile computer changes by orders of magnitude as it moves from a wired network to a wireless LAN and further to a wireless WAN. The movement is also accompanied by changes in latency, error rates, connectivity, protocols, and cost.
y

Fabio Kon is supported in part by a grant from CAPES, the Brazilian Research Agency, proc.# 1405/95-2. Ashish Singhai is supported in part by the grant NSF CDA 94-01124.

The presence of such large dynamic variations implies that conventional system design { in which systems are optimized for one set of performance and application behavior parameters { will not be e ective for emerging computing environments. Instead, we argue that the variation in parameters requires accommodation through adaptation. Middleware and operating system must adapt to change as software and hardware evolve. We consider two types of change: 1. Variations in the environment: uctuations in the network bandwidth, latency, protocols, error rate, cost, connectivity, security levels, memory, CPU, and power availability. 2. Evolution of software and hardware including version updates and recon gurations. Our approach to handling these changes is to build a generic framework to support change management in a network-centric computing environment. This architectural framework combines recently developed techniques in middleware and operating systems to achieve its goal. The speci c techniques we use include distributed objects and re ective middleware SSC98b], architectural awareness SSC96b], customization LTC96], dynamic security CMQ+ 97] the study of optimization techniques SSC98a], and code and data mobility KZ97]. Our work complements these techniques by providing a re ective environment on which these technologies can be implemented, tested, and deployed.

1.1 Supporting Adaptation

In 2K , we build an integrated architecture for adaptability where change is the fundamental premise, and adaptability is the fundamental goal. The design of 2K addresses three important questions in the design of adaptive systems. 1. What to adapt? 2K focuses on two kinds of adaptation strategies. It adapts to frequently varying parameters such as network bandwidth, connectivity, memory availability, and usage patterns using dynamic recon guration of existing objects that constitute the framework. It adapts to slowly varying parameters such as software versions, communication protocols, and hardware components using dynamic code management. In both cases, re ection provides the means for isolating these ever-changing software components from more stable system and application components. 2. When to adapt? 2K addresses this question using architectural awareness, meaning rei cation of inter-component dependence and dynamic representation of system state. Components can access the system state to determine if they need to adapt. Alternatively, changes in the system state can trigger automatic adaptation. 3. How to adapt? A Re ective Object Request Broker (ORB) and mechanisms for code distribution support the adaptation process. In the re ective ORB SSC97], components encapsulate ORB mechanisms and policies for method invocation, marshaling, concurrency, and the like. Code update mechanisms allow the dynamic replacement of system and application components, providing access to new functionality. In this paper, we present an architectural framework to address change management and adaptation in modern computing environments. Adaptation to slowly varying parameters, such as software versions (see section 2), is addressed by network-centric components (section 2.1) which are distributed e ciently using results from the mobile agents and active networking research (section 2.2). 2

1.2 Contents

More rapidly varying parameters, such as network bandwidth, CPU load, and memory availability, require the second kind of adaptation (section 3). The need for adaptation is detected with the help of architectural awareness (section 3.1), which facilitates dynamic optimizations (section 3.2) and triggers recon guration of our re ective middleware (section 4). We demonstrate the applicability of our ideas using a large, real-life application example: a multimedia distribution system (section 5). The example identi es problems that are di cult to solve using traditional operating systems, and shows how they are easily addressed by the 2K architecture. Our research was motivated by observing the limitations in similar, existing systems and research projects (section 6). We present our conclusions in section 7.

2 Managing Hardware and Software Evolution

As discussed in the previous section, recognizing and adapting to changes is a fundamental objective of 2K . It requires seamless and e cient integration of emerging technologies. But, above all, the system needs to provide e cient administration of change. This includes version control, software maintenance and update. For example, video hardware compression should be replaceable with software compression when the former is not available. Or, as end-to-end circuit switched networks become common, currently deployed on-demand protocols should be replaceable with reservation-based protocols. New hardware and software solutions must coexist with their older counterparts. New security policies, authentication protocols, and encryption algorithms should be substitutable for existing ones. An adaptive system should support such replacement e ciently and easily without requiring major modi cations to a legacy operating system with accompanying recompilation, relinking and reboot. The basis for our architecture is an innovative service model in which the distributed system customizes itself in order to better ful ll user and application requirements. In this model, a \user" is no longer an entity that is local to one speci c machine { each user is a machine-independent entity that exists in the network and can transparently carry its pro le across di erent hardware and software platforms. The network-centric, re ective operating system manages and allocates the resources to support the user on the selected platforms. Software components are transmitted over the network to where they are needed. In the rest of this section, we describe the philosophy of network-centrism from the point of view of easing administration and resource management (section 2.1), and dynamic code distribution for software evolution (section 2.2). Traditional operating systems implementing machine-centric management of system resources are becoming inadequate to meet the demands of networked users and distributed applications. A typical Computer Science researcher, for example, is forced to manage many di erent accounts (and di erent user pro les) in a large number of computing environments including portable computers, UNIX and Windows workstations, parallel machines, supercomputers, etc. As a consequence of the rapid evolution of computing and networking, system administrators have to maintain di erent software versions, accounting policies, quotas, access rights, and usage statistics for each machine, network, and user. This leads to complicated administration which accounts for a very signi cant part of the cost of current computing systems. 3

2.1 Network-Centrism and Rei cation of Inter-Component Dependence

2K adopts a network-centric model in which all entities, users, software components, and devices exist in the network. Each entity has a network-wide identity, a network-wide pro le, and dependencies upon other network entities. When a particular service is con gured, the entities that constitute that service are assembled. In contrast to existing systems where a large number of non-utilized modules are carried along with the basic system installation, our philosophy is based upon a \what you need is what you get" (WYNIWYG) model. In other words, the system con gures itself automatically and loads the minimum set of components required for executing the user applications in the most e cient way. These components can be downloaded from the network and only a small subset of system services are needed to bootstrap a node, leading to the construction of \network-computers". In order to achieve that, 2K rei es inter-component dependence. System and application components contain an explicit representation of the requirements that must be ful lled before their execution. An internet browser, for example, could specify that it depends upon components implementing an X-Window system, a local le service, the TCP/IP protocol, and the Java virtual machine version 1.0.2 or later. 2K extends the models for representing dependencies among shared libraries in traditional systems. In Solaris Sun97], for example, the system keeps track of the dependencies among shared libraries that run within one process. 2K manages dependencies between arbitrary components executing in di erent processes, under di erent users, and even in di erent machines. Inter-component dependence characterizes exactly the requirements for a service. Thus, the system can download and execute only the minimal set of components that are required to provide the required services. Moreover, dependencies can be satis ed in alternate ways, leading the way to adaptation. This allows, for example, the con guration of a user desktop environment no matter where the user is and which computer he is using. The middleware can download only the software that is compatible with a given operating system version and that is optimized for it. In summary, a careful representation of the dependencies among network-centric components can (1) enormously facilitate system maintenance; (2) provide the basis for automated software updates, (3) enable the implementation of \users" as network-centric entities, and (4) support a WYNIWYG model in which minimal optimized con gurations are assembled.

2.2 Code Distribution

The di culty of evolving existing Internet networking technology and the recent popularity of mobile agent systems KZ97] has motivated a novel approach to network architecture called active networking TSS+ 97]. In an active network, new protocols and services can be injected into the network using smart packets to carry customized software components which are executed by network routers. This new networking technology increases the degree of sophistication of the network architecture, enabling fast deployment of new protocols and services. Several research groups are investigating the use of active networking, mobile agents, and push and pull technologies to improve performance, provide intelligent resource management, fault tolerance, and reduce bandwidth requirements on distributed and mobile environments. In particular, by transforming push and pull ZF97] into each other as needed, by utilizing combinations of multicast and unicast, and with the aid of mobile agents, we can optimize bandwidth utilization and response time of network-wide operations. Instead of working at the router level, 2K applies the active networking model to the middleware level, using mobile agents to distribute code. The re ective ORBs, described in section 4, are organized as a distribution network through which system administrators can send code 4

bytecode for interpretation by a virtual machine. They may also contain references to networkcentric components to be fetched from remote repositories. Upon receiving a capsule, a node processes its content and forwards it to the next node in the distribution network. Routing within the distribution network is based on system state and on data and code included in the capsules. When a client or server selects a new ORB component through the ORB re ective interface, the system checks whether there is an appropriate, local version of this component. If one is not available, it fetches its code from a remote repository and dynamically links it to the running ORB. Besides, clients may also request the installation of a new service by giving, to the ORB, a reference to a remote component. Using the same code retrieval mechanism, the re ective ORB will then fetch, dynamically link, and execute the code to provide the requested service. Should this new component depend upon other non-available components, the system automatically downloads them from remote repositories and makes sure they are installed. The combination of these mechanisms provides a exible infrastructure for automatic software updates. The rei cation of inter-component dependence lets the system automatically ful ll component requirements, manage multiple component versions, and perform garbage collection, deleting components that are not used anymore. By working on an environment that requires less manual administration, users and developers can concentrate on more important tasks and improve their productivity.

capsules. Capsules, may contain executable code in the form of dynamically loadable libraries or

3 Recognizing Environmental Changes

As we saw, 2K provides support for adaptation in the form of dynamic recon guration. But dynamic recon guration by itself is not enough, we also need to know when to recon gure. In this section, we describe the elements of 2K 's design that support adaptation by recognizing the need for recon guration. 2K uses architectural awareness to enable adaptation. Architectural awareness refers to rei cation of dynamic, inter-component dependence and rei cation of system state. This way, system components can reason about their interactions with other components and use this reasoning to make adaptation decisions. For example, a video transmission component can query the available network bandwidth and CPU load, and use an appropriate compression algorithm. It may transmit low-quality images to get higher compression ratio if the available bandwidth is low and/or use a computationally intensive algorithm if the CPU load is low.
2K extends our earlier research SSC96a, SSC96b] on architectural awareness. These works { which deal with design conformance testing and dynamic visualization { have shown the bene ts of providing, to a system, access to its own structure. In 2K , we use architectural awareness to detect changes in the system environment and to adapt the system in response to these changes. Besides, 2K rei es the structure of the system and changes in this structure trigger adaptation mechanisms. For example, addition of a new network controller will be re ected in the rei ed system structure. It may trigger the networking component to reevaluate its decisions, possibly leading to adaptation in other components, such as network bu er sizes and timeout parameters.

3.1 Architectural Awareness

Architectural awareness is demonstrated in the O ++ BKC97] object-oriented microkernel, which is one of the platforms on which we are implementing 2K . The dependence structure of O ++ components is rei ed as SystemStructure . One can reason about it using two interfaces implemented by each system component: Navigator and Inspector . For each component, the Navigator enables examination of its dependencies, and the Inspector enables examination of its attributes. We illustrate the use of these interfaces through the following example. Consider a memory bank, consisting of several physical page frames. One can use a network node's Navigator to locate the memory bank and its Navigator , which can be used subsequently to browse through individual page Navigator s. For each page, one can use the Inspector to query attributes like persistence, ownership, mean access time, and backing store. Using this information, one can implement various memory management algorithms. For more details, see BKC97]. A single navigation interface is being implemented across all layers of the 2K operating system. In the future, applications will be able to browse and inspect every single system component, from high-level, coarse-grain components like a le service, to low-level kernel objects like page frames. In section 5, we present a real-world application that bene ts signi cantly from architectural awareness. We now describe how the rei cation of the system structure enables optimizations. It has been suggested in the literature that system performance is an end-to-end property which cannot always be implemented in isolation SRC84]. In other words, besides optimized components, system performance also depends upon optimized interaction among components SSC98a]. The explicit representation of system structure allows reasoning about inter-component interactions and provides guidelines for optimizations. For example, rei ed object interactions (call chains) can help optimize data transfer and synchronization across objects. Architectural awareness will allow such reasoning to occur within the resource management algorithms concerning how an object is used by other objects. The concept of explicit system structure can be extended beyond the modules of a local system. We can also analyze interactions among systems (e.g., ORBs) across the Internet and optimize them. For example, consider a distributed system with a user, a le server, and a print server. To print a le, the user would fetch the le from the le server, and send it to the print server. However, if the ORBs that are providing access to the le and print servers can collaborate, then the les can be transfered directly to the print server without rst transferring them to the user's machine.

3.2 Dynamic Optimizations

4 Re ective Middleware
The architectural awareness features described in the previous section suggest opportunities for adaptation. However, the actual mechanism that permits adaptation in 2K is a re ective Object Request Broker. It admits dynamic changes to its behavior by allowing modi cation to basic object mechanisms with or without the knowledge of the application. Object mechanisms that are subject to re ection include object creation and destruction, method invocation, concurrency, request demultiplexing and dispatching, data marshaling, network transport protocol, inter-ORB protocol, object references, naming, etc. We have implemented a prototype re ective ORB SSC98b] and have extended it for real-time invocations 6

SSC97], fault-tolerance and replication, parallel computing, and to interoperate with Java RMI. The re ective ORB provides a natural mechanism for implementing a number of desirable features in a modern distributed operating system: invocation policies. Using these, we can balance the load of client requests in two ways. First, we can locate a server object at the least loaded machine when it is created. Second, we can direct a method invocation to the least loaded server object when multiple instances of the same server object are available. Fault Tolerance By enhancing a re ective ORB including support for group communication, one can implement fault tolerance by replicating a request and sending it to a group of replicated servers. This provides tolerance against network and server failures. Our preliminary results for fault tolerance using re ective ORBs are available in SSC97]. Mobile Computing A re ective ORB can support mobile computing by specializing method invocation. The specialized method invocation will include interaction with a location service for mobile hosts and will route the invocation to the target host. As a result, clients and servers will not be encumbered by details of mobility management, the interaction between the ORB and the mobile system will be transparent to clients. Security As part of our research on the Cherubim security framework CQ98, CMQ+97], we have developed an extension to the OMG IDL that enables the speci cation of dynamic security policies and mechanisms associated with CORBA-like objects. The framework provides hooks at strategic points of the interaction between clients and servers. Using the re ective interface, a large variety of authentication and encryption algorithms can be associated dynamically with those hooks in order to customize the client/server interaction with respect to security. Quality of Service for Continuous Media QoS for applications requires resource allocation and admission control NS95] according to application requirements. The re ective ORB will allow the object creation phase to perform these operations. For example, as part of setting up a video-on-demand session object, the ORB will check available resources for admission control. If the session is admitted, it will reserve network bandwidth and CPU time for it. QoS support must also include real-time scheduling and networking SSC97, MBW97]. These policies can be implemented in the method invocation and execution mechanisms and selected via re ection.

Load Balancing The re ective ORB allows application-speci c object creation and method

5 Application Example
In this section, we describe a multimedia distribution system and show how it would bene t from the dynamic management features of 2K . We have implemented this application on traditional systems and have encountered many problems due to system limitations. We present a number of improvements to the multimedia distribution system that 2K would enable.

In order to provide e cient multimedia distribution to millions of clients, we have developed a scalable distribution framework for real-time data KCT+ 98]. We achieve distribution using a network of Re ector s1 distributed across a wide-area network. Each Re ector works as a relay, receiving input data packets from a list of trusted sources and forwarding these packets to other re ectors or to end-user clients. The communication between them can use a variety of protocols depending upon the situation. An Administration Panel remotely monitors and con gures the Re ector s and a distributed database stores user information (name, e-mail, password, access rights, account balance), and broadcast information (textual description, data format, encoding algorithms, access control lists, costs, list of connected users). While developing this system on traditional operating systems, we faced many problems that the change management features of 2K could alleviate. Here, we describe some of these problems: For a particular world-wide broadcast KCT+ 98] lasting several months, we built a network of more than 30 Re ectors spread across ve continents. During this period, we developed new versions of the Re ector and the client visualization program. The task of periodically updating more than 30 sites with new executable code and content was tedious and error prone. Our initial implementation did not support authentication and security. We are currently incorporating secure authentication and data transmission using a secure socket layer (SSL). However, we are limited to using a xed security policy and a xed set of encryption algorithms. Decentralized administration for security is still an unsolved problem. We designed the system to serve video and audio to commodity personal computers and workstations and traditional operating systems. Therefore, the operating systems o ered no control over QoS. We had to simulate it by estimating the available bandwidth and limiting the number of clients per site.

5.1 System Overview

5.2 Experience on Traditional Operating Systems

5.3 Improvements Enabled by 2K

We notice that these problems can be solved using the 2K features as follows: The code distribution support in 2K (section 2.2) could automate the distribution of new versions to geographically distributed sites. The rei cation of inter-component dependence would enable the installation of minimal, optimized Re ectors . Instead of uploading fat Re ectors containing all possible components and selecting the proper versions manually, this kind of code management would be completely automated. To support security, we can use the Cherubim framework (see section 4). This would allow the adoption of situation-speci c policies and mechanisms for authentication and encryption. The application would select di erent security schemes through the ORB

1 The term Re ector comes from the distributed multimedia community. It is not related to the terminology of computational re ection.

re ective interface, adjusting security according to content and to the level of trust in the network connections. QoS provision o ered by the re ective middleware would provide a uniform way of transparently allocating system resources. The application could estimate network conditions (e.g., available bandwidth) using architectural awareness (section 3.1). Fault tolerance and adaptive load distribution { which are not supported in the current system { could be easily implemented by selecting appropriate ORB protocols. Using 2K 's re ection and rei cation, the multimedia system would also be able to perform other kinds of dynamic optimizations. For example, it could select or adapt decoding algorithms according to the available computational power, or adapt the frame rate for video TCC+ 96] and the sampling rate for audio according to the bandwidth utilization.

6 Related Work
Work related to 2K falls in two categories: (1) adaptive, customizable, and re ective systems; and (2) distributed operating systems and distributed object systems. Research has demonstrated that adapting an operating system to the behavior of an application can signi cantly enhance its performance And92, BSP+ 95]. The need for applicationspeci c customization is further demonstrated by research showing that it is unlikely that a xed set of general purpose mechanisms can provide the best performance for a wide range of applications And92]. Typically, commercially available operating systems and middleware o er only limited adaptability. Several customizable or recon gurable operating systems have been built. Choices CIMR93] allows building a new instance of the OS by specifying, at compile or link time, the mechanisms implementing system services. MicroChoices LTC96] can dynamically import a new module written in Java. The code is then run by a kernel resident Java interpreter. Similarly, SPIN BSP+ 95] can import Modula-3 modules compiled by a trusted compiler. Exokernel EK95, KEG+ 97] demonstrated that support for dynamic recon guration could be achieved by means of a minimal kernel multiplexing hardware resources and user-level libraries. Unfortunately, implementing a new module in any of these systems requires intimate knowledge of system internals and conventions. As a result, writing a system extension is extremely di cult. Operating systems such as Apertos Yok92], provide explicit low-level support for re ection and rei cation of system objects. Rather than concentrating on how to implement re ection, our goal is to further extend their research by focusing on what to do with a system that supports re ection. Various programming languages support re ection explicitly Coi96]. Iguana, for example, is an extension to C++ that rei es several features of this language, allowing dynamic modi cation of their implementations GC96]. One of 2K 's major goals is to provide interoperability among a large number of existing hardware platforms, operating systems, and programming languages. Therefore, we opted for providing re ective facilities via a library API, and not in the programming language level. Many groups have investigated the issues related to the distribution of system services. Spring Mea94] introduced the idea of using IDL descriptions for building distributed operating system services. WebOS VEY+ 97] provides a set of tools for building distributed services and 9

applications. Inferno DPP+ 96] extends the Plan9 operating system to provide a portable virtual machine that can run programs written in Limbo. While strong results have been achieved in both distribution and adaptation, we believe that an easily extensible and customizable adaptable distributed operating system that addresses the relation between adaptability and distribution has not yet been built. Most of the research e orts in these areas are con ned to a speci c computational environment and cannot be used in conjunction with existing systems. Legion GWea97] and Globe vSHT97] share similar goals as ours, in that they also support wide-area distributed objects and dynamic con gurability. However, 2K also focuses on easing system administration, providing QoS guarantees, and automated adaptation. Distributed object models such as CORBA, Java RMI, and DCOM aim at facilitating the development of distributed applications. However, they present serious limitations in exibility, adaptation, and support for application-speci c customizations. These limitations have also been identi ed by other research groups. TAO extends the CORBA model to support real-time applications Sch97]. Since TAO mainly targets static real-time applications (such as avionics), it does not provide dynamic run-time adaptability. Other extensions to the CORBA model include support for group communication MS97], fault-tolerance Maf95], and quality of service for objects ZBS97]. Our research seeks the creation of a generic, re ective framework for dynamic customization of distributed object services. This framework will provide the basis for combining all these isolated e orts into a single system.

7 Conclusions
We have proposed the 2K architectural framework for adaptability and have described how it can support adaptation in response to changes in a distributed system. We address these questions by combining techniques from recent research in distributed object systems, adaptable systems, and re ection. The rei cation of the system structure, or architectural awareness, provides the infrastructure for supporting adaptation. It helps de ning (1) when adaptation should be triggered, (2) what the alternative strategies are, and (3) which strategy would be the most desirable. Code distribution mechanisms use mobile agents to support automated distribution of software components. Dependencies among components are automatically managed by the system, easing system administration. A Re ective Object Request Broker forms the basis for building adaptable distributed services. By customizing the middleware implementation on-the- y, applications can select speci c policies for security, load balancing, fault tolerance, mobile computing, and quality of service. Our ongoing research aims at further extending the capabilities of the re ective ORB and improving its interoperability with other object models such as DCOM. Besides its implementation as middleware running on existing commercial operating systems, we intend to run 2K on O ++, our new architecturally-aware microkernel. In that way, we expect to provide support for high-performance distributed objects. Preliminary experiments with a prototyped re ective ORB and with a distributed multimedia application demonstrate that the 2K operating system will help achieving substantial gains in exibility, simplicity, and performance.

10

References
And92] BKC97] T. Anderson. The case for application-speci c operating systems. In Third Workshop on Workstation Operating Systems, April 1992. Francisco J. Ballesteros, Fabio Kon, and Roy H. Campbell. A Detailed Description of O ++, a Distributed Adaptable Microkernel. Technical Report UIUCDCS-R-972035, University of Illinois at Urabana-Champaign, August 1997. Also available at http://choices.cs.uiuc.edu/2k/off++. B. N. Bershad, S. Savage, P. Pardyak, E. G. Sirer, M. E. Fiuczynski, D. Becker, bers C.Cha, and S. Eggers. Extensibility, Safety and Performance in the SPIN Operating System. In Proceedings of the 15th Symposium on Operating System Principles, December 1995. Roy Campbell, Nayeem Islam, Peter Madany, and David Raila. Designing and Implementing Choices: an Object-Oriented System in C++. Communications of the ACM, September 1993. Roy H. Campbell, Dennis Mickunas, Tin Qian, Chuck Willis, and Zhaoyu Liu. Cherubim: A Mobile Agent Based Security Architecture. Project home page: http://choices.cs.uiuc.edu/Security/DARPA/, 1997. Pierre Cointe. Re ective languages and metalevel architectures. ACM Computing Surveys, 28(4es):151, December 1996. Roy Campbell and Tin Qian. Dynamic agent-based security architecture for mobile computers. Submitted to IEEE Internet Computing Magzine, 1998. Sean Dorward, Rob Pike, Dave Presotto, Howard Trickey, and Phil Winterbottom. Inferno: La commedia Interattiva. In Proceedings of the OSDI'96 (WIP). USENIX, 1996. Dawson Engler and Frans Kaashoek. Exterminate All Operating System Abstractions. In Fifth Workshop on Hot Topics in Operating Systems, Orcas Island, WA, May 1995. IEEE Computer Society. Brendan Gowing and Vinny Cahill. Meta-object protocols for C++: The iguana approach. In Proceedings of Re ection '96, pages 137{152, San Francisco, USA, April 1996. Andrew S. Grimshaw, Wm. A. Wulf, and et al. The Legion Vision of a Worldwide Virtual Computer. Communications of the ACM, 40(1), January 1997. Fabio Kon, Roy H. Campbell, See-Mong Tan, Miguel Valdez, Zhigang Chen, and Jim Wong. A Component-Based Architecture for Scalable Distributed Multimedia. In Proceedings of the 14th International Conference on Advanced Science and Technology (ICAST'98), pages 121{135, Lucent Technologies, Naperville, April 1998. M. Frans Kaashoek, Dawson R. Engler, Gregory R. Ganger, Hector Brice~o, Russell n Hunt, David Mazieres, Tom Pinckney, Robert Grimm, John Janotti, and Kenneth 11

BSP+ 95]

CIMR93] CMQ+ 97] Coi96] CQ98] DPP+ 96] EK95] GC96] GWea97] KCT+ 98]

KEG+ 97]

Mackenzie. Application Performance and Flexibility on Exokernel Systems. In Proceedings of the Sixteenth Symposium on Operating Systems Principles, Saint Malo, FR, October 1997. ACM. KZ97] Joseph Kiniry and Daniel Zimmerman. A hands-on look at java mobile agents. IEEE Internet Computing, 1(4), August 1997. LTC96] W. S. Liao, S. Tan, and R. H. Campbell. Fine-grained, Dynamic User Customization of Operating Systems. In Proceedings Fifth International Workshop on ObjectOrientation in Operating Systems, pages 62{66, Seattle, Washington USA, October 1996. Maf95] Silvano Ma eis. Adding group communication and fault-tolerance to corba. In Proceedings of the 1995 USENIX Conference on Object-Oriented Technologies. The USENIX Association, June 1995. MBW97] S. E. Mitchell, A. Burns, and A. J. Wellings. Adaptive Scheduling using Re ection. In Proceedings of the ECOOP'97 Workshop on Re ective Real-Time Object-Oriented Programming and Systems, June 1997. Mea94] J. Mitchell and et al. An Overview of the Spring System. In Proceedings of Compcon 'Spring 1994, February 1994. MS97] Silvano Ma eis and Douglas C. Schmidt. Constructing reliable distributed communication systems with CORBA. IEEE Communications Magazine, 14(2), February 1997. NS95] K. Nahrstedt and J. M. Smith. The QoS Broker. IEEE Multimedia, 2(1):53{67, Spring 1995. Sch97] Douglas C. Schmidt. Principles and patterns of high-performance and real-time distributed object computing. In Proceedings of the Sixteenth Annual ACM Symposium on Principles of Distributed Computing, page 11, Santa Barbara, California, August 1997. SRC84] J. H. Saltzer, D. P. Reed, and D. D. Clark. End-to-end arguments in system design. ACM Transactions on Computer Systems, 2(4):277{288, November 1984. SSC96a] M. Se ka, Aamod Sane, and Roy H. Campbell. Monitoring Compliance of a Software System With Its High-Level Design Models. In 18th International Conference on Software Engineering, Berlin, Germany, March 25-26 1996. SSC96b] Mohlale Se ka, Aamod Sane, and Roy H. Campbell. Architecture-oriented visualization. In Proceedings of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), volume 31(10) of ACM SIGPLAN Notices, pages 389{405, October 1996. SSC97] Ashish Singhai, Aamod Sane, and Roy Campbell. Re ective ORBs: Support for Robust, Time-Critical Distribution. In Proceedings of the ECOOP'97 Workshop on Re ective Real-Time Object-Oriented Programming and Systems, June 1997. 12

SSC98a] Aamod Sane, Ashish Singhai, and Roy Campbell. End-to-end considerations in framework design. In Proceedings of the 12th European Conference on ObjectOriented Programming (ECOOP), Lecture Notes in Computer Science, page (to appear). Springer Verlag, July 1998. SSC98b] Ashish Singhai, Aamod Sane, and Roy Campbell. Quarterware for middleware. In
Proceddings of the 18th International Conference on Distributed Computing Systems (ICDCS). IEEE, May 1998.

Sun97] TCC+ 96]

TSS+ 97] VEY+ 97] vSHT97]

Yok92] ZBS97] ZF97]

Sun Microsystems. Linker and Libraries, 1997. On-line document available at http: . S. Tan, R. Campbell, Z. Chen, W. Liao, D. K. Raila, F. Kon, and M. Valdez. Adaptation and Synchronization in Low-Bandwidth Internet Video. In World Wide Web Consortium Workshop on Real Time Multimedia and the Web (RTMW '96), INRIA Sophia Antipolis, France, October 1996. David L. Tennenhouse, Jonathan M. Smith, W. David Sincoskie, David J. Wetherall, and Gary J. Minden. A survey of active network research. IEEE Communications Magazine, 35(1):80{86, January 1997. Amin Vahdat, Paul Eastham, Chad Yoshikawa, Eshwar Belani, Thomas Anderson, David Culler, and Michael Dahlin. WebOS: Operating System Services For Wide Area Applications. Technical Report 97-938, UCB-CSD, March 1997. Maarten van Steen, Philip Homburg, and Andrew Tanenbaum. The architectural design of globe: A wide-area distributed system. Technical Report Internal Report IR-422, Faculty of Mathematics and Computer Science. Vrije Universiteit, March 1997. Yasuhiko Yokote. The Apertos Re ecive Operating System: The Concept and Its Implementation. In Proceedings of the 1992 International Conference on ObjectOriented Programming, Systems, Languages, and Applications, October 1992. John A. Zinky, David E. Bakken, and Richard E. Schantz. Architectural Support for Quality of Service for CORBA Objects. Theory and Practice of Object Systems, April 1997. Stanley Zdonik and Michael Franklin. A framework for scalable dissemination based systems. In Proceedings of the 12th Conference on Object-Oriented Programming, Systems, Languages, and Applications, Sigplan Notices:32(10), pages 94{105. ACM Sigplan, October 1997.
//docs.sun.com

13