Simulation is an efficient and powerful tool for studying wireless networking. The lack of physical layer (PHY) accuracy in many popular network simulators such as ns-2 and OPNET has been observed to produce misleading results. In this paper, we demonstrate a technique for validating the packet-level PHY models in network simulators against the physical layer of a software-defined radio testbed. Specifically, we evaluate the accuracy of model-based simulations against hybrid (i.e., joint packet and waveform) simulations of the real PHY implementation directly executing in a simulation environment. We demonstrate that this direct-execution approach is an effective means of evaluating the accuracy of packet-level PHY models from the perspectives of different protocol layers using a broad set of operating conditions. Moreover, this is an effective means of establishing when a packet-level PHY model can be used to generate trustworthy simulation results.

Increasingly wireless networks use multi-antenna nodes as in IEEE 802.11n and 802.16. The physical layer (PHY) in such systems may use the antennas to provide multiple streams of data (spatial multiplexing) or to increase the robustness of fewer streams. These physical layers also provide support for sending packets at different rates by changing the modulation and coding of transmissions. Rate adaptation is the problem of choosing the best transmission mode for the current channel and in these systems requires choosing both the level of spatial multiplexing and the modulation and coding. Hydra is an experimental wireless network node prototype in which both the MAC and PHY are highly programmable. Hydra's PHY is essentially the 802.11n PHY, and currently supports two antennas and the same modulations and codings as 802.11n. Because of limitations of our hardware platform, the actual rates are a factor of 10 smaller than 802.11n. The MAC is essentially the 802.11 MAC with extensions, including the ability to feedback channel state or rate information from the receiver. Hydra was designed to allow experimentation with real radios, PHYs, and network stacks over real-world channels and it is well suited to studying rate adaptation in multi-antenna systems. To allow controlled experimentation, we also have the ability to perform experiments over emulated channels using exactly the same MAC and PHY used for RF transmissions. We present rate control experiments based on transmission over both real and emulated channels. Our experiments include measurements for single antenna systems and two antenna systems using a single or multiple spatial streams. We study rate adaptation algorithms using both explicit and implicit feedback from the receiver. A novel aspect of our results is the first experimental study of adaptation between single and multiple spatial streams for 802.11n style systems.

As data rates supported by the physical layer increase, PHY and especially MAC overheads increasingly dominate the throughput achievable by wireless networks. A promising approach for reducing these overheads is to aggregate a number of frames together into a single transmission. The 802.11n standard uses such an approach for unicast frames. We present the design of a system that can aggregate both unicast and broadcast frames. Further, the system can classify TCP ACK segments so that they can be aggregated with TCP data flowing in the opposite direction. A novel aspect of our work is that we implement and validate our design not through simulation, but rather using our wireless node prototype, Hydra, which supports a high performance PHY based on 802.11n. Our validation shows significant improvements in throughput for each kind of aggregation we support.

This paper investigates the tradeoff between throughput and feedback delay of limited feedback beamforming in indoor wireless channels with a practical MIMO-OFDM prototype. Past descriptions of this tradeoff are largely based on simplified models of the wireless channel. Unfortunately, wireless channel models may not accurately represent the complexities of a real wireless channel. Furthermore, system impairments, including channel estimation error, only exacerbate the problem of modeling a real wireless system. One such analytical result predicts the performance of limited feedback beamforming as an exponential function of feedback delay. This analytical result has been confirmed through Monte Carlo simulation under Rayleigh fading channel models. Through rigorous measurements and experimentation this paper both evaluates the performance of limited feedback beamforming under feedback delay and confirms the accuracy of the analytical results.

Conventional data networks are based on layered architectures. The introduction of wireless networks has created a need to violate this layering discipline to create cross- layer designs or adaptations. Ad-hoc implementations of such cross-layer adaptations reduce the level of modularity and abstraction in the network's implementation, giving rise to a significant increase in complexity. We present a taxonomy of possible cross-layer adaptations that is then used to derive an architecture for their implementation that significantly preserves the networks structure. We present implementation results that validate this architecture in the context of a real wireless network implementation.

Hydra is a flexible wireless network testbed being developed at UT Austin. Our focus is networks that support multiple wireless hops and where the network, especially the MAC, takes advantage of sophisticated PHY techniques, such as OFDM and MIMO. We argue that for this domain simulation alone is not adequate and that working prototypes are needed to validate algorithms and protocols. Hydra nodes consist of a flexible RF front-end and a general purpose machine with a software based MAC and PHY. Using the frameworks of the Click modular router and GNU radio and coding in C++ makes it relatively easy to implement working prototypes of cross-layer designs that require custom MACs and PHYs. We present the architecture and implementation of Hydra, as well as a preliminary cross-layer design experiment for a rate-adaptive MAC. These early results show Hydra is a capable prototyping tool for wireless network research.

