| dc.description.abstract | Reactive embedded systems, such as sensor nodes, or real-time control systems, are embedded into and interact with a physical environment for controlling and measuring purposes. When deployed in environments with changing requirements and unpredictable events, these systems need to adapt their software to maintain a desired level of functionality. As these systems are generally long lived, they need to provide means for allowing software adaptations such as introducing new, or improving old functionality. There are many static software adaptation techniques, but high reliability and durability constraints for reactive embedded systems make stopping and changing their structure or behaviour offline undesirable. Dynamic software reconfiguration is needed to allow such changes to happen while the system, or parts of the system, remain functional. Dynamic software reconfiguration provides mechanisms that enable software structure and behaviour changes at system run-time. Such reconfiguration occurs in conjunction with normal processes in a reactive, embedded system. However, this has the potential to cause conflict between two requirements: On the one hand, even while the software of a system is being reconfigured, it needs to react to many, typically unstructured, events, including physical events, user commands, and messages from other systems. As many of these systems operate in real-time, a response to these events needs to occur within time bounds. On the other hand, a reconfiguration may be required to react to current prevailing conditions and therefore it should complete as soon as possible to maintain acceptable quality of service. Transactional reconfiguration approaches complete the reconfiguration without consideration of the incoming events and their processing deadline. However, this might lead to a missed event deadline with implications for the system's overall timeliness. Preemptive reconfiguration approaches stop any reconfiguration activity and directly process an incoming event, which results in a timely computation of the event. However, this might delay a reconfiguration indefinitely if many incoming events occur consecutively. A reconfiguration model targeting reactive, embedded systems should fulfil two requirements: The model should meet the processing deadline of incoming events, while at the same time it should make progress towards a completion of the reconfiguration. The research question that emerges is what techniques are necessary to realise such a reconfiguration model. To address this question, this thesis introduces TimeAdapt, a time-adaptive reconfiguration model. Input to the model is the current software configuration, an event's processing deadline, and the remaining reconfiguration activities. Based on that input, the model determines how much of the reconfiguration can still be executed to reach a safe configuration within the given processing deadline. The core of the model is a partitioning of a reconfiguration process sequence into sub-sequences of reconfiguration tasks that are safe to be interrupted and sub-sequences that must be executed atomically to reach a valid safe intermediate system configuration. The reconfiguration model is defined for embedded software that follows the data-flow based computational model. This model was chosen as it is a well-defined mathematical model for concurrent computations and is general enough to describe distributed and local software architectures. The contributions of this thesis are two-fold. Firstly, the time-adaptive reconfiguration model enables the timely reaction to incoming events, while at the same time progress towards a reconfiguration completion is made. Secondly, a reconfiguration system is designed and implemented, which is a real-world implementation of the time-adaptive reconfiguration model. The system executes local reconfiguration s using time-bounded reconfiguration algorithms on components that follow the data-flow architecture. The reconfiguration system is implemented for a real embedded platform, Java SunSpots, and the reconfiguration algorithms are compared to transactional and preemptive reconfiguration approaches for an example application scenario. The evaluations show that our model has a higher percentage of met deadlines, while it leads to a faster completion of an ongoing reconfiguration. | |
