Srinidhi Varadarajan

EtheReal: a host-transparent real-time Fast Ethernet switch

Distributed multimedia applications require guaranteed quality of service (QoS) from the underlying networks. This paper describes the design, implementation, and evaluation of a real-time Fast Ethernet switch called EtheReal that provides bandwidth guarantees to real-time applications running on Ethernet without modification to the hardware and operating system on the host machines. At the heart of the EtheReal switch architecture is a novel real-time connection setup protocol that is completely transparent to the host machines OS, and thus allows the switch to be deployed in a network of heterogeneous machines running different OS platforms. The only dependency of EtheReal on the hosts is their support for TCP/UDP/IP. In addition, the EtheReal switch uses an Ethernet address swapping technique for real-time packets, similar to ATM to avoid the complexity of maintaining a global connection ID space. Because of the inherent CRC support built into Ethernet hardware, this technique significantly reduces the total processing overhead compared to address swapping at higher network layers. The current EtheReal switch prototype is fully operational; and is built with off-the-shelf PC hardware. It is capable of supporting up to 640 Mbits/sec across 4 ports, and has a per-hop connection establishment overhead of 0.1-0.6 msec and a 10 /spl mu/s non-real-time packet latency.

DejaVu: transparent user-level checkpointing, migration and recovery for distributed systems

We present a new fault tolerance system, DejaVu, for transparent and automatic checkpointing, migration and recovery of parallel and distributed applications. DejaVu has several novel features. First, it provides a transparent parallel checkpointing and recovery mechanism that recovers from any combination of systems failures without modification to parallel applications or the underlying operating system. Second, it uses a novel instrumentation and state capture mechanism that transparently captures application state. Third, it uses a new runtime mechanism for transparent incremental checkpointing, capturing the least amount of state needed to maintain global consistency. Finally, it provides a novel communication architecture that enables transparent migration of existing MPI codes, without source-code modifications. DejaVu has been implemented for 32 bit and 64 bit Linux platforms on x86 processors interconnected over Infiniband or Gigabit Ethernet networks. Performance results from the production-ready implementation shows less than 5% overhead with real-world parallel applications with large memory footprints.

The Distributed Open Network Emulator: Using Relativistic Time for Distributed Scalable Simulation

In this paper, we present the design and implementation of The Distributed Open Network Emulator (dONE), a scalable hybrid network emulation/simulation environment. It has several novel contributions. First, a new model of time called relativistic time that combines the controllability of virtual time with the naturally flowing characteristics of wall-clock time. This enables a hybrid environment in which direct code execution can be mixed with simulation models. Second, dONE uses a new transparent object based framework called Weaves, which enables the composition of unmodified network applications and protocol stacks to create large-scale simulations. Finally, it implements a novel parallelization strategy that minimizes the number of independent timelines and offers an efficient mechanism to progress the event timeline. Our prototype implementation incorporates the complete TCP/IP stack from the Linux 2.4 kernel family and executes any application code written for the BSD sockets interface. The prototype runs on 16 processors and produces super-linear speedup in a simulation of hundred infinite-source to infinite-sink pairs.

Avoiding deadlock avoidance

The evolution of processor architectures from single core designs with increasing clock frequencies to multi-core designs with relatively stable clock frequencies has fundamentally altered application design. Since application programmers can no longer rely on clock frequency increases to boost performance, over the last several years, there has been significant emphasis on application level threading to achieve performance gains. A core problem with concurrent programming using threads is the potential for deadlocks. Even well-written codes that spend an inordinate amount of effort in deadlock avoidance cannot always avoid deadlocks, particularly when the order of lock acquisitions is not known a priori. Furthermore, arbitrarily composing lock based codes may result in deadlock - one of the primary motivations for transactional memory. In this paper, we present a language independent runtime system called Sammati that provides automatic deadlock detection and recovery for threaded applications that use the POSIX threads (pthreads) interface - the de facto standard for UNIX systems. The runtime is implemented as a pre-loadable library and does not require either the application source code or recompiling/relinking phases, enabling its use for existing applications with arbitrary multi-threading models. Performance evaluation of the runtime with unmodified SPLASH, Phoenix and synthetic benchmark suites shows that it is scalable, with speedup comparable to baseline execution with modest memory overhead.

Reinforcing reachable routes

This paper studies the evaluation of routing algorithms from the perspective of reachability routing, where the goal is to determine all paths between a sender and a receiver. Reachability routing is becoming relevant with the changing dynamics of the Internet and the emergence of low-bandwidth wireless/ad hoc networks. We make the case for reinforcement learning as the framework of choice to realize reachability routing, within the confines of the current Internet infrastructure. The setting of the reinforcement learning problem offers several advantages, including loop resolution, multi-path forwarding capability, cost-sensitive routing, and minimizing state overhead, while maintaining the incremental spirit of current backbone routing algorithms. We identify research issues in reinforcement learning applied to the reachability routing problem to achieve a fluid and robust backbone routing framework. This paper also presents the design, implementation and evaluation of a new reachability routing algorithm that uses a model-based approach to achieve cost-sensitive multi-path forwarding; performance assessment of the algorithm in various troublesome topologies shows consistently superior performance over classical reinforcement learning algorithms. The paper is targeted toward practitioners seeking to implement a reachability routing algorithm.

