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

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

Behavioural models for distributed Fractal components

International audienc

Behavioural Semantics for Asynchronous Components

Software components are a valuable programming abstraction that enables a compositional design of complex applications. In distributed systems, components can also be used to provide an abstraction of locations: each component is a unit of deployment that can be placed on a di fferent machine. In this article, we consider this kind of distributed components that are additionally loosely coupled and communicate by asynchronous invocations. Components also provide a convenient abstraction for verifying the correct behaviour of systems: they provide structuring entities easing the correctness veri fication. This article aims at providing a formal background for the generation of behavioural semantics for asynchronous components. We use the pNet intermediate language to express the semantics of hierarchical distributed components communicating asynchronously by a request-reply mechanism. We also formalise two crucial aspects of distributed components: recon figuration and one-to-many communications. This article both demonstrates the expressiveness of the pNet model and formally speci fies the complete process of the generation of a behavioural model for a distributed component system. The behavioural models we build are precise enough to allow veri fication by finite instantiation and model-checking, but also to use veri fication techniques for infi nite systems.Les composants logiciels fournissent une abstraction de programmation intéressante pour la conception modulaire d'applications complexes. Dans les systèmes répartis, les composants peuvent également être utilisés pour fournir une abstraction de la localisation des processus: chaque composant est une unité de déploiement qui peut être placée sur une machine différente. Dans cet article, nous considérons ce type de composants distribuées, faiblement couplés et communiquant par des appels asynchrones. Les composants fournissent également une abstraction commode pour vérifier le bon comportement des systèmes: ils fournissent un concept structurant qui facilite la vérification de ses propriétés. Cet article vise à fournir un support formel pour la génération de la sémantique comportementale des composants asynchrones. Nous utilisons le formalisme intermédiaire pNet pour exprimer la sémantique des composants hiérarchiques distribués communiquant de manière asynchrone par un mécanisme de requêtes. Nous formalisons également deux aspects fondamentaux des composants distribués: la reconfiguration et les communications de groupe. Cet article d'une part démontre l'expressivité du modèle pNet et d'autre part spécifie formellement le processus complet de la génération du modèle comportemental d'un système de composants distribués. Les modèles de comportement que nous construisons sont suffisamment précis pour permettre la vérification par instanciation finie et model-checking, mais aussi pour utiliser des techniques de vérification de systèmes infinis

interActors: A Model for Supporting Complex Communication in Concurrent Systems

In concurrent systems, such as multi-core computers, parallel systems, cloud computing systems, and systems involving mobile devices, processes interact with each other. Protocols for interactions among processes are increasingly complex and diverse, which is in part responsible for making programming of concurrent systems difficult. Particularly, in a concurrent program, the code for communication protocols often intermixes with the code for its functional behaviors, compromising modularity and reusability. There is a growing body of work on separating communication concerns of processes from their functional concerns. Although they achieve some degree of separation, they have some disadvantages. For example, the number of communication participants is fixed in some approaches, or in other approaches, communication mechanisms, such as for establishing the initial rendezvous for communication participants is left to the processes. In other words, existing approaches either offer static protocols that cannot handle dynamically evolving number of participants in interactions, or offer complex initialization steps that are left mixed with functional concerns. I propose interActors, a model for supporting complex communications in concurrent systems. I treat a communication as a first-class object which consists of outlets, through which processes can connect to it, and handlers, which are responsible for handling communication logics. Outlets establish a boundary between communications and processes in an application. New outlets can be created if necessary, to handle dynamically changed communication patterns at run-time. We say communications are self-driven because they have outlets and handlers that are active and therefore they can move interactions forward. More complex communications can be constructed by composing simpler communications. Operational semantics and compositional semantics are developed by extending the Actor model of concurrency with support for complex communication. A prototype implementation is developed using Scala and Akka actor library. With the intention of restricting arbitrarily complex code in communications, I developed Communication Specification Language (CSL), which excludes loops from communications and only allows a small set of statements and expressions. interActors are evaluated using case studies and comparison with Reo, a leading coordination model and language. The evaluation shows that interActors offer advantages in terms of programmability, reusability, and modularity

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

Providing quality of service to internet applications using multiprotocol label switching

The growth of the Internet and the range of applications it now supports has created a need for improved traffic engineering techniques. One protocol which shows promise in this regard is Multiprotocol Label Switching (MPLS). MPLS inherits a mix of attributes from earlier protocols such as IP and ATM, and potentially combines the simplicity of IP and the Quality of Service (QoS) capabilities of ATM. MPLS is now a mature standard widely deployed in the Internet. This thesis concerns the development of new mechanisms that can further extend the MPLS capabilities for traffic engineering. Web service remains a key application in today's Internet. The traffic demands at popular Web-sites and the requirements of redundancy and reliability can only be met by using multiple Web servers. A new solution to Web server load balancing based on MPLS is presented in this thesis. This solution features a novel Web switching architecture featuring switching at layer two. An extended solution for providing differentiated Web services is also proposed . It has been implemented in a soft MPLS router using the Linux operating system. The performance of soft routers is significantly affected by the packet processing time. An MPLS-based framework to increase the average packet size and consequently reduce the traffic frame-rate is described in the thesis. This has been implemented in a Linux-based soft router and its performance evaluated experimentally. As transmission rates continue to rise, such aggregation techniques will be needed if packet processing time is not to become a bottleneck. The switching technology at the core of tomorrow's Internet, featuring GMPLS and optical switching using , perhaps, optical burst switching technology, will not work efficiently with short packets. A new class of scheduling algorithms is also described, intended for deployment in MPLS networks. Their operation is based on an analogy with the workings of the human heart. This class of algorithms achieves the optimal fairness for packet based schedulers and has low hardware complexity. It can be combined with the packet aggregation mechanism above to provide an effective interface between the edges of tomorrow's Internet and its high-speed core