A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> Abstract : Wireless sensor networks consist of collections of small, low-power nodes that interface or interact with the physical environment. The ability to add new functionality or perform software maintenance without having to physically reach each individual node is already an essential service, even at the limited scale at which current sensor networks are deployed. TinyOS supports single-hop over-the-air reprogramming today, but the need to reprogram sensors in a multi-hop network will become particularly critical as sensor networks mature and move toward larger deployment sizes. In this paper we present Multihop Over-the-Air Programming (MOAP), a code distribution mechanism specifically targeted for Mica-2 Motes. We discuss and analyze the design goals, constraints, choices and optimizations focusing in particular on dissemination strategies and retransmission policies. We have implemented MOAP on Mica-2 motes and we evaluate that implementation using both emulation and testbed experiments. We show that our dissemination mechanism obtains a 60-90% performance improvement in terms of required transmissions compared to flooding. We also show that a very simple windowed retransmission tracking scheme is nearly as effective as arbitrary repairs and yet is much better suited to energy and memory constrained embedded systems. <s> BIB001 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> To support network programming, we present Deluge, a reliable data dissemination protocol for propagating large data objects from one or more source nodes to many other nodes over a multihop, wireless sensor network. Deluge builds from prior work in density-aware, epidemic maintenance protocols. Using both a real-world deployment and simulation, we show that Deluge can reliably disseminate data to all nodes and characterize its overall performance. On Mica2-dot nodes, Deluge can push nearly 90 bytes/second, one-ninth the maximum transmission rate of the radio supported under TinyOS. Control messages are limited to 18% of all transmissions. At scale, the protocol exposes interesting propagation dynamics only hinted at by previous dissemination work. A simple model is also derived which describes the limits of data propagation in wireless networks. Finally, we argue that the rates obtained for dissemination are inherently lower than that for single path propagation. It appears very hard to significantly improve upon the rate obtained by Deluge and we identify establishing a tight lower bound as an open problem. <s> BIB002 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> Wireless sensor networks are composed of large numbers of tiny networked devices that communicate untethered. For large scale networks, it is important to be able to download code into the network dynamically. We present Contiki, a lightweight operating system with support for dynamic loading and replacement of individual programs and services. Contiki is built around an event-driven kernel but provides optional preemptive multithreading that can be applied to individual processes. We show that dynamic loading and unloading is feasible in a resource constrained environment, while keeping the base system lightweight and compact. <s> BIB003 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> Many sensor networking applications such as surveillance and environmental monitoring are time-sensitive in nature. To support such applications, we design and implement Nano-RK, a reservation-based real-time operating system (RTOS) with multi-hop networking support for use in wireless sensor networks. We support fixed-priority preemptive multitasking for guaranteeing that task deadlines are met, along with support for CPU and network bandwidth reservations. Tasks can specify their resource demands and the operating system provides timely, guaranteed and controlled access to CPU cycles and network packets in resource-constrained embedded sensor environments. We also introduce the concept of virtual energy reservations that allows the OS to enforce energy budgets associated with a sensing task by controlling resource accesses. A lightweight wireless networking stack supports packet forwarding, routing and TDMA-based network scheduling. Nano-RK has been implemented on the Atmel ATMEGA128 processor with the Chipcon CC2420 802.15.4 transceiver chip. Our results show that a light-weight embedded resource kernel with rich functionality and timing support is practical and constitutes a simple and alternative paradigm for supporting distributed sensing tasks <s> BIB004 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> We present TinyOS, a flexible, application-specific operating system for sensor networks, which form a core component of ambient intelligence systems. Sensor networks consist of (potentially) thousands of tiny, low-power nodes, each of which execute concurrent, reactive programs that must operate with severe memory and power constraints. The sensor network challenges of limited resources, event-centric concurrent applications, and low-power operation drive the design of TinyOS. Our solution combines flexible, fine-grain components with an execution model that supports complex yet safe concurrent operations. TinyOS meets these challenges well and has become the platform of choice for sensor network research; it is in use by over a hundred groups worldwide, and supports a broad range of applications and research topics. We provide a qualitative and quantitative evaluation of the system, showing that it supports complex, concurrent programs with very low memory requirements (many applications fit within 16KB of memory, and the core OS is 400 bytes) and efficient, low-power operation.We present our experiences with TinyOS as a platform for sensor network innovation and applications. <s> BIB005 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> This paper presents LiteOS, a multi-threaded operating system that provides Unix-like abstractions for wireless sensor networks. Aiming to be an easy-to-use platform, LiteOS offers a number of novel features, including: (1) a hierarchical file system and a wireless shell interface for user interaction using UNIX-like commands; (2) kernel support for dynamic loading and native execution of multithreaded applications; and (3) online debugging, dynamic memory, and file system assisted communication stacks. LiteOS also supports software updates through a separation between the kernel and user applications, which are bridged through a suite of system calls. Besides the features that have been implemented, we also describe our perspective on LiteOS as an enabling platform. We evaluate the platform experimentally by measuring the performance of common tasks, and demonstrate its programmability through twenty-one example applications. <s> BIB006 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> This paper presents a survey on the current state-of-the-art in Wireless Sensor Network (WSN) Operating Systems (OSs). In recent years, WSNs have received tremendous attention in the research community, with applications in battlefields, industrial process monitoring, home automation, and environmental monitoring, to name but a few. A WSN is a highly dynamic network because nodes die due to severe environmental conditions and battery power depletion. Furthermore, a WSN is composed of miniaturized motes equipped with scarce resources e.g., limited memory and computational abilities. WSNs invariably operate in an unattended mode and in many scenarios it is impossible to replace sensor motes after deployment, therefore a fundamental objective is to optimize the sensor motes’ life time. These characteristics of WSNs impose additional challenges on OS design for WSN, and consequently, OS design for WSN deviates from traditional OS design. The purpose of this survey is to highlight major concerns pertaining to OS design in WSNs and to point out strengths and weaknesses of contemporary OSs for WSNs, keeping in mind the requirements of emerging WSN applications. The state-of-the-art in operating systems for WSNs has been examined in terms of the OS Architecture, Programming Model, Scheduling, Memory Management and Protection, Communication Protocols, Resource Sharing, Support for Real-Time Applications, and additional features. These features are surveyed for both real-time and non-real-time WSN operating systems. <s> BIB007 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> Sensor network protocols exist to satisfy the communication needs of diverse applications, including data collection, event detection, target tracking and control. Network protocols to enable these services are constrained by the extreme resource scarcity of sensor nodes—including energy, computing, communications and storage—which must be carefully managed and multiplexed by the operating system. These challenges have led to new protocols and operating systems that are efficient in their energy consumption, careful in their computational needs and miserly in their memory footprints, all while discovering neighbours, forming networks, delivering data and correcting failures. <s> BIB008 </s> A Survey Report on Operating Systems for Tiny Networked Sensors <s> IV. ISSUES WITH OS FOR WSN <s> When first written in 2000, TinyOS's users were a handful of academic computer science researchers. A decade later, TinyOS averages 25,000 downloads a year, is in many commercial products, and remains a platform used for a great deal of sensor network, low-power systems, and wireless research. ::: ::: We focus on how technical and social decisions influenced this success, sometimes in surprising ways. As TinyOS matured, it evolved language extensions to help experts write efficient, robust systems. These extensions revealed insights and novel programming abstractions for embedded software. Using these abstractions, experts could build increasingly complex systems more easily than with other operating systems, making TinyOS the dominant choice. ::: ::: This success, however, came at a long-term cost. System design decisions that seem good at first can have unforeseen and undesirable implications that play out over the span of years. Today, TinyOS is a stable, self-contained ecosystem that is discouraging to new users. Other systems, such as Arduino and Contiki, by remaining more accessible, have emerged as better solutions for simpler embedded sensing applications. <s> BIB009
With the application needs the design of platforms used in WSN must address parameters like energy efficiency, delay, reliability, cost and scalability BIB008 . In paper BIB002 , the authors have classified the operation of WSN at two levels, which are at the node level and network level. A network level deals with the routing, communication channel, protocols, connectivity, and etc. Whereas, hardware, sensors, energy consumption, radio and central processing unit (CPU) is taken care at the node level. The concern here is efficient resource management and support for hetrogeneity and scalability. To the above said issues, research efforts in both hardware and software are required. Hardware typically includes lower cost while the software part includes network lifetime, middleware, robustness, scalability, reliability and security. To the best knowledge of the authors, there is no any single platform available which can address the variety of application requirements. In the following section, we present open design issues for OS, which are required for reliable performance of WSN based systems. We present issues, including parameter architecture, programming model, scheduling of process, memory protection and support for communication protocols. 1) Architecture : In  , the authors reported that the services provided by the OS can be influenced by the kernel's architecture which are (a) size of the core kernel and (b) runtime reconfigurability. In addition to this, an architecture is also responsible for adding services and updating the services to the kernel. Major architectures which are known and used in OSs are layered architecture, virtual machine architecture, monolithic architecture and the micro-kernel architecture BIB005 , BIB004 , BIB006 , BIB003 . A monolithic architecture does not have any specific structure therefore the services provided by the OS are taken separately or individually. This provides to integrate all services together into a single system image, thus this architecture has very small OS memory footprint. In microkernel architecture the size of the kernel is reduced because the functionality is provided in the kernel. This architecture has better reliability and ease of customizations. The major demerit of this architecture is the poor performance due to frequent user to kernel boundary switching. With the purpose of exporting OS to the user programs, virtual machine architecture is another choice for OS design. The advantage of this system is the portability facilities. Layered architecture has advantages like easy to manage, simple and reliable in performance but has the major drawback that this architecture is not so flexible. The design considerations for OS should include flexibility, less kernel size and future extension supports. Merits and demerits of different architecture used in OS design are listed in table II. 2) Programming Model: A better application programming interface (API) provides a way to have a clear understanding of separation between the application program and the low level node functionalities. An OS should have a clear set of APIs to interact with the developers. In addition to this, the OS API may include sensor data reading APIs, networking APIs, manupulation of memory APIs, management of power APIs and task manage- BIB004 . This helps in a optimized resource management. The role of a programming model supported by an OS has significant importance for applications. Mainly there are two programming models which are current state of arts for WSN OSs, multithreaded programming model and event driven programming model BIB007 . A programmer is comfortable with the multithreaded programme and is also used for many application development. But, this is not a good choice for resource constrained devices or networks. Whereas an event driven programming model is useful for computing devices where the role of a resource is critical. But, for traditional applications this has also limited choices. To overcome this researchers have worked and developed a light weight multithreading programming model for WSNs. Reprogramming of an OS is a kind of mandatory feature which can not be avoided. Dynamically updating the software is achieved using this feature only. As, the WSN involves inaccessible deployment, reprogramming of the platform is critical and to do this dissemination protocol is used to distribute the code BIB002 , BIB001 . For a successful reprogramming the code should be relocatable and can be run in any memory location. 3) Process Scheduling: To avoid race conditions, an efficient synchronization mechanism is needed in the OS. A flexible computational support aids in design of the flexible architecture of the OS. In the case of a priority application, scheduling of computational units is very much crucial. The sequence or order in which a task should be executed is another important concern while designing OS. A CPU is responsible for scheduling the tasks or processes. As a WSN is widely used in various applications including real time applications and non-real, the importance of an efficient scheduling is felt critical. Researchers are working on scheduling algorithms so that the OS can accommodate the requirements by application BIB009 . 4) Memory Protection and Memory Management: Memory protection refers to protect one process address space from another, so that there should not be any conflict in process execution. A WSN has very limited memory for operation. A better memory management can significantly improve the performance of the network. Therefore, the design for OS should have a good memory management scheme. Earlier OS designers for WSN assumed that only one application executes on a sensor node therefore memory protection mechanism is not required BIB007 . But in recent years' application requirement, it is desired to have the memory protection scheme BIB008 . 5) Support for Communication Protocol: Communication in the OS design context refers to the process in which a device can not only share data within the system itself but also with other nodes in the network. A WSN is distributed in nature and the nodes communicate with each other in the network. With the future prospects application demand, to support heterogeneity and interoperability features a communication protocol should be developed with the considerations of one system to all. Research efforts are needed to support the inter component communication which further helps in dynamic linking of the components BIB001 .