DejaVu: Transparent User-Level Checkpointing, Migration, and Recovery for Distributed Systems

In this paper, we present a new fault tolerance system called DejaVu for transparent and automatic checkpointing, migration, and recovery of parallel and distributed applications. DejaVu provides a transparent parallel checkpointing and recovery mechanism that recovers from any combination of systems failures without any modification to parallel applications or the OS. It uses a new runtime mechanism for transparent incremental checkpointing that captures the least amount of state needed to maintain global consistency and provides a novel communication architecture that enables transparent migration of existing MPI codes, without source-code modifications. Performance results from the production-ready implementation show less than 5% overhead in real-world parallel applications with large memory footprints.

Experiences with EtheReal: a fault-tolerant real-time Ethernet switch

We present our experiences with the implementation of a real-time Ethernet switch called EtheReal. EtheReal provides three innovations for real-time traffic over switched Ethernet networks. First, EtheReal delivers connection oriented hard bandwidth guarantees without requiring any changes to the end host operating system and network hardware/software. For ease of deployment by commercial vendors, EtheReal is implemented in software over Ethernet switches, with no special hardware requirements. QoS support is contained within two modules, switches and end-host user level libraries that expose a socket like API to real time applications. Secondly, EtheReal provides automatic fault detection and recovery mechanisms that operate within the constraints of a real-time network. Finally EtheReal supports server-side push applications with a guaranteed bandwidth link-layer multicast scheme. Performance results from the implementation show that EtheReal switches deliver bandwidth guarantees to real time-applications within 0.6% of the contracted value, even in the presence of interfering best-effort traffic between the same pair of communicating hosts.

Weaves: a framework for reconfigurable programming

This paper presents a language independent runtime framework—called Weaves—for object based composition of unmodified code modules that enables selective sharing of state between multiple control flows through a process. Furthermore, the framework allows dynamic instantiation of code modules and control flows through them. In effect, weaves create intra-process modules (similar to objects in OOP) from code written in any language. Applications can be built by instantiating Weaves to form Tapestries of dynamically interacting code. The framework enables objects to be arbitrarily shared—it is a true superset of both processes as well as threads, with code sharing and fast context switching time similar to threads. Weaves does not require any special support from either the language or application code—practically any code can be weaved. Weaves also include support runtime loading and linking of object modules enabling the next generation of highly dynamic applications. This paper presents the elements of the Weaves framework and its implementation on the Linux platform over source-code independent ELF object files. The current implementation has been validated over Sweep3D, a benchmark for 3D discrete ordinates neutron transport (Koch et al. Trans. Am. Nucl. Soc. 65 (198) [1992]), and a user-level port of the Linux 2.4 family kernel TCP/IP protocol stack.

Exploiting coarse-grain speculative parallelism

Speculative execution at coarse granularities (e.g., code-blocks, methods, algorithms) offers a promising programming model for exploiting parallelism on modern architectures. In this paper we present Anumita, a framework that includes programming constructs and a supporting runtime system to enable the use of coarse-grain speculation to improve program performance, without burdening the programmer with the complexity of creating, managing and retiring speculations. Speculations may be composed by specifying surrogate code blocks at any arbitrary granularity, which are then executed concurrently, with a single winner ultimately modifying program state. Anumita provides expressive semantics for winner selection that go beyond time to solution to include user-defined notions of quality of solution. Anumita can be used to improve the performance of hard to parallelize algorithms whose performance is highly dependent on input data. Anumita is implemented as a user-level runtime with programming interfaces to C, C++, Fortran and as an OpenMP extension. Performance results from several applications show the efficacy of using coarse-grain speculation to achieve (a) robustness when surrogates fail and (b) significant speedup over static algorithm choices.

Modular implementation of adaptive decisions in stochastic simulations

We present a modular approach to implement adaptive decisions with existing scientific codes. Using a sophisticated system software tool based on the function call interception technique, an external code module is transparently combined with the given program without altering the original code structure, resulting in a newly composed application with extended behavior. This is useful for generalizing codes into using different parameter values or to switch algorithms or implementations at runtime. Applying the proposed method on a biochemical stochastic simulation software package to implement a set of exemplary use cases, which includes changing program parameters, substituting random number generators, and dynamically changing the stochastic simulation method, we demonstrate how effectively new code modules can be plugged in to construct an application with enhanced capabilities.