How To Touch a Running System

The increasing importance of distributed and decentralized software
architectures entails more and more attention for adaptive
software. Obtaining adaptiveness, however, is a difficult task as
the software design needs to foresee and cope with a variety of
situations. Using reconfiguration of components facilitates this
task, as the adaptivity is conducted on an architecture level
instead of directly in the code. This results in a separation of
concerns; the appropriate reconfiguration can be devised on a
coarse level, while the implementation of the components can remain
largely unaware of reconfiguration scenarios. We study
reconfiguration in component frameworks based on formal theory. We
first discuss programming with components, exemplified with the
development of the cmc model checker. This highly efficient model
checker is made of C++ components and serves as an example for
component-based software development practice in general, and also
provides insights into the principles of adaptivity. However, the
component model focuses on high performance and is not geared
towards using the structuring principle of components for
controlled reconfiguration. We thus complement this highly
optimized model by a message passing-based component model which
takes reconfigurability to be its central principle. Supporting
reconfiguration in a framework is about alleviating the programmer
from caring about the peculiarities as much as possible. We utilize
the formal description of the component model to provide an
algorithm for reconfiguration that retains as much flexibility as
possible, while avoiding most problems that arise due to
concurrency. This algorithm is embedded in a general four-stage
adaptivity model inspired by physical control loops. The
reconfiguration is devised to work with stateful components,
retaining their data and unprocessed messages. Reconfiguration
plans, which are provided with a formal semantics, form the input
of the reconfiguration algorithm. We show that the algorithm
achieves perceived atomicity of the reconfiguration process for an
important class of plans, i.e., the whole process of
reconfiguration is perceived as one atomic step, while minimizing
the use of blocking of components. We illustrate the applicability
of our approach to reconfiguration by providing several examples
like fault-tolerance and automated resource control.