Network emulation is valuable largely because of its ability to study applications running on real hosts and "somewhat real" networks. However, conservatively allocating a physical host or network link for each corresponding virtual entity is costly and limits scale. We present a system that can faithfully emulate, on low-end PCs, virtual topologies over an order of magnitude larger than the physical hardware, when running typical classes of distributed applications that have modest resource requirements. This version of Emulab virtualizes hosts, routers, and networks, while retaining near-total application transparency, good performance fidelity, responsiveness suitable for interactive use, high system throughput, and efficient use of resources. Our key design techniques are to use the minimum degree of virtualization that provides transparency to applications, to exploit the hierarchy found in real computer networks, to perform optimistic automated resource allocation, and to use feed-back to adaptively allocate resources. The entire system is highly automated, making it easy to use even when scaling to more than a thousand virtual nodes. This paper identifies the many problems posed in building a practical system, and describes the system's motivation, design, and preliminary evaluation.

The main forces that shaped current network testbeds were the needs for realism and scale. Now that several testbeds support large and complex experiments, management of experimentation processes and results has become more difficult and a barrier to high-quality systems research. The popularity of network testbeds means that new tools for managing experiment workflows, addressing the ready-made base of testbed users, can have important and significant impacts. We are now evolving Emulab, our large and popular network testbed, to support experiments that are organized around scientific workflows. This paper summarizes the opportunities in this area, the new approaches we are taking, our implementation in progress, and the challenges in adapting scientific workflow concepts for testbed-based research. With our system, we expect to demonstrate that a network testbed with integrated scientific workflow management can be an important tool to aid research in networking and distributed systems.

Simulation has been the dominant research methodology in wireless and sensor networking. When mobility is added, real-world experimentation is especially rare. However, it is becoming clear that simulation models do not sufficiently capture radio and sensor irregularity in a complex, real-world environment, especially indoors. Unfortunately, the high labor and equipment costs of truly mobile experimental infrastructure present high barriers to such experimentation.We describe our experience in creating a testbed to lower those barriers. We have extended the Emulab network testbed software to provide the first remotely-accessible mobile wireless and sensor testbed. Robots carry motes and single board computers through a fixed indoor field of sensor-equipped motes, all running the user's selected software. In real-time, interactively or driven by a script, remote users can position the robots, control all the computers and network interfaces, run arbitrary programs, and log data. Our mobile testbed provides simple path planning, a vision-based tracking system accurate to 1 cm, live maps, and webcams. Precise positioning and automation allow quick and painless evaluation of location and mobility effects on wireless protocols, location algorithms, and sensor-driven applications. The system is robust enough that it is deployed for public use.We present the design and implementation of our mobile testbed, evaluate key aspects of its performance, and describe a few experiments demonstrating its generality and power.

Most new wireless research protocols and applications are evaluated using simulation, and such evaluations sparsely consider real-world radio signal propagation effects or device mobility. Current simulators do not describe these detailed RF characteristics very well. Researchers have found that multipath effects and other sources of radio irregularity can degrade effectiveness of routing protocols [4]. Consequently, in order to fully evaluate new wireless protocols, study of their interaction with real-world environments is necessary. Unfortunately, control and space issues create a barrier to mobilization of wireless devices in the real world. We have extended the highly-used Emulab testbed [3] to provide a remotely-accessible mobile wireless network testbed for use by the research community. The mobile testbed is currently deployed in a temporary area measuring 60 square meters in which remote users can dynamically position several robots. Dozens of sensor network motes, some with environmental sensors, are mounted on walls and ceilings. The robots carry an Intel Stargate with an X-Scale 400MHz CPU running Linux, a wireless Ethernet card, and a Mica2 sensor network mote with a 900MHz radio. Users can script robot motion using the ns language [2] or dynamically issue commands from a Java applet in the standard Emulab

Simulation has been the dominant research methodology in wireless and sensor networking. When mobility is added, the frequency of real-world experimentation becomes tiny. How- ever, it is becoming clear that simulation models do not suf- ficiently capture radio and sensor irregularity in a complex, real-world environment, especially indoors. Unfortunately, the high costs in labor, equipment, and tedium of truly mo- bile experimental infrastructure in real-world environments typically present an insurmountable barrier to such experi- mentation. We describe our experience in creating an initial testbed to lower those barriers. Our system, called "TrueMobile," already deployed for public use, provides the first remotely- accessible mobile wireless and sensor testbed. Robots carry motes and single board computers running Linux through a fixed field of sensor-equipped motes, all running the user's selected software. In real-time, interactively or driven by pre- programmed events, remote users can position the robots, control all the computers and network interfaces, and log data. TrueMobile provides simple path planning, a vision- based tracking system accurate to 1 cm, live maps, and we- bcams. Precise positioning and automation allow quick and painless evaluation of location and mobility effects on wire- less protocols, location algorithms, and sensor-driven appli- cations. We present TrueMobile's design and implementation, eval- uate key aspects of its performance, and describe a few exper- iments demonstrating its generality and power.

