Improving the performance of trickle-based data dissemination in low-power networks

Trickle is a polite gossip algorithm for managing communication traffic. It is of particular interest in low-power wireless networks for reducing the amount of control traffic, as in routing protocols (RPL), or reducing network congestion, as in multicast protocols (MPL). Trickle is used at the network or application level, and relies on up-to-date information on the activity of neighbors. This makes it vulnerable to interference from the media access control layer, which we explore in this paper. We present several scenarios how the MAC layer in low-power radios violates Trickle timing. As a case study, we analyze the impact of CSMA/CA with ContikiMAC on Trickle's performance. Additionally, we propose a solution called Cleansing that resolves these issues

Extending RTA/Linux with fixed-priority scheduling with deferred preemption

Fixed-Priority Scheduling with Deferred Preemption (FPDS) is a middle ground between Fixed-Priority Pre-emptive Scheduling and Fixed-Priority Non-preemptive Scheduling, and offers advantages with respect to context switch overhead and resource access control. In this paper we present our work on extending the real-time operating system RTAI/Linux with support for FPDS. We give an overview of possible alternatives, describe our design choices and implementation, and verify through a series of measurements that indicate that a FPDS implementation in a real-world RTOS is feasible with minimal overhead

Extending a HSF-enabled open-source real-time operating system with resource sharing

Hierarchical scheduling frameworks (HSFs) provide means for composing complex real-time systems from well-defined, independently analyzed subsystems. To support resource sharing within two-level, fixed priority scheduled HSFs, two synchronization protocols based on the stack resource policy (SRP) have recently been presented, i.e. HSRP [1] and SIRAP [2]. This paper describes an implementation to provide such HSFs with SRP-based synchronization protocols. We base our implementations on the commercially available real-time operating system µC/OS-II, extended with proprietary support for periodic tasks, idling periodic servers and two-level fixed priority preemptive scheduling. Specifically, we show the implementation of SRP as a local synchronization protocol, and present the implementation of both HSRP and SIRAP. Moreover, we investigate the system overhead induced by the synchronization primitives of each protocol. Our aim is that these protocols can be used side-by-side within the same HSF, so that their primitives can be selected based on the protocol’s relative strengths

Extending a HSF-enabled open-source real-time operating system with resource sharing

Hierarchical scheduling frameworks (HSFs) provide means for composing complex real-time systems from well-defined, independently analyzed subsystems. To support resource sharing within two-level, fixed priority scheduled HSFs, two synchronization protocols based on the stack resource policy (SRP) have recently been presented, i.e. HSRP [1] and SIRAP [2]. This paper describes an implementation to provide such HSFs with SRP-based synchronization protocols. We base our implementations on the commercially available real-time operating system µC/OS-II, extended with proprietary support for periodic tasks, idling periodic servers and two-level fixed priority preemptive scheduling. Specifically, we show the implementation of SRP as a local synchronization protocol, and present the implementation of both HSRP and SIRAP. Moreover, we investigate the system overhead induced by the synchronization primitives of each protocol. Our aim is that these protocols can be used side-by-side within the same HSF, so that their primitives can be selected based on the protocol’s relative strengths

Opaque analysis for resource sharing in compositional real-time systems

In this paper we propose opaque analysis methods to integrate dependent real-time components into hierarchical fixed-priority scheduled systems. To arbitrate mutually exclusive resource access between components, we consider two existing protocols: HSRP - comprising overrun with and without payback - and SIRAP. An opaque analysis allows to postpone the choice of a synchronization protocol until component integration time. First, we identify the sources of pessimism in the existing analysis techniques and we conclude that both protocols assume different models in their local analysis. In particular, the compositional analysis for overrun with payback (OWP) is not opaque and is pessimistic. The latter makes OWP expensive compared to its counter part without a payback mechanism (ONP). This paper presents an opaque and less pessimistic OWP analysis. Secondly, SIRAP requires more timing information to perform a task-level schedulability analysis. In many practical situations, however, detailed timing characteristics of tasks are hard to obtain. We introduce an opaque analysis for SIRAP using the analysis of ONP to reduce the required timing information during the local analysis. We show that the analysis for ONP cannot deem systems schedulable which are infeasible with SIRAP. The SIRAP analysis may therefore reduce the required system resources of a component by sacrificing the choice for an arbitrary synchronization protocol at system integration time

Opaque analysis for resource-sharing components in hierarchical real-time systems : extended version

A real-time component may be developed under the assumption that it has the entire platform at its disposal. Composing a real-time system from independently developed components may require resource sharing between components. We propose opaque analysis methods to integrate resource-sharing components into hierarchically scheduled systems. Resource sharing imposes blocking times within an individual component and between components. An opaque local analysis ignores global blocking between components and allows to analyse an individual component while assuming that shared resources are exclusively available for a component. To arbitrate mutually exclusive resource access between components, we consider four existing protocols: SIRAP, BROE and HSRP - comprising overrun with payback (OWP) and overrun without payback (ONP). We classify local analyses for each synchronization protocol based on the notion of opacity and we develop new analysis for those protocols that are non-opaque. Finally, we compare SIRAP, ONP, OWP and BROE by means of an extensive simulation study. From the results, we derive guidelines for selecting a global synchronization protocol

Steady-State Properties of Single-File Systems with Conversion

We have used Monte-Carlo methods and analytical techniques to investigate the influence of the characteristic parameters, such as pipe length, diffusion, adsorption, desorption and reaction rate constants on the steady-state properties of Single-File Systems with a reaction. We looked at cases when all the sites are reactive and when only some of them are reactive. Comparisons between Mean-Field predictions and Monte-Carlo simulations for the occupancy profiles and reactivity are made. Substantial differences between Mean-Field and the simulations are found when rates of diffusion are high. Mean-Field results only include Single-File behavior by changing the diffusion rate constant, but it effectively allows passing of particles. Reactivity converges to a limit value if more reactive sites are added: sites in the middle of the system have little or no effect on the kinetics. Occupancy profiles show approximately exponential behavior from the ends to the middle of the system.Comment: 15 pages, 20 figure

Uniform Interfaces for Resource-Sharing Components in Hierarchically Scheduled Real-Time Systems

In literature, several hierarchical scheduling frameworks (HSFs) have been proposed for enabling resource sharing between components on a uni-processor system. Each HSF comes with its own set of composition rules which take into account a specific synchronization protocol for arbitrating access to resources. However, the inventors of these synchronization protocols have also chosen to describe these composition rules with the help of protocol-specific component interfaces. This creates unnecessary framework dependencies on components