Gruia-Catalin Roman

LIME: a middleware for physical and logical mobility

LIME is a middleware supporting the development of applications that exhibit physical mobility of hosts, logical mobility of agents, or both. LIME adapts a coordination perspective inspired by work on the Linda model. The context for computation, represented in Linda by a globally accessible, persistent tuple space, is represented in LIME by transient sharing of the tuple spaces carried by each individual mobile unit. Linda tuple spaces are also extended with a notion of location and with the ability to react to a given state. The hypothesis underlying our work is that the resulting model provides a minimalist set of abstractions that enable rapid and dependable development of mobile applications. In this paper, we illustrate the model underlying LIME, present its current design and implementation, and discuss initial lessons learned in developing applications that involve physical mobility.

LIME: Linda meets mobility

LIME is a system designed to assist in the rapid development of dependable mobile applications over both wired and ad hoc networks. Mobile agents reside on mobile hosts and all communication takes place via transiently shared tuple spaces distributed across the mobile hosts. The decoupled style of computing characterizing the Linda model is extended to the mobile environment. At the application level, both agents and hosts perceive movement as a sudden change of context. The set of tuples accessible by a particular agent residing on a given host is altered transparently in response to changes in the connectivity pattern among the mobile hosts. In this paper we present the key design concepts behind the LIME system.

Rapid Development and Flexible Deployment of Adaptive Wireless Sensor Network Applications

Wireless sensor networks (WSNs) are difficult to program and usually run statically-installed software limiting its flexibility. To address this, we developed Agilla, a new middleware that increases network flexibility while simplifying application development. An Agilla network is deployed with no pre-installed application. Instead, users inject mobile agents that spread across nodes performing application-specific tasks. Each agent is autonomous, allowing multiple applications to share a network. Programming is simplified by allowing programmers to create agents using a high-level language. Linda-like tuple spaces are used for inter-agent communication and context discovery. This preserves each agents autonomy while providing a rich infrastructure for building complex applications, and marks the first time mobile agents and tuple spaces are used in a unified framework for WSNs. Our efforts resulted in an implementation for MICA2 motes and the development of several applications. The implementation consumes a mere 41.6KB of code and 3.59KB of data memory. An agent can migrate 5 hops in less than 1.1 seconds with 92% reliability. In this paper, we present Agilla and provide a detailed evaluation of its implementation, an empirical study of its overhead, and a case study demonstrating its use

LIME: A coordination model and middleware supporting mobility of hosts and agents

LIME (Linda in a mobile environment) is a model and middleware supporting the development of applications that exhibit the physical mobility of hosts, logical mobility of agents, or both. LIME adopts a coordination perspective inspired by work on the Linda model. The context for computation, represented in Linda by a globally accessible persistent tuple space, is refined in LIME to transient sharing of the identically named tuple spaces carried by individual mobile units. Tuple spaces are also extended with a notion of location and programs are given the ability to react to specified states. The resulting model provides a minimalist set of abstractions that facilitates the rapid and dependable development of mobile applications. In this article we illustrate the model underlying LIME, provide a formal semantic characterization for the operations it makes available to the application developer, present its current design and implementation, and discuss lessons learned in developing applications that involve physical mobility.

Mobile agent middleware for sensor networks: an application case study

Agilla is a mobile agent middleware that facilitates the rapid deployment of adaptive applications in wireless sensor networks (WSNs). Agilla allows users to create and inject special programs called mobile agents that coordinate through local tuple spaces, and migrate across the WSN performing application-specific tasks. This fluidity of code and state has the potential to transform a WSN into a shared, general-purpose computing platform capable of running several autonomous applications at a time, allowing us to harness its full potential. We have implemented and evaluated a fire tracking application to determine how well Agilla achieves its goals. Fire is modeled by agents that gradually spread throughout the network, engulfing nodes by inserting fire tuples into their local tuple spaces. Fire tracker agents are then used to form a perimeter around the fire. Using Agilla, we were able to rapidly create and deploy 47 byte fire agents, and 100 byte tracker agents on a WSN consisting of 26 MICA2 motes. Our experiments show that the tracker agents can form an 8-node perimeter around a burning node within 6.5 seconds and that it can adapt to a fire spreading at a rate of 7 seconds per hop. We also present the lessons learned about the adequacy of Agillas primitives, and regarding the efficiency, reliability, and adaptivity of mobile agents in a WSN.