We have extended the well-known Emulab network testbed software to support both fixed and mobile wireless sensor devices. Mobility is achieved through remotely-controlled robots. We have deployed this software in public production use for the research and education communities. The current temporary testbed is in a 60 square meter indoor area. It contains six robots and 25 fixed Mica2 motes with serial programming boards, 10 of which also have full sensor boards. The robots carry an Intel Stargate with an X-Scale 400MHz CPU running Linux, an 802.11a/b/g wireless Ethernet card, and a Mica2. A much larger testbed is contemplated. Robot motion can be scripted using the ns language or interactively controlled from a Java applet Webcam views integrated into the applet ease remote access. A high-precision (1cm) localization system provides precise positions of robots (and thus wireless antennae). Users have full control over the wireless devices on each robot, and can install custom software on the Stargate and mote. To provide users with precise, real-time robot control, we extended the core of Emulab with three new components. The robot control daemon, robotd, maneuvers robots to user-specified positions based on input from visiond, and

Emulab is a large-scale, remotely-accessible network and distributed systems testbed used by over a thousand researchers around the world. In Emulab, users create "experiments" composed of arbitrarily interconnected groups of dedicated machines that are automatically configured according to user specifications. In the last year alone, users have run over 18,000 such experiments, expecting consistent and correct behavior in the face of the ever-evolving 500,000 line code base and 3,000 discrete hardware components that comprise Emulab. We have found normal testing to be insufficient to meet these expectations and have therefore provided continuous, automatic validation. This paper describes Linktest, an integral part of our validation framework that is responsible for end-to-end validation during the configuration of every experiment. Developing and deploying such a validation approach faces numerous challenges, including the need for a code path entirely independent of the rest of the Emulab software. We describe our system's motivation, its design and implementation and our experience.

Network emulation is valuable largely because of its abil- ity to study applications running on real hosts and "some- what real" networks. However, conservatively allocating a physical host or network link for each corresponding virtual entity is costly and limits scale. We present a system that can faithfully emulate, on relatively low-end PCs, virtual topologies over an order of magnitude larger than the phys- ical hardware, when running typical classes of distributed applications that have modest resource requirements. The new Emulab virtualizes hosts, routers, and networks, while retaining near-total application transparency, good perfor- mance fidelity, responsiveness suitable for interactive use, high system throughput, and efficient use of resources. Our key design techniques are to use the minimum degree of vir- tualization that provides transparency to applications, to ex- ploit the hierarchy found in real computer networks, to per- form optimistic automated resource allocation, and to use feedback to adaptively allocate resources. The entire sys- tem is highly automated, making it easy to use even when scaling to thousands of virtual nodes. This paper describes the system's motivation, design, and preliminary evaluation.

Many real-world distributed, real-time, embedded (ORE) systems, such as multiagent military applications, are built using commercially available operating systems, middleware, and collections of pre-existing software. The complexity of these systems makes it difficult to ensure that they maintain high quality of service (QOS). At design time, the challenge is to introduce coordinated QOS controls into multiple software elements in a non-invasive manner. At run time, the system must adapt dynamically to maintain high QOS in the face of both expected events, such as application mode changes, and unexpected events, such as resource demands from other applications. We describe the design and implementation of a CPU broker for these types of ORE systems. The CPU broker mediates between multiple real-time tasks and the facilities of a real-time operating system: using feedback and other inputs, it adjusts allocations over tune to ensure that high application-level QOS is maintained. The broker connects to its monitored tasks in a non-invasive manner, is based on and integrated with industry-standard middleware, and implements an open architecture for new CPU management policies. Moreover, these features allow the broker to be easily combined with other QOS mechanisms and policies, as part of an overall end-to-end QOS management system. We describe our experience in applying the CPU Broker to a simulated DUE military system. Our results show that the broker connects to the system transparently and allows it to function in the face of run-time CPU resource contention.

Mobile code makes it possible for users to define the processing and protocols used to communicate with a remote node, while still allowing the remote administrator to set the terms of interaction with that node. However, mobile code cannot do anything useful without a rich execution environment, and no administrator would install a rich environment that did not also provide strict controls over the resources consumed and accessed by the mobile code. Based on our experience with ANTS, we have developed Bees, an execution environment that provides better security, fine-grained control over capsule propagation, simple composition of active protocols, and a more flexible mechanism for interacting with end-user programs. Bees' security comes from a flexible authentication and authorization mechanism, capability-based access to privileged resources, and integration with our custom virtual machine that provides isolation, termination, and resource control. The enhancements to the mobile code environment make it possible to compose a protocol with a number of "helper" protocols. In addition, mobile code can now interact naturally with end-user programs, making it possible to communicate with legacy applications. We believe that these features offer significant improvements over the ANTS execution environment and create a more viable platform for active applications.

