631 research outputs found
Programming distributed and adaptable autonomous components--the GCM/ProActive framework
International audienceComponent-oriented software has become a useful tool to build larger and more complex systems by describing the application in terms of encapsulated, loosely coupled entities called components. At the same time, asynchronous programming patterns allow for the development of efficient distributed applications. While several component models and frameworks have been proposed, most of them tightly integrate the component model with the middleware they run upon. This intertwining is generally implicit and not discussed, leading to entangled, hard to maintain code. This article describes our efforts in the development of the GCM/ProActive framework for providing distributed and adaptable autonomous components. GCM/ProActive integrates a component model designed for execution on large-scale environments, with a programming model based on active objects allowing a high degree of distribution and concurrency. This new integrated model provides a more powerful development, composition, and execution environment than other distributed component frameworks. We illustrate that GCM/ProActive is particularly adapted to the programming of autonomic component systems, and to the integration into a service-oriented environment
Advanced Grid programming with components: a biometric identification case study
Component-oriented software development has been attracting increasing attention for building complex distributed applications. A new infrastructure supporting this advanced concept is our prototype component framework based on the Grid component model. This paper provides an overview of the component framework and presents a case study where we utilise the component-oriented approach to develop a business process application for a biometric identification system. We then introduce the tools being developed as part of an integrated development environment to enable graphical component-based development of Grid applications. Finally, we report our initial findings and experiences of efficiently using the component framework and set of software tools
An asynchronous distributed component model and its semantics
This paper is placed in the context of large scale distributed programming, providing a programming model based on asynchronous components. It focuses on the semantics of asynchronous invocations and component synchronisation. Our model is precise enough to enable the specification of a formal semantics. A variant of this model has been implemented, together with tools for managing components.
This paper explains why we consider that our component model is efficient and provides a convenient programming model. We show how futures play a major role for such asynchronous components, and provide a reduction semantics for the component model. This reduction semantics has been specified in the Isabelle theorem prover, and will be used to prove properties on the component model and its implementations
Behavioural Models for Distributed Fractal Components
This paper presents a formal behavioural specification framework together with its applications in different contexts for specifying and verifying the correct behaviour of distributed Fractal components. Our framework allows us to build behavioural models for applications ranging from sequential Fractal components, to distributed objects, and finally distributed components. Our models are able to characterise both functional and non-functional behaviours, and the interaction between the two concerns. Finally, this work has resulted in the development of tools allowing the non-expert programmer to specify the behaviour of his components, and automatically, or semi-automatically verify properties of his application
Management of service composition based on self-controlled components
International audienceCloud computing and Future Internet promise a new ecosystem where everything is "as a service", reachable and connectable anywhere and anytime, everyone succeeding to get a service composition that meets his needs. But do we have the structure and the appropriate properties to design the service components and do we have the means to manage, at run-time, the personalised compositions corresponding to Service Level Agreement? In this article we introduce an entity of service composition called Self-Controlled Component (SCC), including, since the design step, functional and non-functional specifications. SCCs benefit both from the strong structure, explicit composition, and autonomic management of component-oriented programming, from the highly dynamic composition, and from the discovery capacities of service-oriented computing. Self-control mechanisms are then attached automatically to SCCs to enable autonomic application management during execution. The objective of this new concept is to provide strong Quality of Service (QoS) guarantees of composed applications. We illustrate the approach using an example called Springoo, to how in the context of a legacy application the contributions and benefits of our solution. For the management of the service composition we propose the concept of Virtual Private Service Network (VPSN) and Virtual Service Community (VSC) that allows us to model the personalised Service Level Agreement (SLA) where user requirements and provider offers converge on a QoS contract
Tools and Models for High Level Parallel and Grid Programming
When algorithmic skeletons were first introduced by Cole in late 1980 the
idea had an almost immediate success. The skeletal approach has been proved to
be effective when application algorithms can be expressed in terms of skeletons
composition. However, despite both their effectiveness and the progress made in
skeletal systems design and implementation, algorithmic skeletons remain absent
from mainstream practice. Cole and other researchers, focused the problem. They
recognized the issues affecting skeletal systems and stated a set of principles
that have to be tackled in order to make them more effective and to take
skeletal programming into the parallel mainstream. In this thesis we propose
tools and models for addressing some among the skeletal programming
environments issues. We describe three novel approaches aimed at enhancing
skeletons based systems from different angles. First, we present a model we
conceived that allows algorithmic skeletons customization exploiting the macro
data-flow abstraction. Then we present two results about the exploitation of
meta-programming techniques for the run-time generation and optimization of
macro data-flow graphs. In particular, we show how to generate and how to
optimize macro data-flow graphs accordingly both to programmers provided
non-functional requirements and to execution platform features. The last result
we present are the Behavioural Skeletons, an approach aimed at addressing the
limitations of skeletal programming environments when used for the development
of component-based Grid applications. We validated all the approaches
conducting several test, performed exploiting a set of tools we developed.Comment: PhD Thesis, 2008, IMT Institute for Advanced Studies, Lucca. arXiv
admin note: text overlap with arXiv:1002.2722 by other author
Unifying Architectural and Behavioural Specifications of Distributed Components
International audienceWe present a novel specification language called JDC to be used at design phase of distributed components. The extensive seek for asynchrony in distributed components demands new techniques for its specification that have not been addressed before. We propose to focus the specification on its data-flow; this allows to reason about inter-component synchronisations produced by a data-driven synchronisation model. The language is endowed with enough formality so it allows a constructive approach; it allows the generation of behaviour models which can be model-checked, and the generation of code skeletons with the control flow of components. Globally, this approach aims at generating components with strong guarantees w.r.t. their behaviour
Integrating formal reasoning into component-based approach to reconfigurable distributed systems
Distributed computing is becoming ubiquitous in recent years in many areas, especially the
scientific and industrial ones, where the processing power - even that of supercomputers - never
seems to be enough. Grid systems were born out of necessity, and had to grow quickly to
meet requirements which evolved over time, becoming today’s complex systems. Even the
simplest distributed system nowadays is expected to have some basic functionalities, such as
resources and execution management, security and optimization features, data control, etc. The
complexity of Grid applications is also accentuated by their distributed nature, making them
some of the most elaborate systems to date. It is often too easy that these intricate systems
happen to fall in some kind of failure, it being a software bug, or plain simple human error; and
if such a failure occurs, it is not always the case that the system can recover from it, possibly
meaning hours of wasted computational power.
In this thesis, some of the problems which are at the core of the development and mainte-
nance of Grid software applications are addressed by introducing novel and solid approaches
to their solution. The difficulty of Grid systems to deal with unforeseen and unexpected cir-
cumstances resulting from dynamic reconfiguration can be identified. Such problems are often
related to the fact that Grid applications are large, distributed and prone to resource failures.
This research has produced a methodology for the solution of this problem by analysing the
structure of distributed systems and their reliance on the environment which they sit upon, often
overlooked when dealing with these types of scenarios. It is concluded that the way that Grid applications interact with the infrastructure is not sufficiently addressed and a novel approach
is developed in which formal verification methods are integrated with distributed applications
development and deployment in a way that includes the environment. This approach allows for
reconfiguration scenarios in distributed applications to proceed in a safe and controlled way, as
demonstrated by the development of a prototype application
A Reconfiguration Framework for Distributed Components
Adaptability is a key feature of distributed systems. In component systems, adaptability can be realised by reconfiguration of the component assembly. The objective of this work is to increase the support for reconfiguration capabilities in distributed component models. This work extends an existing framework of reconfiguration language, FScript, by enabling remote interpretation of reconfiguration procedures. We provide an extension of the component model with a non-functional ability: the interpretation of reconfiguration scripts. This capability provides the basis for the non-centralised interpretation of reconfiguration scripts. This way, reconfiguration scripts can be evaluated in a distributed manner. We also provide an implementation of the extended script language and the interpreter
- …