Reliable clinical monitoring using wireless sensor networks: experiences in a step-down hospital unit

This paper presents the design, deployment, and empirical study of a wireless clinical monitoring system that collects pulse and oxygen saturation readings from patients. The primary contribution of this paper is an in-depth clinical trial that assesses the feasibility of wireless sensor networks for patient monitoring in general hospital units. We present a detailed analysis of the system reliability from a long term hospital deployment over seven months involving 41 patients in a step-down cardiology unit. The network achieved high reliability (median 99.68%, range 95.21% -- 100%). The overall reliability of the system was dominated by sensing reliability of the pulse oximeters (median 80.85%, range 0.46% -- 97.69%). Sensing failures usually occurred in short bursts, although longer periods were also present due to sensor disconnections. We show that the sensing reliability could be significantly improved through oversampling and by implementing a disconnection alarm system that incurs minimal intervention cost. A retrospective data analysis indicated that the system provided sufficient temporal resolution to support the detection of clinical deterioration in three patients who suffered from significant clinical events including transfer to Intensive Care Units. These results indicate the feasibility and promise of using wireless sensor networks for continuous patient monitoring and clinical deterioration detection in general hospital units.

Software engineering for mobility: a roadmap

The term distributed computing conjures the image of a fixed network structure whose nodes support the execution of processes that communicate with each other via messages traveling along links. Peer-to-peer communication is feasible but client-server relationships dominate. More recently, servers have been augmented with brokerage capabilities to facilitate discovery of available services. Stability is the ideal mode of operation; changes are relatively slow; even in the case of failure, nodes and links are expected eventually to come back up. By contrast, mobility represents a total meltdown of all the stability assumptions (explicit or implicit) associated with distributed computing. The network structure is no longer fixed, nodes may come and go, processes may move among nodes, and even programs (the code executed by processes) may evolve and change structure. The challenges and opportunities associated with this computational melee form the main subject of this paper. We seek to sort out this chaotic form of computing by focusing our attention on the formulation of a simple framework for viewing mobility, on precise definition of terms, and on research issues mobility poses for the software engineering community.

Agilla: A mobile agent middleware for self-adaptive wireless sensor networks

This article presents Agilla, a mobile agent middleware designed to support self-adaptive applications in wireless sensor networks. Agilla provides a programming model in which applications consist of evolving communities of agents that share a wireless sensor network. Coordination among the agents and access to physical resources are supported by a tuple space abstraction. Agents can dynamically enter and exit a network and can autonomously clone and migrate themselves in response to environmental changes. Agillas ability to support self-adaptive applications in wireless sensor networks has been demonstrated in the context of several applications, including fire detection and tracking, monitoring cargo containers, and robot navigation. Agilla, the first mobile agent system to operate in resource-constrained wireless sensor platforms, was implemented on top of TinyOS. Agillas feasibility and efficiency was demonstrated by experimental evaluation on two physical testbeds consisting of Mica2 and TelosB nodes.

EgoSpaces: facilitating rapid development of context-aware mobile applications

Todays mobile applications require constant adaptation to their changing environments, or contexts. Technological advances have increased the pervasiveness of mobile computing devices such as laptops, handhelds, and embedded sensors. The sheer amount of context information available for adaptation places a heightened burden on application developers as they must manage and utilize vast amounts of data from diverse sources. Facilitating programming in this data-rich environment requires a middleware that provides context information to applications in an abstract form. In this paper, we demonstrate the feasibility of such a middleware that allows programmers to focus on high-level interactions among programs and to employ declarative abstract context specifications in settings that exhibit transient interactions with opportunistically encountered components. We also discuss the novel context-aware abstractions the middleware provides and the programming knowledge necessary to write applications using it. Finally, we provide examples demonstrating the infrastructures ability to support differing tasks from a wide variety of application domains

A taxonomy of program visualization systems

A taxonomy of program visualization systems that is based on a model of program visualization that maps programs to graphical representations is presented. The taxonomy is illustrated with three program visualization systems representative of research trends: Zeus, Tango, and Pavane.<<ETX>>