In this paper, we present STP, a system in which communicating end hosts use untrusted mobile code to remotely upgrade each other with the transport protocols that they use to communicate. New transport protocols are written in a type-safe version of C, distributed out-of-band, and run in-kernel. Communicating peers select a transport protocol to use as part of a TCP-like connection setup handshake that is backwards-compatible with TCP and incurs minimum connection setup latency. New transports can be invoked by unmodified applications. By providing a late binding of protocols to hosts, STP removes many of the delays and constraints that are otherwise commonplace when upgrading the transport protocols deployed on the Internet. STP is simultaneously able to provide a high level of security and performance. It allows each host to protect itself from untrusted transport code and to ensure that this code does not harm other network users by sending significantly faster than a compliant TCP. It runs untrusted code with low enough overhead that new transport protocols can sustain near gigabit rates on commodity hardware. We believe that these properties, plus compatibility with existing applications and transports, complete the features that are needed to make STP useful in practice.

Distributed applications are complex by nature, so it is essential that there be effective software development tools to aid in the construction of these programs. Commonplace “middleware” tools, however, often impose a tradeoff between programmer productivity and application performance. For instance, many corba idl compilers generate code that is too slow for high-performance systems. More importantly, these compilers provide inadequate support for sophisticated patterns of communication. We believe that these problems can be overcome, thus making idl compilers and similar middleware tools useful for a broader range of systems. To this end we have implemented Flick, a flexible and optimizing idl compiler, and are using it to produce specialized high-performance code for complex distributed applications. Flick can produce specially “decomposed” stubs that encapsulate different aspects of communication in separate functions, thus providing application programmers with fine-grain control over all messages. The design of our decomposed stubs was inspired by the requirements of a particular distributed application called Khazana, and in this paper we describe our experience to date in refitting Khazana with Flick-generated stubs. We believe that the special idl compilation techniques developed for Khazana will be useful in other applications with similar communication requirements. [1]This research was supported in part by the Defense Advanced Research Projects Agency, monitored by the Department of the Army under contract number DABT63-94-C-0058, and the Air Force Research Laboratory, Rome Research Site, USAF, under agreement number F30602-96-2-0269. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation hereon.

Many real-world distributed, real-time, embedded (DRE) systems, such as multi-agent military applications, are built using commercially available operating systems, middleware, and collections of pre-existing software. The complexity of these sys- tems makes it difficult to ensure that they maintain high quality of service (QOS). At design time, the challenge is to introduce coordinated QOS controls into multiple software elements in a non-invasive manner. At run time, the system must adapt dynamically to maintain high QOS in the face of both expected events, such as application mode changes, and unexpected events, such as resource demands from other applications. In this paper we describe the design and implementation of a CPU Broker for these types of DRE systems. The CPU Broker mediates between multiple real-time tasks and the facilities of a real-time operating system: using feedback and other inputs, it adjusts allocations over time to ensure that high application-level QOS is maintained. The broker connects to its monitored tasks in a non-invasive manner, is based on and integrated with industry- standard middleware, and implements an open architecture for new CPU management policies. Moreover, these features allow the broker to be easily combined with other QOS mechanisms and policies, as part of an overall end-to-end QOS management system. We describe our experience in applying the CPU Broker to a simulated DRE military system. Our results show that the broker connects to the system transparently and allows it to function in the face of run-time CPU resource contention. I. INTRODUCTION To meet the requirements of the market, real-time and embedded software systems must increasingly be designed atop commercial, off-the-shelf (COTS) operating systems and middleware. These technologies promote rapid software de- velopment by allowing system developers to concentrate on their application logic rather than on low-level "infrastruc- tural" code. In addition, commercial operating systems and middleware promote software quality by providing tested, ef- ficient, and reliable implementations of low-level functionality. Finally, these technologies promote scalability across different types of embedded platforms, configurability of features and feature selection, and evolvability of the embedded software systems over time. These so-called "-ilities" are essential in

Network emulation is valuable largely because of its ability to study applications running on real hosts and “somewhat real” networks. However, conservatively allocating a physical host or network link for each corresponding virtual entity is costly and limits scale. We present a system that can faithfully emulate, on relatively low-end PCs, virtual topologies over an order of magnitude larger than the physical hardware, when running typical classes of distributed applications that have modest resource requirements. The new Emulab virtualizes hosts, routers, and networks, while retaining near-total application transparency, good performance fidelity, responsiveness suitable for interactive use, high system throughput, and efficient use of resources. Our key design techniques are to use the minimum degree of virtualization that provides transparency to applications, to exploit the hierarchy found in real computer networks, to perform optimistic automated resource allocation, and to use feedback to adaptively allocate resources. The entire system is highly automated, making it easy to use even when scaling to thousands of virtual nodes. This paper describes the system’s motivation, design, and preliminary evaluation.