We propose a multichannel feedback protocol to enable local scheduling with channel state information for wireless networks with orthogonal frequency division multiplexing (OFDM). In our proposed protocol, the frequency subcarrier domain is shared by multiple control channels, on which request-to-send (RTS) and clear-to-send (CTS) are exchanged. These control channels are created using random spreading signatures. Channel state information of the simultaneous transmissions, which defines the gains of these channels, is exchanged on these control channels and channel state information tables that contain the channel information of both the desired link and the interfering links are created at the transmit nodes, then scheduling decisions are made based on the channel information tables. We show that the proposed protocol improves the network throughput compared to IEEE 802.11 style protocols for a wireless local area network topology

We address the problems of the IEEE 802.11 MAC for wireless networks by designing a MAC protocol jointly with a multiple-input multiple-output (MIMO) technique in the physical layer. We propose a new MAC protocol, mitigating interference using multiple antennas MAC (MIMA-MAC), which mitigates interference from neighboring nodes by employing the spatial multiplexing capability of MIMO. Both theoretical analysis and simulation results clearly show that the proposed MIMA-MAC system outperforms the 802.11 system in terms of the aggregate throughput of the network by mitigating interference from neighboring nodes and thereby increasing simultaneous transmissions in the network.

With the explosion of demand for wireless communication services, scarcity of spectrum poses a great challenge to wireless networking. However, recent field measurements show that a significant percentage of spectrum is under-utilized . To address this problem, the research community introduced the concept of real-time secondary markets, where licensees are allowed to temporarily lease the spectrum unused by the primary users to secondary users. To support this new service, an authentication, authorization, and accounting (AAA) mechanism must be in place to enable the licensees and secondary users to trade spectrum in a real-time manner. In this paper, we present an AAA system architecture, and propose a set of mechanisms to authenticate and authorize secondary users, synchronize multiple secondary devices, and manage real-time secondary market services.

Media access control (MAC) mechanism design is a key problem in wireless networking. One problem is hidden nodes, which are allowed to transmit, but which interfere with a receiver causing a collision. Another problem is exposed nodes, which are not allowed to transmit although they would not interfere, thus limiting spatial reuse. MAC designs, like IEEE 802.11, try to solve both of these problems, but are not wholly successful. Other MAC designs attempt to control the transmit power, both to lower power use and to minimize exposed nodes. This results in a worsened hidden node problem. We present a power control MAC that balances the hidden and exposed node problem. The idea is to use no more power than is needed to eliminate the hidden nodes, thus limiting the exposed nodes. We present simulation results that show our design outperforms both 802.11 and previous power control MACs.

Many important applications must run continuously and without interruption, and yet also must be changed to fix bugs or upgrade functionality. No prior general-purpose methodology for dynamic updating achieves a practical balance between flexibility, robustness, low overhead, ease of use, and low cost.We present an approach for C-like languages that provides type-safe dynamic updating of native code in an extremely flexible manner---code, data, and types may be updated, at programmer-determined times---and permits the use of automated tools to aid the programmer in the updating process. Our system is based on dynamic patches that contain both the updated code and the code needed to transition from the old version to the new. A novel aspect of our patches is that they consist of verifiable native code (e.g. Proof-Carrying Code or Typed Assembly Language), which is native code accompanied by annotations that allow online verification of the code's safety. We discuss how patches are generated mostly automatically, how they are applied using dynamic-linking technology, and how code is compiled to make it updateable.To concretely illustrate our system, we have implemented a dynamically updateable web server, FlashEd. We discuss our experience building and maintaining FlashEd, and generalize to present observations about updateable software development. Performance experiments show that for FlashEd, the overhead due to updating is low: typically less than 1 percent.

This paper presents a new MAC protocol, mitigating interference using multiple antennas with antenna selection (MIMA/AS-MAC), which uses multiple antennas to mitigate both interference from neighboring transmitters and fading. The proposed MIMA/AS-MAC protocol employs spatial multiplexing with antenna subset selection for data packet transmission, while using the Alamouti space-time code for control of packet transmission. To study its performance, the MIMA/AS-MAC was implemented in the ns-2 network simulator for a system with two antennas. The total network throughput and fairness between two traffic flows was measured. The results show that the MIMA/AS-MAC system outperforms the previously proposed MIMA-MAC scheme, which does not use an antenna selection scheme, as well as a hybrid of the IEEE 802.11 MAC protocol with Alamouti encoding.

