31,747 research outputs found
Membrane-based design and management methodology for parallel dynamically reconfigurable embedded systems
International audiencePartial and dynamic reconfiguration provides a relevant new dimension to design efficient parallel embedded systems. However, due to the encasing complexity of such systems, ensuring the consistency and parallelism management at runtime is still a key challenge. So architecture models and design methodology are required to allow for efficient component reuse and hardware reconfiguration management.This paper presents a distributed persistence management model and its implementation for reconfigurable multiprocessor systems on dynamically reconfigurable circuits. The proposed approach is inspired from the well-known component based models used in software applications development. Our model is based on membranes wrapping the systems components. The objective is to improve design productivity and ensure consistency by managing context switching and storage using modular distributed hardware controllers. These membranes are distributed and optimized with the aim to design self-adaptive systems by allowing dynamic changes in parallelism degree and contexts migration. Simulation and synthesis results are given to show performances and effectiveness of our methodology
System Support for Managing Invalid Bindings
Context-aware adaptation is a central aspect of pervasive computing
applications, enabling them to adapt and perform tasks based on contextual
information. One of the aspects of context-aware adaptation is reconfiguration
in which bindings are created between application component and remote services
in order to realize new behaviour in response to contextual information.
Various research efforts provide reconfiguration support and allow the
development of adaptive context-aware applications from high-level
specifications, but don't consider failure conditions that might arise during
execution of such applications, making bindings between application and remote
services invalid. To this end, we propose and implement our design approach to
reconfiguration to manage invalid bindings. The development and modification of
adaptive context-aware applications is a complex task, and an issue of an
invalidity of bindings further complicates development efforts. To reduce the
development efforts, our approach provides an application-transparent solution
where the issue of the invalidity of bindings is handled by our system,
Policy-Based Contextual Reconfiguration and Adaptation (PCRA), not by an
application developer. In this paper, we present and describe our approach to
managing invalid bindings and compare it with other approaches to this problem.
We also provide performance evaluation of our approach
MORPH: A Reference Architecture for Configuration and Behaviour Self-Adaptation
An architectural approach to self-adaptive systems involves runtime change of
system configuration (i.e., the system's components, their bindings and
operational parameters) and behaviour update (i.e., component orchestration).
Thus, dynamic reconfiguration and discrete event control theory are at the
heart of architectural adaptation. Although controlling configuration and
behaviour at runtime has been discussed and applied to architectural
adaptation, architectures for self-adaptive systems often compound these two
aspects reducing the potential for adaptability. In this paper we propose a
reference architecture that allows for coordinated yet transparent and
independent adaptation of system configuration and behaviour
A deliberative model for self-adaptation middleware using architectural dependency
A crucial prerequisite to externalized adaptation is an understanding of how components are interconnected, or more particularly how and why they depend on one another. Such dependencies can be used to provide an architectural model, which provides a reference point for externalized adaptation. In this paper, it is described how dependencies are used as a basis to systems' self-understanding and subsequent architectural reconfigurations. The approach is based on the combination of: instrumentation services, a dependency meta-model and a system controller. In particular, the latter uses self-healing repair rules (or conflict resolution strategies), based on extensible beliefs, desires and intention (EBDI) model, to reflect reconfiguration changes back to a target application under examination
Context-aware adaptation in DySCAS
DySCAS is a dynamically self-configuring middleware for automotive control systems. The addition of autonomic, context-aware dynamic configuration to automotive control systems brings a potential for a wide range of benefits in terms of robustness, flexibility, upgrading etc. However, the automotive systems represent a particularly challenging domain for the deployment of autonomics concepts, having a combination of real-time performance constraints, severe resource limitations, safety-critical aspects and cost pressures. For these reasons current systems are statically configured. This paper describes the dynamic run-time configuration aspects of DySCAS and focuses on the extent to which context-aware adaptation has been achieved in DySCAS, and the ways in which the various design and implementation challenges are met
ACME vs PDDL: support for dynamic reconfiguration of software architectures
On the one hand, ACME is a language designed in the late 90s as an
interchange format for software architectures. The need for recon guration at
runtime has led to extend the language with speci c support in Plastik. On the
other hand, PDDL is a predicative language for the description of planning
problems. It has been designed in the AI community for the International
Planning Competition of the ICAPS conferences. Several related works have
already proposed to encode software architectures into PDDL. Existing planning
algorithms can then be used in order to generate automatically a plan that
updates an architecture to another one, i.e., the program of a recon guration.
In this paper, we improve the encoding in PDDL. Noticeably we propose how to
encode ADL types and constraints in the PDDL representation. That way, we can
statically check our design and express PDDL constraints in order to ensure
that the generated plan never goes through any bad or inconsistent
architecture, not even temporarily.Comment: 6\`eme \'edition de la Conf\'erence Francophone sur les Architectures
Logicielles (CAL 2012), Montpellier : France (2012
CATS: linearizability and partition tolerance in scalable and self-organizing key-value stores
Distributed key-value stores provide scalable, fault-tolerant, and self-organizing
storage services, but fall short of guaranteeing linearizable consistency
in partially synchronous, lossy, partitionable, and dynamic networks, when data
is distributed and replicated automatically by the principle of consistent hashing.
This paper introduces consistent quorums as a solution for achieving atomic
consistency. We present the design and implementation of CATS, a distributed
key-value store which uses consistent quorums to guarantee linearizability and partition tolerance in such adverse and dynamic network conditions. CATS is
scalable, elastic, and self-organizing; key properties for modern cloud storage
middleware. Our system shows that consistency can be achieved with practical
performance and modest throughput overhead (5%) for read-intensive workloads
Achieving Robust Self-Management for Large-Scale Distributed Applications
Autonomic managers are the main architectural building blocks for constructing self-management capabilities of computing systems and applications. One of the major challenges in developing self-managing applications is robustness of management elements which form autonomic managers. We believe that transparent handling of the effects of resource churn (joins/leaves/failures) on management should be an essential feature of a platform for self-managing large-scale dynamic distributed applications, because it facilitates the development of robust autonomic managers and hence improves robustness of self-managing applications. This feature can be achieved by providing a robust management element abstraction that hides churn from the programmer.
In this paper, we present a generic approach to achieve robust services that is based on finite state machine replication with dynamic reconfiguration of replica sets. We contribute a decentralized algorithm that maintains the set of nodes hosting service replicas in the presence of churn. We use this approach to implement robust management elements as robust services that can operate despite of churn. Our proposed decentralized algorithm uses peer-to-peer replica placement schemes to automate replicated state machine migration in order to tolerate churn. Our algorithm exploits lookup and failure detection facilities of a structured overlay network for managing the set of active replicas. Using the proposed approach, we can achieve a long running and highly available service, without human intervention, in the presence of resource churn. In order to validate and evaluate our approach, we have implemented a prototype that includes the proposed algorithm
- …