416 research outputs found
Enforcing Architectural Styles in Presence of Unexpected Distributed Reconfigurations
Architectural Design Rewriting (ADR, for short) is a rule-based formal
framework for modelling the evolution of architectures of distributed systems.
Rules allow ADR graphs to be refined. After equipping ADR with a simple logic,
we equip rules with pre- and post-conditions; the former constraints the
applicability of the rules while the later specifies properties of the
resulting graphs. We give an algorithm to compute the weakest pre-condition out
of a rule and its post-condition. On top of this algorithm, we design a simple
methodology that allows us to select which rules can be applied at the
architectural level to reconfigure a system so to regain its architectural
style when it becomes compromised by unexpected run-time reconfigurations.Comment: In Proceedings ICE 2012, arXiv:1212.345
Constraint design rewriting
Constraint networks are hyper-graphs whose nodes and hyper-edges represent variables and relations between them, respectively.
The problem to assign values to variables by satisfying all constraints is NP-complete.
We propose an algebraic approach to the design and transformation of constraint networks, inspired by Architectural Design Rewriting (ADR). The main idea is to exploit ADR to equip constraint networks with some hierarchical structure and represent them as terms of a suitable algebra, when possible. Constraint network transformations such as constraint propagations are then specified with efficient rewrite rules exploiting the network's structure provided by terms.
The approach can be understood as (i) an extension of ADR with constraints, and (ii) an application of ADR to the design of reconfigurable constraint networks
Hierarchical Control for Self-adaptive IoT Systems: A Constraint Programming-Based Adaptation Approach
The self-adaptation control of Internet of Things (IoT) systems ought to tackle uncertainties in the dynamic environment (application level), as well as the dynamic computation infrastructure (architecture level). While the control of those two levels is generally separated, they should coordinate to guarantee functionality and quality. This paper proposes a conceptual model for the separation of concerns in controlling the environment and infrastructure events. The approach is applied on a real case: Melle-Longchamp area's smart power transmission network (in France). A hierarchical architecture with a control mechanism formalized with constraint programming (CP) is modeled. The control system assesses the reconfigurations that enhance the quality of service (QoS) while considering the internal and external limitations. The CP considers the desired environment control modes and assesses their feasibility by computing the response time and availability using a Netflow algorithm. The outcomes of this research supported design decisions and provided architectural reconfiguration solutions to the French Power Transmission Company (RTE)
Adaptability Checking in Multi-Level Complex Systems
A hierarchical model for multi-level adaptive systems is built on two basic
levels: a lower behavioural level B accounting for the actual behaviour of the
system and an upper structural level S describing the adaptation dynamics of
the system. The behavioural level is modelled as a state machine and the
structural level as a higher-order system whose states have associated logical
formulas (constraints) over observables of the behavioural level. S is used to
capture the global and stable features of B, by a defining set of allowed
behaviours. The adaptation semantics is such that the upper S level imposes
constraints on the lower B level, which has to adapt whenever it no longer can
satisfy them. In this context, we introduce weak and strong adaptabil- ity,
i.e. the ability of a system to adapt for some evolution paths or for all
possible evolutions, respectively. We provide a relational characterisation for
these two notions and we show that adaptability checking, i.e. deciding if a
system is weak or strong adaptable, can be reduced to a CTL model checking
problem. We apply the model and the theoretical results to the case study of
motion control of autonomous transport vehicles.Comment: 57 page, 10 figures, research papaer, submitte
Hierarchical Control for Self-adaptive IoT Systems A Constraint Programming-Based Adaptation Approach
International audienceThe self-adaptation control of Internet of Things (IoT) systems ought to tackle uncertainties in the dynamic environment (application level), as well as the dynamic computation infrastructure (architecture level). While the control of those two levels is generally separated, they should coordinate to guarantee functionality and quality. This paper proposes a conceptual model for the separation of concerns in controlling the environment and infrastructure events. The approach is applied on a real case: Melle-Longchamp area's smart power transmission network (in France). A hierarchical architecture with a control mechanism formalized with constraint programming (CP) is modeled. The control system assesses the reconfigurations that enhance the quality of service (QoS) while considering the internal and external limitations. The CP considers the desired application level control modes and assesses their feasibility by computing the response time and availability using a Netflow algorithm. The outcomes of this research supported design decisions and provided architectural reconfiguration solutions to the French Power Transmission Company (RTE)
Autonomous Architectural Assembly And Adaptation
An increasingly common solution for systems which are deployed in unpredictable
or dangerous environments is to provide the system with an autonomous or selfmanaging
capability. This capability permits the software of the system to adapt to
the environmental conditions encountered at runtime by deciding what changes
need to be made to the system’s behaviour in order to continue meeting the
requirements imposed by the designer. The chief advantage of this approach comes
from a reduced reliance on the brittle assumptions made at design time.
In this work, we describe mechanisms for adapting the software architecture of
a system using a declarative expression of the functional requirements (derived
from goals), structural constraints and preferences over the space of non-functional
properties possessed by the components of the system. The declarative approach
places this work in contrast to existing schemes which require more fine-grained,
often procedural, specifications of how to perform adaptations. Our algorithm for
assembling and re-assembling configurations chooses between solutions that meet
both the functional requirements and the structural constraints by comparing
the non-functional properties of the selected components against the designer’s
preferences between, for example, a high-performance or a highly reliable solution.
In addition to the centralised algorithm, we show how the approach can be applied
to a distributed system with no central or master node that is aware of the full
space of solutions. We use a gossip protocol as a mechanism by which peer nodes
can propose what they think the component configuration is (or should be). Gossip
ensures that the nodes will reach agreement on a solution, and will do so in a
logarithmic number of steps. This latter property ensures the approach can scale
to very large systems. Finally, the work is validated on a number of case studies
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
Operator interfaces for the lifecycle support of component based automation systems
Current manufacturing automation systems (specifically the powertrain sector)
have been facing challenges with constant pressures of globalisation,
environmental concerns and ICT (Information and Communication Technology)
innovations. These challenges instigate new demands for shorter product
lifecycles and require customised products to be manufactured as efficiently as
possible. Manufacturing systems must therefore be agile to remain competitive
by supporting frequent reconfigurations involving distributed engineering
activities. [Continues.
- …