All distributed computing systems face the architectural question of the location (and nature) of programmability in the telecommunications networks, computers, and other peripheral devices comprising them. The perspective of this paper is that network elements should be as programmable as possible, to enable the most flexible distributed computing systems. There has been a persistent confluence among operating systems, programming languages, networking and distributed systems. We demonstrate how these interactions led to what is called "active networking," and in the spirit of "vox audita peril, littera scripta manel" (the spoken word perishes, but the written word remains), include an account of how it was made to happen. Lessons are drawn both from the broader research agenda, and the specific goals pursued in the SwitchWare project. We speculate on likely futures for active networking.

We present SNAP (safe and nimble active packets), a new scheme for programmable (or active) packets centered around a new low-level packet language. Unlike previous active packet approaches, SNAP is practical: namely, adding significant flexibility over IP without compromising safety and security or efficiency. In this paper we show how to compile from the well-known active picket language PLAN to SNAP, showing that SNAP retains PLAN's flexibility; give proof sketches of its novel approach to resource control; and present experimental data showing SNAP attains performance very close to that of a software IP router.

Many important applications must run continuously and without interruption, yet must be changed to fix bugs or upgrade functionality. No prior general-purpose methodology for dynamic updating achieves a practical balance between flexibility, robustness, low overhead, and ease of use.

We present PLANet: an active network architecture and implementation. In addition to a standard suite of Internet-like services, PLANet has two key programmability features: (1) all packets contain programs; and (2) router functionality may be extended dynamically. Packet programs are written in our special purpose programming language PLAN, the Packet Language for Active Networks, while dynamic router extensions are written in OCaml, a dialect of ML. Currently, PLANet routers run as byte-code-interpreted Linux user-space applications, and support Ethernet and IP as link layers. PLANet achieves respectable performance on standard networking operations: on 300 MHz Pentium-II's attached to 100 Mbps Ethernet, PLANet can route 48 Mbps and switch over 5000 packets per second. We demonstrate the utility of PLANet's activeness by showing experimentally how it can nontrivially improve application and aggregate network performance in congested conditions.

Comparative experimentation is increasingly important in computer science, but performing such experiments can be challenging. The paper presents a set of experiments that compare the performance of two persistent storage managers, and answer the question of whether the safer storage manager has performance comparable to the less safe one. This comparison was difficult for a number of reasons, among them: relatively few programs using either storage manager existed and no established benchmarks existed, and the two techniques are incompatible at the source code level, thus making a direct comparison impossible. In particular one storage manager used a malloc-and-free style of dynamic storage allocation, while the other used a high performance concurrent garbage collector. A number of approaches were used to overcome this difficulty. The most novel approach involved tracing the memory management of a production program that used the malloc-and-free based storage manager and then replaying the trace in an environment that allowed garbage collection and malloc-and-free to be compared. The study represents the most extensive study of a garbage collected persistent storage system to date.

The evolutionary history of a set of species is represented by a phylogenetic tree, in other words, by a rooted, leaf-labelled tree, where internal nodes represent ancestral species and the leaves represent modern day species. Accurate (or even boundedly inaccurate) topology reconstructions of large and divergent trees has long been considered one of the major challenges in systematic biology. None of the polynomial time methods developed by the theoretical computer science community has been shown to outperform the popular Neighbor-Joining method used by systematic biologists, with respect to topology estimation. (However, preliminary experiments indicate that two new variants of Neighbor-Joining, Bio-NJ and Weighbor, do exhibit improved performance.) In this paper, we present a simple polynomial time method, the Disk-Covering Method (DCM), which boosts the performance of base phylogenetic methods. We analyze the performance of DCM-boosted distance methods under the general Markov mo...

PLAN (Packet Language for Active Networks) is a new language for programs that form the packets of a programmable network. These programs replace the packet headers (which can be viewed as very rudimentary programs) used in current networks. As such, PLAN programs are lightweight and of restricted functionality. These limitations are mitigated by allowing PLAN code to call node-resident service routines written in other, more powerful languages. This two-level architecture, in which PLAN serves as a scripting or 'glue' language for more general services, is the primary contribution of this paper. We have successfully applied the PLAN programming environment to implement an IP-free internetwork.PLAN is based on the simply typed lambda calculus and provides a restricted set of primitives and datatypes. PLAN defines a special construct called a chunk used to describe the remote execution of PLAN programs on other nodes. Primitive operations on chunks are used to provide basic data transport in the network and to support layering of protocols. Remote execution can make debugging difficult, so PLAN provides strong static guarantees to the programmer, such as type safety. A more novel property aimed at protecting network availability is a guarantee that PLAN programs use a bounded amount of network resources.

