Sean Rooney

The Tempest: a framework for safe, resource assured, programmable networks

Most research in network programmability has stressed the flexibility engendered by increasing the ability of users to configure network elements for their own purposes, without addressing the larger issues of how such advanced control systems can coexist both with each other and with more conventional ones. The Tempest framework presented here extends beyond the provision of simple network programmability to address these larger issues. In particular, we show how network programmability can be achieved without jeopardizing the integrity of the network as a whole, how network programmability fits in with existing networks, and how programmability can be offered at different levels of granularity. Our approach is based on the Tempests ability to dynamically create virtual private networks over a switched transport architecture (e.g., an ATM network). Each VPN is assigned a set of network resources which can be controlled using either a well-known control system or a control system tailored to the specific needs of a distributed application. The first level of programmability in the Tempest is fairly coarse-grained: an entire virtual network can be programmed by a third party. At a finer level of granularity the Tempest allows user supplied code to be injected into parts of an operational virtual network, thus allowing application specific customization of network control. The article shows how the Tempest framework allows these new approaches to coexist with more conventional solutions.

Network infrastructure for massively distributed games

The popularity of hypertext documents led to the need for specific network infrastructure elements such as HTML caches, URL-based switches, web-server farms, and as a result created several new industries as companies rushed to fill that need. We contend that massive distributed games will have a similar impact on the Internet and will require similar dedicated support. This paper outlines some initial work on prototyping such support. Our approach is to combine highlevel game specific logic and low-level network awareness in a single network-based computation platform that we call a booster box.

Automatic VLAN creation based on on-line measurement

Virtual LANs (VLANs) permit hosts connected to a LAN switch to be grouped together into logical groups as a function of some management policy rather than simply of their physical location. Commercial LAN switches support a variety of policies based on either physical or logical addresses, protocol types, tagged frames, or user defined rules. The objective of these policies is the same: to reduce the amount of traffic that needs to be routed by grouping together hosts which are likely to communicate with each other into the same virtual LAN. This paper proposes a novel and more direct approach, it shows how VLANs can be created and removed dynamically as a function of the measured traffic patterns across the network. This is both simpler than configuring many static rules and permits the VLAN configuration to adapt to the evolution in the traffic patterns. The latter point is especially important in future LANs supporting peer-to-peer continuous media services, such as IP telephony or video-conferencing, in which clusters of hosts come together to communicate with each other intensively for relatively short periods of time and then form into new clusters.

Communication Architectures for Massive Multi-Player Games

Massive multi-player games are characterized by a large number of participating players. It is therefore essential that an appropriate communication architecture is deployed in order to support an ever growing number of players. Several such architectures have been proposed, including client-server and peer-to-peer architectures. In this paper, we propose a systematic method to assess the scalability of different architectures in order to identify the most appropriate one for specific game types. The model proposed is very general in that it covers centralized, distributed, and hybrid architectures and it is applied to the client-server, peer-to-peer and the newly introduced federated peer-to-peer architecture. Quantitative expressions that capture the effect of various game types are derived, and the trade-offs among the architectures are identified.

Techniques for integrating sensors into the enterprise network

Cheap programmable sensor devices are becoming commercially available. They offer the possibility of transforming existing enterprise applications and enabling entirely new ones. The merging of sensor networks into the enterprise network poses some distinct problems. In particular, information from theses devices must be obtained in a way which minimizes their energy use and must be aggregated and filtered before being sent to the application server to prevent it from being overwhelmed. We describe a range of complementary techniques for integrating sensors into an enterprise network. These comprise new architectural entities within the enterprise network — edge server — new means of sharing information within the enterprise network — messaging binning — and new protocols for extracting information from the sensor network — Messo.

Edge server software architecture for sensor applications

Edge servers perform computation on data in addition to that performed by the application server. Typically edge servers are deployed just in front of the application server and perform simple generic functions such as load balancing. With the increasing integration of network connected sensors into Internet based applications we foresee the need for the deployment of edge servers at the other end of the network, i.e. at the boundary with the external sensor network. These edge servers reduce the amount of data that has to be sent to the application server by filtering, summarizing and aggregating the sensor data. They are distinct from existing servers in both the location they run and the application-specific functions they perform. Both these differences influence their design. We describe our implementation of such an edge server.

OS streaming deployment

A network deployment of generally available operating systems (OS) usually takes in the order of tens of minutes. This is prohibitive in an environment in which OSs must be dynamically and frequently provisioned in response to external requests. By exploiting the fact that in general only a small part of an OS image is actually required to be present to perform useful tasks, we demonstrate how an OS can perform work shortly after a deployment has begun. This requires the insertion of a streaming device between the operating system and the disk. We have implemented such a device for Windows∗ and Linux∗. We show that such an OS streaming deployment reduces significantly (i.e., to a few seconds) the time between the start of the deployment and the moment at which the OS is available. Furthermore, we demonstrate that the performance overhead of using the OS during streaming is negligible as the penalty introduced by the streaming device is minor and the I/O performance is completely dominated by the multiple caches between the application and the disk.

Messo & Preso Practical Sensor-Network Messaging Protocols

We present two protocols one of which supports the publication by sensors in a sensor-network of messages on a named topic, the other that allows sensors to subscribe to messages on a named topic. We separate the publish and subscribe functions into different protocols as it is not necessary for a given device to support both. The publication protocol is designed for management systems in which nodes take readings from a sensor and transmit them to monitoring applications while the subscription protocol is for actuating systems in which the state of certain nodes is changed by control applications. The protocols use cross-layer optimization techniques for reducing transmissions within the messaging layer of the sensor-network. We show that the path characteristics of such network are highly variable leading to frequent topology changes motivating our description of the protocols which can function even over fluctuating network topologies. Finally, we use simulation to compare the actuation protocol with an epidemic approach, showing that our protocol is more efficient when the topics that the nodes are interested in are non-uniform

On the Applicability of Compressive Sampling in Fine Grained Processor Performance Monitoring

Real-time performance analysis of processor behaviourrequires the efficient gathering of micro-architecturalinformation from processor cores. Such information can beexpected to be highly structured allowing it to be compressed, but the computational burden of conventional compression techniques exclude their use in this environment. We consider the use of new mathematical techniques that allow a signal to be compressed and recovered from a relatively small number of samples. These techniques, collectively termed Compressive Sampling,are asymmetric in that compression is simple, but recovery is complex. This makes them appropriate for applications in which the simplicity of the sensor can be offset against complexity at the ultimate recipient of the sensed information. We evaluate the practicality of using such techniques in the transfer of signals representing one or more micro-architectural counters from a processor core. We show that compressive sampling is usable to recover such performance signals, evaluating the trade-off between efficiency, accuracy and practicability within its variousvariants.

Toward scalable real-time messaging

Conventional messaging technologies have been designed for large transactional systems, making the prediction and calibration of their delay impractical. In this paper, we present a minimal messaging system, implemented in Java™, that is designed to enable the analysis, modeling, and calibration of the expected performance of these technologies. We describe the algorithms and protocols that underlie this messaging system, show how an analysis can be performed, and give the actual measured performance figures. We show that the system achieves a throughput of more than 100,000 messages per second with less than 120-millisecond maximum latency, in the test environment. At 10,000 messages per second, a maximum latency of 5 milliseconds is measured. The algorithms make use of lock-free data structures, which allow the throughput to scale on multi-core systems.