Nigamanth Sridhar

Abstractions for safe concurrent programming in networked embedded systems

Over the last several years, large-scale wireless mote networks have made possible the exploration of a new class of highly-concurrent and highly-distributed applications. As the horizon of what kinds of applications can be built on these networked embedded systems keeps expanding, there is a need to keep the activity of programming such systems easy, efficient, and scalable. We make three major contributions in this paper. First, we present a library for TinyOS and nesC that enables true multi-threading on a mote. This library includes support for all mote platforms in use currently (AVR, MSP). Second, we present a tool that can effectively and accurately compute stack requirements for multithreaded programs. Such analysis ensures that the stacks allocated to individual threads are correctly sized. Finally, we present a collection of programming abstractions that simplifies the construction of concurrent systems for the mote platform. We also present experimental results obtained from several example systems built using our concurrent programming abstractions and the underlying thread library.

Decentralized Local Failure Detection in Dynamic Distributed Systems

A failure detector is an important building block when constructing fault-tolerant distributed systems. In asynchronous distributed systems, failed processes are often indistinguishable from slow processes. A failure detector is an oracle that can intelligently suspect processes to have failed. Different classes of failure detectors have been proposed to solve different kinds of problems. Almost all of this work is focused on global failure detection, and moreover, in systems that do not contain mobile nodes or include dynamic topologies. In this paper, we present diamPm l - a local failure detector that can tolerate mobility and topology changes. This means that diamPm l can distinguish between a failed process and a process that has moved away from its original location. We also establish an upper bound on the duration for which a process wrongly suspects a node that has moved away from its neighborhood. We support our theoretical results with experimental findings from an implementation of this algorithm for sensor networks

Dynamic module replacement in distributed protocols

Dynamic module replacement - the ability to hot swap a components implementation at runtime - is fundamental to supporting evolutionary change in long-lived and highly-available systems. Most existing solutions require special-purpose middleware or depend on research languages with limited support for mainstream software development. We present a language-neutral technique for dynamic module replacement using Service Facilities (Serfs) - a pattern-based design strategy for decoupling runtime dependencies. We demonstrate the sufficiency of Serfs with respect to a litmus test of criteria for module replacement. Next, we extend the traditional scope of module replacement to encompass the domain of modules for distributed protocols. We conclude by applying the Serf strategy to illustrate dynamic replacement of mutual exclusion protocols in modules for distributed resource allocation.

A Sensor Network System for Measuring Traffic in Short-Term Construction Work Zones

In this paper, we present the design and implementation of a sensor network system for monitoring the flow of traffic through temporary construction work zones. As opposed to long-term work zones which are common on highways, short-term or temporary work zones remain active for a few hours or a few days at most. As such, instrumenting temporary work zones with monitoring equipment similar to those used in long-term work zones is not practical. Yet, these temporary work zones present an important problem in terms of crashes occurring in and around them. Our design for a sensornet-based system for monitoring traffic is (a ) inexpensive, (b ) rapidly deployable, and (c ) requires minimal maintenance. We report on our experiences in building this system, and with testing our system in live work zones in the Cleveland area.

Failure detectors for wireless sensor-actuator systems

Wireless sensor-actuator systems (WSAS) offer exciting opportunities for emerging applications by facilitating fine-grained monitoring and control, and dense instrumentation. The large scale of such systems increases the need for such systems to tolerate and cope with failures, in a localized and decentralized manner. We present abstractions for detecting node failures and link failures caused by topology changes in a WSAS. These abstractions were designed and implemented as a set of reusable components in nesC under TinyOS. Results, which demonstrate the performance and viability of the abstractions, based on experiments on an 80 node testbed are presented. In the future, these abstractions can be extended to detect and cope with larger classes of failures in WSAS.

DESAL alpha: An Implementation of the Dynamic Embedded Sensor-Actuator Language

We present DESALalpha, a realization of the dynamic embedded sensor-actuator language for Telos-based devices. The platform provides native support for: (i) rule-based programming; (ii) synchronized action scheduling; (iii) neighborhood management; and (iv) distributed state sharing. We describe the design and implementation of DESALalpha, present examples that illustrate its use, and summarize the resource requirements of compiled applications. Finally, we present lessons learned based on our use of DESALalpha during the past year.

A state-based language for sensor-actuator networks

This paper introduces a language design for sensor-actuator networks. The main features are communication by a soft-state abstraction and behavior control by periodic rule evaluation. These features enable a state-based, rather than event-based, style of programming. Dynamic changes to network configuration and failures of components are automatically handled by this approach. The design choices target applications which experience low-to-moderate rates of sensor input and which do not require extreme, low-latency sensor processing and actuation. Coordinated actuation is concisely expressed in this language.

Service Facilities: Extending Abstract Factories to Decouple Advanced Dependencies

It is widely agreed that component interactions should be based on the import and export of interface information only, not on knowledge of implementation-specific details. This can be achieved in many cases either by explicit parameterization using templates (in languages that have them) or by using some variant of the abstract factory pattern. We introduce an alternative: the use of service facilities. This technique is similar both to the use of templates and to the use of factories, but it is preferable to both in several important ways. Service facilities can be used to decouple design-time concrete-to-concrete component dependencies in any reasonable programming language and with any component infrastructure that is based on design-by-contract principles.

Stackless preemptive multi-threading for TinyOS

Programming support for multi-threaded applications on embedded microcontroller platforms has attracted a considerable amount of research attention in the recent years. This paper is focused on this problem, and presents UnStacked C, a source-to-source transformation that can translate multithreaded programs into stackless continuations. The transformation can support legacy code by not requiring any changes to application code, and only modifications to the underlying threading library. We describe the details of UnStacked C in the context of the TinyOS operating system for wireless sensor network applications. We present a modified implementation of the TOSThreads library for TinyOS, and show how existing applications programmed using TOSThreads can be automatically transformed to use stackless threads with only modifications in the build process. By eliminating the need to allocate individual thread stacks and by supporting lazy thread preemption, UnStacked C enables a considerable saving of memory used and power consumed, respectively.

Utilization of a wrist-mounted accelerometer to count movement repetitions

Stroke is a leading cause of disability. Lasting effects of a stroke may include limited mobility in limbs. In order to restore a reasonable amount of function in the upper extremities, extensive rehabilitation that includes multiple repetitions of practice are necessary. These practice sessions are often boring to the patient. The work we describe in this paper is a part of a larger project using the ENGAGE video gaming protocol to make these therapy sessions more engaging and effective. Instead of repeating a specific exercise, the patient plays a video game using the Nintendo Wii remote or the PlayStation EyeToy. When engaging in such non-standard motion, it becomes more difficult for the clinician to gauge how much of the required practice the patient is actually getting in each session. To help solve this problem, we have designed a simple accelerometer-based sensor node that tracks movement repetitions and helps the clinician track the patients progress across sessions. We present results from calibration and statistical validation of this sensor node.