This paper examines the design space for copying garbage collectors (GCs) in which "large objects" are managed in a separate, non-copy-collected space. We focus on two main issues:1. how to set the policy for classifying objects as "large"2. how to manage the large object spaceWe explore these issues experimentally using the Oscar GC testbed. In particular, we vary the threshold size of large objects and also whether the objects may contain pointers. Furthermore, we compare the performance of treadmill collection to that of mark-and-sweep collection for managing the large object space.We find that for some heaps there is a minimum cutoff size below which adding objects to the large object space does not result in a performance improvement, while for others no such cutoff exists. In general, including pointer-containing objects in the large object space seems beneficial. Finally, the exact method used to collect the large object space does not significantly influence overall performance.

We examine the costs and benefits of a variety of copying garbage collection (GC) mechanisms across multiple architectures and programming languages. Our study covers both low-level object representation and copying issues as well as the mechanisms needed to support more advanced techniques such as generational collection, large object spaces, and type segregated areas.Our experiments are made possible by a novel performance analysis tool, Oscar. Oscar allows us to capture snapshots of programming language heaps that may then be used to replay garbage collections. The replay program is self-contained and written in C, which makes it easy to port to other architectures and to analyze with standard performance analysis tools. Furthermore, it is possible to study additional programming languages simply by instrumenting existing implementations to capture heap snapshots.In general, we found that careful implementation of GC mechanisms can have a significant benefit. For a simple collector, we measured improvements of as much as 95%. We then found that while the addition of advanced features can have a sizeable overhead (up to 15%), the net benefit is quite positive, resulting in additional gains of up to 42%. We also found that results varied depending upon the platform and language. Machine characteristics such as cache arrangements, instruction set (RISC/CISC), and register pool were important. For different languages, average object size seemed to be most important.The results of our experiments demonstrate the usefulness of a tool like Oscar for studying GC performance. Without much overhead, we can easily identify areas where programming language implementors could collaborate with GC implementors to improve GC performance.

Active networks accelerate network evolution by permitting the network infrastructure to be programmable, on a per-user, per-packet, or other basis. This programmability must be balanced against the safety and security needs inherent in shared resources.This paper describes the design, implementation, and performance of a new type of network element, an Active Bridge. The active bridge can be reprogrammed "on the fly", with loadable modules called switchlets. To demonstrate the use of the active property, we incrementally extend what is initially a programmable buffered repeater with switchlets into a self-learning bridge, and then a bridge supporting spanning tree algorithms. To demonstrate the agility that active networking gives, we show how it is possible to upgrade a network from an "old" protocol to a "new" protocol on-the-fly. Moreover, we are able to take advantage of information unavailable to the implementors of either protocol to validate the new protocol and fall back to the old protocol if an error is detected. This shows that the Active Bridge can protect itself from some algorithmic failures in loadable modules.Our approach to safety and security favors static checking and prevention over dynamic checks when possible. We rely on strong type checking in the Caml language for the loadable module infrastructure, and achieve respectable performance. The prototype implementation on a Pentium-based HP Netserver LS running Linux with 100 Mbps Ethernet LANS achieves ttcp throughput of 16 Mbps between two PCs running Linux, compared with 76 Mbps unbridged. Measured frame rates are in the neighborhood of 1800 frames per second.

\Ve describe the design of a transaction facilit y for a language that supports higher-order functions.tVe factor transactions into four separable features: persistence, undoability, locking, and threads.Then, relying on function composition, we show how we can put them together again.Our modular approach toward building transactions enables us to construct a model of concurrent, nested, multi threaded transactions, as well as other nontradi tional models where not all features of traditional transactions are present.Key to our approach is the use of higher-order functions to make transactions first-class.Not only do we get clean composability of transactional features, but also we avoid the need to introduce special control General

We have implemented the first copying garbage collector that permits continuous unimpeded mutator access to the original objects during copying. The garbage collector incrementally replicates all accessible objects and uses a mutation log to bring the replicas up-to-date with changes made by the mutator. An experimental implementation demonstrates that the costs of using our algorithm are small and that bounded pause times of 50 milliseconds can be readily achieved.

We describe a replicating garbage collector for a persistent heap. The garbage collector cooperates with a transaction manager to provide safe and efficient transactional storage management. Clients read and write the heap in primary memory and can commit or abort their write operations. When write operations are committed they are preserved in stable storage and survive system failures. Clients can freely access the heap during garbage collection because the collector concurrently builds a compact replica of the heap. A log captures client write operations and is used to support both the transaction manager and the replicating garbage collector.Our implementation is the first to provide concurrent and compacting garbage collection of a persistent heap. Measurements show that concurrent replicating collection produces significantly shorter pause times than stop-and-copy collection. For small transactions, throughput is limited by the logging bandwidth of the underlying log manager. The results suggest that replicating garbage collection offers a flexible and efficient way to provide automatic storage management in transaction systems, object-oriented databases and persistent programming environments.