9,687 research outputs found
A Reputation-Based Approach to Self-Adaptive Service Selection
Service-orientation provides concepts and tools for flexible composition and management of largescale distributed software applications. The automated run-time management of such loosely coupled software systems, however, poses still major challenges and is therefore an active research area, including the use of novel computing paradigms. In this context, the dynamic and adaptive selection of best possible service providers is an important task, which can be addressed by an appropriate middleware layer that allows considering different service quality aspects when managing the adaptive execution of distributed service workflows dynamically. In such an approach, service consumers are enabled to delegate the adaptive selection of service providers at run-time to the execution infrastructure. The selection criteria used are based on the cost of a service provision and the continuous, dynamic evaluation of reputations of providers, i.e. maintained track records of meeting the respective service commitments. This paper discusses the design and operating principle of such an automatic service selection middleware extension. Its ability to balance different quality criteria for service selection, such as service cost vs. the reliability of provision, is empirically evaluated based on a multi-agent platform approach
Towards Adaptable and Adaptive Policy-Free Middleware
We believe that to fully support adaptive distributed applications,
middleware must itself be adaptable, adaptive and policy-free. In this paper we
present a new language-independent adaptable and adaptive policy framework
suitable for integration in a wide variety of middleware systems. This
framework facilitates the construction of adaptive distributed applications.
The framework addresses adaptability through its ability to represent a wide
range of specific middleware policies. Adaptiveness is supported by a rich
contextual model, through which an application programmer may control precisely
how policies should be selected for any particular interaction with the
middleware. A contextual pattern mechanism facilitates the succinct expression
of both coarse- and fine-grain policy contexts. Policies may be specified and
altered dynamically, and may themselves take account of dynamic conditions. The
framework contains no hard-wired policies; instead, all policies can be
configured.Comment: Submitted to Dependable and Adaptive Distributed Systems Track, ACM
SAC 200
Separating Agent-Functioning and Inter-Agent Coordination by Activated Modules: The DECOMAS Architecture
The embedding of self-organizing inter-agent processes in distributed
software applications enables the decentralized coordination system elements,
solely based on concerted, localized interactions. The separation and
encapsulation of the activities that are conceptually related to the
coordination, is a crucial concern for systematic development practices in
order to prepare the reuse and systematic integration of coordination processes
in software systems. Here, we discuss a programming model that is based on the
externalization of processes prescriptions and their embedding in Multi-Agent
Systems (MAS). One fundamental design concern for a corresponding execution
middleware is the minimal-invasive augmentation of the activities that affect
coordination. This design challenge is approached by the activation of agent
modules. Modules are converted to software elements that reason about and
modify their host agent. We discuss and formalize this extension within the
context of a generic coordination architecture and exemplify the proposed
programming model with the decentralized management of (web) service
infrastructures
The Simulation Model Partitioning Problem: an Adaptive Solution Based on Self-Clustering (Extended Version)
This paper is about partitioning in parallel and distributed simulation. That
means decomposing the simulation model into a numberof components and to
properly allocate them on the execution units. An adaptive solution based on
self-clustering, that considers both communication reduction and computational
load-balancing, is proposed. The implementation of the proposed mechanism is
tested using a simulation model that is challenging both in terms of structure
and dynamicity. Various configurations of the simulation model and the
execution environment have been considered. The obtained performance results
are analyzed using a reference cost model. The results demonstrate that the
proposed approach is promising and that it can reduce the simulation execution
time in both parallel and distributed architectures
Adaptive online deployment for resource constrained mobile smart clients
Nowadays mobile devices are more and more used as a platform for applications. Contrary to prior generation handheld devices configured with a predefined set of applications, today leading edge devices provide a platform for flexible and customized application deployment. However, these applications have to deal with the limitations (e.g. CPU speed, memory) of these mobile devices and thus cannot handle complex tasks. In order to cope with the handheld limitations and the ever changing device context (e.g. network connections, remaining battery time, etc.) we present a middleware solution that dynamically offloads parts of the software to the most appropriate server. Without a priori knowledge of the application, the optimal deployment is calculated, that lowers the cpu usage at the mobile client, whilst keeping the used bandwidth minimal. The information needed to calculate this optimum is gathered on the fly from runtime information. Experimental results show that the proposed solution enables effective execution of complex applications in a constrained environment. Moreover, we demonstrate that the overhead from the middleware components is below 2%
LUNES: Agent-based Simulation of P2P Systems (Extended Version)
We present LUNES, an agent-based Large Unstructured NEtwork Simulator, which
allows to simulate complex networks composed of a high number of nodes. LUNES
is modular, since it splits the three phases of network topology creation,
protocol simulation and performance evaluation. This permits to easily
integrate external software tools into the main software architecture. The
simulation of the interaction protocols among network nodes is performed via a
simulation middleware that supports both the sequential and the
parallel/distributed simulation approaches. In the latter case, a specific
mechanism for the communication overhead-reduction is used; this guarantees
high levels of performance and scalability. To demonstrate the efficiency of
LUNES, we test the simulator with gossip protocols executed on top of networks
(representing peer-to-peer overlays), generated with different topologies.
Results demonstrate the effectiveness of the proposed approach.Comment: Proceedings of the International Workshop on Modeling and Simulation
of Peer-to-Peer Architectures and Systems (MOSPAS 2011). As part of the 2011
International Conference on High Performance Computing and Simulation (HPCS
2011
A Case Study on Formal Verification of Self-Adaptive Behaviors in a Decentralized System
Self-adaptation is a promising approach to manage the complexity of modern
software systems. A self-adaptive system is able to adapt autonomously to
internal dynamics and changing conditions in the environment to achieve
particular quality goals. Our particular interest is in decentralized
self-adaptive systems, in which central control of adaptation is not an option.
One important challenge in self-adaptive systems, in particular those with
decentralized control of adaptation, is to provide guarantees about the
intended runtime qualities. In this paper, we present a case study in which we
use model checking to verify behavioral properties of a decentralized
self-adaptive system. Concretely, we contribute with a formalized architecture
model of a decentralized traffic monitoring system and prove a number of
self-adaptation properties for flexibility and robustness. To model the main
processes in the system we use timed automata, and for the specification of the
required properties we use timed computation tree logic. We use the Uppaal tool
to specify the system and verify the flexibility and robustness properties.Comment: In Proceedings FOCLASA 2012, arXiv:1208.432
- …