Persistent storage offers multiple advantages for sensor networks, yet the available storage systems have been unwieldy because of their complexity and device-specific designs. We present the Coffee file system for flashbased sensor devices. Coffee provides a programming interface for building efficient and portable storage abstractions. Unlike previous flash file systems, Coffee uses a small and constant RAM footprint per file, making it scale elegantly with workloads consisting of large files or many files. In addition, the performance overhead of Coffee is low: the throughput is at least 92 % of the achievable direct flash driver throughput. We show that network layer components such as routing tables and packet queues can be implemented on top of Coffee, leading to increased performance and reduced memory requirements for routing and transport protocols.

Abstract. Many applications operate in heterogeneous wireless sensor networks, which represent a challenging programming environment due to the wide range of device capabilities. Servilla addresses this difficulty in developing applications by offering a new middleware framework based on service provisioning. Using Servilla, developers can construct platform-independent applications over a dynamic and diverse set of devices. A salient feature of Servilla is its support for the discovery and binding to local and remote services, which enables flexible and energy-efficient in-network collaboration among heterogeneous devices. Furthermore, Servilla provides a modular middleware architecture that can be easily tailored to devices with a wide range of resources, allowing resource-constrained devices to provide services while leveraging the capabilities of more powerful devices. Servilla has been implemented on TinyOS for two representative hardware platforms (Imote2 and TelosB) with drastically different resources. Microbenchmarks demonstrate the efficiency of Servilla’s implementation, while an application case study on structural health monitoring demonstrates the efficacy of its coordination model for integrating heterogeneous devices. 1

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. Agilla’s 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. Agilla’s feasibility and efficiency was demonstrated by experimental evaluation on two physical testbeds consisting of Mica2 and TelosB nodes.

Computer Science Sensor networks are being deployed at massive scales, containing a range of sensors and underlying computing platforms. Programming paradigms for sensor networks should meet the attendant challenges of scale and heterogeneity. Furthermore, with sensor networks expected to be deployed for long periods of time, the ability to reprogram them remotely is necessary in order to provide new services, fix bugs, and enhance applications and system software. The operating system and whole system reprogramming approach in use today will have limited use in the future, given the envisioned scales of sensor network deployments. In order to address this challenge, researchers have treated virtual machines as system software. However, to satisfy the resource limitations of sensor nodes, they usually export only a minimal set of services to the application programmer. This makes applications of even moderate complexity difficult to implement. In this dissertation, methods to implement virtual machines that scale and export com-prehensive service-suites on a per-application basis are presented. The use of fine-grained software synthesis and scaling to build resource-efficient system software is advocated, and a new incre-mental linking technique to reduce the cost of application evolution to facilitate both application

Abstract—Image processing applications introduce new challenges to the design of sensor network systems via non-trivial in-network computation. As embedded processing becomes more complex, in-situ reconfiguration is seen as the key enabling technology to maintain and manage such systems. In dynamic event-driven heterogeneous sensor networks, reconfiguration also encompasses autonomous re-partitioning of applications across multiple tiers to provide a low-power responsive system by efficiently coping with variations in run-time resource usage and availability. Hence, we aim to provide an efficient lowpower macro-programming environment that supports multidimensional software reconfiguration of heterogeneous imaging networks. Working towards this initiative, we present the ViRe framework for mote-class devices based on data-centric application composition and execution. Applications, modeled as dataflow graphs, are composed from a library of pre-defined and reusable image processing elements. Concise scripts capture the wiring information and are used to install applications in the network, while execution on the nodes is performed via processor native code to minimize overhead. A lean run-time engine tightly monitors application execution to provide an efficient, robust and scalable support for complex reconfigurable embedded image processing. Thus, the system is able to lower application repartitioning overhead and minimize loss of work during software reconfiguration.

With sensor networks starting to get mainstream acceptance, programmability is of increasing importance. Customers and field engineers will need to reprogram existing deployments and software developers will need to test and debug software in network testbeds. Script languages, which are a popular mechanism for reprogramming in general-purpose computing, have not been considered for wireless sensor networks because of the perceived overhead of interpreting a script language on tiny sensor nodes. In this paper we show that a structured script language is both feasible and efficient for programming tiny sensor nodes. We present a structured script language, SCript, and develop an interpreter for the language. To reduce program distribution energy the SCript interpreter stores a tokenized representation of the scripts which is distributed through the wireless network. The ROM and RAM footprint of the interpreter is similar to that of existing virtual machines for sensor networks. We show that the interpretation overhead of our language is on par with that of existing virtual machines. Thus script languages, previously considered as too expensive for tiny sensor nodes, are a viable alternative to virtual machines. 1

Nucleos is a new runtime system for ultra-lightweight embedded systems. Central to Nucleos is a dispatcher based on the concept of recursive threaded code, which enables layers of abstraction from the runtime system and interrupt handlers to application tasks to be composed in a structured, powerful way, all with minimal program code. When used in conjunction with models of computation with behavioral transparency such as synchronous dataflow (SDF), Nucleos can support efficient memory allocation policies for multiple communicating actors with minimal runtime overhead. This recursive structure also lends itself to in-field code update and dynamic execution. Nucleos’s low runtime overhead and low RAM/ROM requirements enable it to run on compact platforms previously unsupported by the most popular sensor OSes while still providing high flexibility and composability. In some cases, applications running on Nucleos actually outperform hand-crafted code running without an OS, thanks to non-obvious memory optimizations enabled by the SDF model of computation.

Abstract not found

Wireless sensor networks have been traditionally designed to be privately owned and used. Hence the two hallmark features of sensor networks, namely customized network applications and the collaborative in-network processing, are not achievable beyond the boundary of the users ' administrative domains (except for limited scope data sharing through Internet gateways). This position paper advocates a contrarian notion of sensor grid that preserves the operational continuity of the participating sensornets and yet allows controlled sharing of sensor node hardware capabilities over multiple administrative domains. This is achieved by stitching together virtualized nodes donated by participating sensornets into a transient virtual sensornet underlay, which is called a Community Sensor Grid. Possible approaches for node virtualization support are discussed for some existing sensornet OS platforms. The formation, operation and dissolution of the transient underlay are to be supported by a P2P overlay formed by the Internet gateways of participating sensornets. Categories and Subject Descriptors C.2.1 [Computer-Communication Networks]: Network Architecture and Design—packet-switching networks, store and

journal homepage: www.elsevier.com/locate/scico Servilla: A flexible service provisioning middleware for heterogeneous