The ASCOLA project-team aims at harnessing and developing advanced application structuring mechanisms, and supporting the transformational development of correct large-scale applications as well as their valid evolution throughout their entire life cycle. We apply a language-based approach to achieve this goal, defining new languages in order to represent architectural as well as implementation level abstractions and exploit formal methods to ensure correctness.
Concretely, we investigate expressive aspect languages to modularize crosscutting concerns. Those languages enable sophisticated relationships between execution events to be formulated and manipulated directly at the language level. We study how to reconcile invasive accesses by aspects with strongly encapsulated software entities. Furthermore, we foster the transformational development of implementations from higher-level architectural software representations using domain-specific languages. Finally, we focus on abstractions and development methods for distributed and concurrent systems, in particular flexible and energy-efficient infrastructures.
Our results are subjected to validation in the context of four main application domains: enterprise information systems, service-oriented architectures, cluster and grid applications, and pervasive systems.
This year two groups of results of the ASCOLA team are particularly notable. First, in the domain of Cloud-based infrastructures, the team has shown how to harness virtual machine migration for the optimization of energy consumption ; Fabien Hermenier has received the award “Exceptional PhD” of University of Nantes for his work underlying these results. Three national projects on energy-aware software composition on the operating system and infrastructure levels have been started or selected.
Furthermore, the team has introduced two original foundational calculi for AOP. The Aspect Join calculus constitutes the first formal definition of distributed aspect languages that allows the proof of properties (in our case using bisimulation) over distributed applications that are subject to modifications through aspects. The A calculus supports the to-date most comprehensive aspect model for object-oriented base languages and supports correctness properties for a wide range of constructs using a parametrized calculus and type system.
Since we mainly work on new software structuring concepts and programming language design, we first briefly introduce some basic notions and problems of software components (understood in a broad sense, i.e., including modules, objects, ADLs and services), aspects, and DSLs. We conclude by presenting the main issues related to distribution and concurrency that are relevant to our work.
Modules and services.The idea that building software components, i.e., composable prefabricated and parametrized software parts, was key to create an effective software industry was realized very early . At that time, the scope of a component was limited to a single procedure. In the seventies, the growing complexity of software made it necessary to consider a new level of structuring and programming and led to the notions of information hiding, modules, and module interconnection languages , . Information hiding promotes a black-box model of program development whereby a module implementation, basically a collection of procedures, is strongly encapsulated behind an interface. This makes it possible to guarantee logical invariant propertiesof the data managed by the procedures and, more generally, makes modular reasoningpossible. In a first step, it is possible to reason locally, about the consistency between the module implementation and the module interface. In a second step, it is possible to reason about composing modules by only considering their interfaces. Modern module systems also consider types as module elements and consider, typically static, modules as a unit of separate compilation, with the most sophisticated ones also supporting modules parametrized by modules .
In the context of today's Internet-based information society, components and modules have given rise to software serviceswhose compositions are governed by explicit orchestration or choreographyspecifications that support notions of global properties of a service-oriented architecture. These horizontal compositions nowadays have, however, to be frequently adapted dynamically. Such adaptations, in particular in the context of software evolution processes, often conflict with a black-box composition model either because of the need for invasive modifications, for instance, in order to optimize resource utilization or modifications to the vertical compositions implementing the high-level services.
Object-Oriented Programming.Classesand objectsprovide another kind of software component, which makes it necessary to distinguish between component types(classes) and component instances(objects). Indeed, unlike modules, objects can be created dynamically. Although it is also possible to talk about classes in terms of interfaces and implementations, the encapsulation provided by classes is not as strong as the one provided by modules. This is because, through the use of inheritance, object-oriented languages put the emphasis on incremental programmingto the detriment of modular programming. This introduces a white-box model of software development and more flexibility is traded for safety as demonstrated by the fragile base classissue .
Architecture Description Languages.The advent of distributed applications made it necessary to consider more sophisticated connections between the various building blocks of a system. The software architecture of a software system describes the system as a composition of componentsand connectors, where the connectors capture the interaction protocolsbetween the components . It also describes the rationale behind such a given architecture, linking the properties required from the system to its implementation. Architecture Descriptions Languages(ADLs) are languages that support architecture-based development . A number of these languages make it possible to generate executable systems from architectural descriptions provided implementations for the primitive components are available. However, guaranteeing that the implementation conforms to the architecture is an issue.
The main driving force for the structuring means, such as components and modules, is the quest for clean separation of concerns on the architectural and programming levels. It has, however, early been noted that concern separation in the presence of crosscutting functionalities requires specific language and implementation level support. Techniques of so-called computational reflection, for instance, Smith's 3-Lisp or Kiczales's CLOS meta-object protocol , as well as metaprogramming techniques have been developed to cope with this problem but proven unwieldy to use and not amenable to formalization and property analysis due to their generality.
Aspect-Oriented Software Development , has emerged over the previous decade as the domain of systematic exploration of crosscutting concerns and corresponding support throughout the software development process. The corresponding research efforts have resulted, in particular, in the recognition of crosscuttingas a fundamental problem of virtually any large-scale application, and the definition and implementation of a large number of aspect-oriented models and languages.
However, most current aspect-oriented models, notably AspectJ , rely on pointcuts and advice defined in terms of individual execution events. These models are subject to serious limitations concerning the modularization of crosscutting functionalities in distributed applications, the integration of aspects with other modularization mechanisms such as components, and the provision of correctness guarantees of the resulting AO applications. They do, in particular, only permit the manipulation of distributed applications on a per-host basis, that is, without direct expression of coordination properties relating different distributed entities . Similarly, current approaches for the integration of aspects and (distributed) components do not directly express interaction properties between sets of components but rather seemingly unrelated modifications to individual components . Finally, current formalizations of such aspect models are formulated in terms of low-level semantic abstractions (see, e.g., Wand's et al semantics for AspectJ ) and provide only limited support for the analysis of fundamental aspect properties.
Recently, first approaches have been put forward to tackle these problems, in particular, in the context of so-called statefulor history-based aspect languages , , which provide pointcut and advice languages that directly express rich relationships between execution events. Such languages have been proposed to directly express coordination and synchronization issues of distributed and concurrent applications , , , provide more concise formal semantics for aspects and enable analysis of their properties , , , . Due to the novelty of these approaches, they represent, however, only first results and many important questions concerning these fundamental issues remain open.
Today, protocols constitute a frequently used means to precisely define, implement, and analyze contracts between two or more hardware or software entities. They have been used to define interactions between communication layers, security properties of distributed communications, interactions between objects and components, and business processes.
Object interactions , component interactions , and service orchestrations are most frequently expressed in terms of regular interaction protocolsthat enable basic properties, such as compatibility, substitutability, and deadlocks between components to be defined in terms of basic operations and closure properties of finite-state automata. Furthermore, such properties may be analyzed automatically using, e.g., model checking techniques , .
However, the limited expressive power of regular languages has led to a number of approaches using more expressive non-regularinteraction protocols that often provide distribution-specific abstractions, e.g., session types , or context-free or turing-complete expressiveness , . While these protocol types allow conformance between components to be defined (e.g., using unbounded counters), property verification can only be performed manually or semi-automatically.
Furthermore, first approaches for the definition of aspects over protocolshave been proposed, as well as over regular structures and non-regular ones , . The modification of interaction protocols by aspects seems highly promising for the integration of aspects and components.
Patterns provide a kind of abstraction that is complementary to the modularization mechanisms discussed above. They have been used, in particular, to define general architectural styleseither by defining entire computation and communication topologies , connectors between (complex) software artifacts , or (based on, possibly concretizations of, design patterns ) as building blocks for object-oriented software architectures. The resulting pattern-based architectures are similar to common component-based architectures and are frequently used to implement the latter, see, for instance, Sun's J2EE patterns.
Patterns have also been used to implement architectural abstractions. This is the case, for instance, for the numerous variants of the publish/subscribe pattern as well as the large set of so-called skeletons , that is, patterns for the implementation of distributed and concurrent systems. While these patterns are essentially similar to architecture-level patterns, their fine-grained application to multiple code entities often results in crosscutting code structures. An important open issue consists in the lack of pattern-based representations for the implementation of general distributed applications — in sharp contrast to their use for the derivation of massively parallel programs.
Domain-specific languages(DSLs) represent domain knowledge in terms of suitable basic language constructs and their compositions at the language level. By trading generality for abstraction, they enable complex relationships among domain concepts to be expressed concisely and their properties to be expressed and formally analyzed. DSLs have been applied to a large number of domains; they have been particularly popular in the domain of software generation and maintenance , .
Many modularization techniques and tasks can be naturally expressed by DSLs that are either specialized with respect to the type of modularization constructs, such as a specific brand of software component, or to the compositions that are admissible in the context of an application domain that is targeted by a modular implementation. Moreover, software development and evolution processes can frequently be expressed by transformations between applications implemented using different DSLs that represent an implementation at different abstraction levels or different parts of one application.
Functionalities that crosscut a component-based application, however, complicate such a DSL-based transformational software development process. Since such functionalities belong to another domain than that captured by the components, different DSLs should be composed. Such compositions (including their syntactic expression, semantics and property analysis) have only very partially been explored until now. Furthermore, restricted composition languages and many aspect languages that only match execution events of a specific domain (e.g., specific file accesses in the case of security functionality) and trigger only domain-specific actions clearly are quite similar to DSLs but remain to be explored.
While ASCOLA does not investigate distribution and concurrency as research domains per se (but rather from a software engineering and modularization viewpoint), there are several specific problems and corresponding approaches in these domains that are directly related to its core interests that include the structuring and modularization of large-scale distributed infrastructures and applications. These problems include crosscutting functionalities of distributed and concurrent systems, support for the evolution of distributed software systems, and correctness guarantees for the resulting software systems.
Underlying our interest in these domains is the well-known observation that large-scale distributed applications are subject to numerous crosscutting functionalities(such as the transactional behavior in enterprise information systems, the implementation of security policies, and fault recovery strategies). These functionalities are typically partially encapsulated in distributed infrastructures and partially handled in an ad hoc manner by using infrastructure services at the application level. Support for a more principled approach to the development and evolution of distributed software systems in the presence of crosscutting functionalities has been investigated in the field of open adaptable middleware , . Open middleware design exploits the concept of reflection to provide the desired level of configurability and openness. However, these approaches are subject to several fundamental problems. One important problem is their insufficient, framework-based support that only allows partial modularization of crosscutting functionalities.
There has been some criticismon the use of AspectJ-like aspect models(which middleware aspect models like that of JBoss AOP are an instance of) for the modularization of distribution and concurrency related concerns, in particular, for transaction concerns and the modularization of the distribution concern itself . Both criticisms are essentially grounded in AspectJ's inability to explicitly represent sophisticated relationships between execution events in a distributed system: such aspects therefore cannot capture the semantic relationships that are essential for the corresponding concerns. History-based aspects, as those proposed by the ASCOLA project-team provide a starting point that is not subject to this problem.
From a point of view of language design and implementation, aspect languages, as well as domain specific languages for distributed and concurrent environments share many characteristics with existing distributed languages: for instance, event monitoring is fundamental for pointcut matching, different synchronization strategies and strategies for code mobility may be used in actions triggered by pointcuts. However, these relationships have only been explored to a small degree. Similarly, the formal semantics and formal properties of aspect languages have not been studied yet for the distributed case and only rudimentarily for the concurrent one , .
Large IT infrastructures typically evolve by adding new third-party or internally-developed components, but also frequently by integrating already existing information systems. Integration frequently requires the addition of glue code that mediates between different software components and infrastructures but may also consist in more invasive modifications to implementations, in particular to implement crosscutting functionalities. In more abstract terms, enterprise information systems are subject to structuring problems involving horizontal composition (composition of top-level functionalities) as well as vertical composition (reuse and sharing of implementations among several top-level functionalities). Moreover, information systems have to be more and more dynamic.
In this year, we have shown, in particular, how to use invasive patterns to reconcile requirements for black-box and gray-box composition for the evolution of grid-based information systems, see Sections and .
Service-Oriented Computing (SOC) is an emerging paradigm used to program and integrate distributed applications, thus solving some of the integration problems discussed above. Indeed, service-oriented computing has two main advantages:
Loose-coupling: services are autonomous, in that they do not require other services to be executed;
Ease of integration: Services communicate over standard protocols.
In 2010, we mainly provided new results about the QoS properties in service-oriented architectures and the evolution of such systems in the context of the CESSA research project, see .
Our current work is based on the following observation: similar to other compositional structuring mechanisms, SOAs are subject to the problem of cross-cutting functionalities, that is, functionalities that are scattered and tangled over large parts of the architecture and the underlying implementation. Security functionalities, such as access control and monitoring for intrusion detection, are a prime example of such a functionality in that it is not possible to modularize security issues in a well-separated module. Aspect-Oriented Software Development is precisely an application-structuring method that addresses in a systemic way the problem of the lack of modularization facilities for cross-cutting functionalities.
We are considering solutions to secure SOAs by providing an aspect-oriented structuring and programming model that allows security functionalities to be modularized. Two levels of research have been identified:
Service level: as services can be composed to build processes, aspect weaving will deal with the orchestration and the choreography of services.
Implementation level: as services are abstractly specified, aspect weaving will require to extend service interfaces in order to describe the effects of the executed services on the sensitive resources they control.
A cluster is a group of coupled computers that work together closely through fast Local Area Networks. Clusters are usually deployed within one administration domain to improve performance (for scientific applications) or availability (e.g., for Internet services hosted by a data center) compared to a single computer configuration. A grid is a collaboration between different administrative domains that share a part of their infrastructure. It is composed of a set of nodes which could be of very different nature, like clusters or (low-bandwidth wide-area) networks of personal computers or super-computers. Architectures require permanent adaptation, from the application to the system level and calls for automation of the adaptation process. We focus on self-configuration and self-optimization functionalities across the whole software stack : from the lower levels (systems mechanisms such as distributed file systems for instance) to the higher ones (i.e. the applications themselves such as J2EE clustered servers or scientific grid applications).
This year we extended the Entropy framework to allow the implementation of advanced scheduling policies though efficient cluster-wide context switches of virtualized jobs (i.e job embedded in one or several virtual machines) across a cluster.
We continued to deal with self-administration of large distributed architectures with the partners of the ANR SelfXL project, see Sec. . Furthermore, we finalized the MCITN Scalus European network in which we are involved. The project Scalus (“SCALing by means of Ubiquitous Storage”) addresses the foundation for ubiquitous storage systems, which can be scaled with respect to multiple characteristics (capacity, performance, distance, security, ...), see Sec. .
Pervasive systems are another class of systems raising interesting challenges in terms of software structuring. Such systems are highly concurrent and distributed. Moreover, they assume a high-level of mobility and context-aware interactions between numerous and heterogeneous devices (laptops, PDAs, smartphones, cameras, electronic appliances...). Programming such systems requires proper support for handling various interfering concerns like software customization and evolution, security, privacy, context-awareness...Additionally, service composition occurs spontaneously at runtime.
This year, as part of understanding the potential target applications of our new language ECaesarJ (see Sec. ), we have shown how a proper combination of advanced features inherited from Object-Oriented, Aspect-Oriented, and Event-based Programming could support the programming of context-aware applications.
The model of Aspects With Explicit Distribution (AWED) supports the modularization of crosscutting functionalities of distributed applications. It addresses the problem that common aspect systems do not provide features for distributed programming. It notably features three main aspect abstractions: remote pointcuts, remotely-executed advice, and distributed aspects.
This year the AWED model has been used to implement new results on the evolution of grid algorithms by means of invasive distributed patterns (see. Sec. ) and employed in the CESSA project proposal (see Sec. ) as a basis for our work on the secure evolution of service-oriented architectures. Furthermore, an application of the AWED system to the adaptation of a satellite-based automatic tolling system that we have developed in the context of an industry cooperation with Siemens AG, Munich, Germany, has been presented in the journal “IEEE Computer” in 2010, see Sec. .
AWED is available at
http://
ECaesarJ is a language developed in the context of the European project AMPLE (see Sec. ), as joint work with the Technische Universität Darmstadt(TUD). The basic objective was to provide support for directly mapping the high-level features defined by a software product line onto implementation-level features, beyond standard feature-oriented programming. But the language has much wider applications. ECaesarJ can actually be seen as a language which smoothly integrates Object-Oriented Programming, Feature-Oriented Programming, Aspect-Oriented Programming, and Event-based Programming.
It is an extension of Java with virtual classesand propagating mixin composition(as its ancestor CaesarJ, developed at the TUD), but also polymorphic eventsand state machines. Unlike AspectJ, ECaesarJ does not include a class-like concept of aspect. Instead, it deals with pointcuts and advices as (implicit) events and event handlers, which are standard class members. This makes it possible to use standard inheritance to reuse and refine them. Explicit events can also be used when events must be explicitly triggered as in traditional event-based programming.
This provides a symmetric version of AOP where virtual classes can be used to deal with structural aspects whereas events can be used to deal with behavioral aspects.
Finally, a class can also include, as class members, state transitions. Combining this with virtual classes makes it possible to define, at the programming language level, refinable hierarchical state machines. The combination of state machines and events provides, in particular, effective language support for the State design pattern as well as a form of Event-based AOP.
ECaesarJ is available on request under the GPL license
.
Entropy is a virtual machine manager for clusters. The current prototype acts as an infinite control loop, which performs a globally optimized placement according to cluster resource usage, scheduler objectives and administrative rules.
Relying on an encapsulation of jobs into VMs, Entropy enables the implementation of finer scheduling policies through cluster-wide context switches, i.e., permutations of VMs present in the cluster. It thus supports a more flexible use of cluster resources and frees end-users from the burden of dealing with time estimates.
The major advantage of the Entropy system concerns the cluster-wide context switch process itself. Entropy computes a new viable configuration and an optimized reconfiguration plan. This plan describes the sequences of transitions to perform (i.e. the run, migrate, suspend/resume, stop VM operations) in order to pass from the current situation to the new one. As the cost of each action and the dependencies between them is considered, Entropy reduces the duration of each cluster-wide context switch by performing a minimum number of actions in the most efficient way.
Around this solution, we developed VMScript, a domain specific language for administration of virtualized grid infrastructures. This language relies on set manipulation and is used to introspect physical and virtual grid architectures thanks to query expressions and notably to modify VM placement on machines. VMScript interact with Entropy and can be used to define administrative placement rules.
In 2010, Entropy has been presented at the CloudComp
conference, and has been tested or used by our partners
Orange Labs, DGFiP (direction Générale des Finances
Publiques), Bull, MACIF, Logica. Entropy is available under
the LGPL license at
http://
FPath and FScript are two domain-specific languages (DSLs) dealing respectively with the navigation and the dynamic reconfiguration of Fractal architectures. FPathis a DSL for querying Fractal architectures. It is restricted to the introspection of architectures by browsing elements identified by their properties or location in the architecture. This focused domain allows FPath to offer a very concise and readable syntax and ensures correctness properties by construction (e.g. any query terminates in a finite time). FScriptis a DSL dedicated to the reconfiguration of Fractal component architectures. It enables reconfiguration scripts to modify a Fractal architecture. Like FPath, FScript guarantees several properties by construction, e.g. termination of scripts by excluding the possibility of infinite loops. Moreover the FScript interpreter supports a transactional model of reconfigurations and the preservation of ACID properties .
As part of the Galaxy project (see Sec. ), we have developed with the INRIA Adam project-team an adaptation of FPath/FScript to FraSCAti, a component framework providing runtime support for the Service Component Architecture (SCA). In that way, software architects are able to navigate using FPath notation through FraSCAti architectures and to reconfigure them with FScript.
FScript and its extensions are available under the LGPL
license at
http://
WildCAT is a generic Java framework for context-aware applications. It permits the monitoring of large scale applications by allowing developers to easily organize and access resources through a hierarchical organization backed with a powerful SQL-like language to inspect sensors data and to trigger actions upon particular conditions. WildCAT proposes two modes to inspect the resources: a pull mode relies on synchronous communication and a push one relies on asynchronous communication. In the pull mode, developers programmatically get and set attributes. In the push mode, developers register listeners on queries expressed over the events generated by the backend.
In the context of the Galaxy project (see Sec. ), we have shown how WildCAT can be used to monitor a SCA application running in OW2 FraSCAti runtime.
WildCAT is available under GPL v2 at
http://
We have provided results on two subject matters: aspect languages and their application to distributed systems, as well as the foundations of aspects.
We have developed support for aspect languages for distributed systems, in particular to support expressive scoping strategies for dynamic evolution of distributed systems, have proposed means to integrate notions of distributed events and aspects in an object-oriented context, and have developed aspect-based support for the invasive composition of distributed programming patterns.
Scoping strategies for distributed aspects.We have developed scoping mechanisms to configure and deploy distributed aspects . These mechanisms enable us to reuse aspects in different contexts and to ensure properties (for example, an aspect should not migrate from one host to another). The operational semantics of our scoping features has been precisely defined with interpreters. This work has been done by members of the associate team RAPIDS (see Sec. ).
Object-oriented events with EScala.We have further refined the notion of events initially introduced in ECaesarJ (see Sec. ). These object-oriented events combine traditional imperative events, triggered explicitly, with the declarative events of aspect-oriented programming, which can be seen as declarative queries over implicit events. An efficient and type-safe implementation of the concept has been realized as an extension of Scala. An extension of this work has been accepted for publication at AOSD'11.
Invasive patterns for distributed programming.We have developed a more structured approach to the composition of complex software systems in order to improve their modularization and evolution properties . Concretely, we have provided two contributions, we (i) have presented a small kernel composition language for structured gray-box composition with explicit control mechanisms for invasive access to software entities and a corresponding aspect-based implementation; (ii) have presented and compared evolutions using this approach to gray-box composition in the context of two real-world software systems: benchmarking of grid algorithms with NASGrid and transactional replication with JBoss Cache.
Furthermore, we have produced several results on the use of AOSD in large-scale applications, in particular, an analysis of the use of AOSD in industrial applications.
AOSD in practice.Together with partners from industry and academia we have published an overview article on the current state of AOSD in practice that presents, in particular, a set of large-scale real-world applications using AOP. We have contributed through the AWED approach (see Sec. ) to distributed aspects in the context of a satellite-based automatic tolling application whose modularization properties we have improved with Siemens AG, Germany.
Systems-of-systems.This year we have started to consider composition issues in systems-of-systems . Concretely, we have studied integration problems in such systems (see Sec. for details) and devised a high-level aspect-based approach to address these problems.
Finally, Mario Südholt has participated in the publication of the proceedings of the international conference of AOSD as PC chair and principal co-editor.
We have contributed two major results to the foundations of aspect-oriented programming: a new calculus that largely integrates aspect-oriented and object-oriented concepts and the first foundational calculus for distributed aspects. Furthermore, we have presented a new notion of views on component-based systems.
The A Calculus.With partners from Vrije Universiteit Brussel and Aarhus University, we have proposed a new foundational calculus for AOP that supports the most general aspect model to-date compared to existing calculi and the deepest integration with plain OO concepts . Integration with OOP is achieved essentially by modeling proceedusing first-class closures. Two well-known pointcut categories, calland executionthat are commonly considered similar are shown to be significantly different; our calculus enables the resolution of the associated soundness problems. Our calculus also includes type ranges, an intuitive and concise alternative to explicit type variables that allows advices to be polymorphic over intercepted methods. Finally, our calculus if the first aspect calculus to use calculus parameters to cover type safety for a wide design space of other features. The soundness of the resulting type system has been verified in Coq.
The Aspect Join Calculus.We have developed the first formal theory of distributed aspects . Based on the distributed and objective join calculus, our calculus is presented with a (chemical) operational semantics and a type system. We have also defined a translation of the aspect join calculus into the core join calculus and shown the correctness of the translation with a proof of bisimilarity. In this way, we provide a well-defined version of a weaving algorithm that constitutes, e.g., a main step towards an implementation of the aspect join calculus directly in JoCaml.
Views on component-based systems.We have introduced a notion of views in component-based system, in particular the Fractal component model, in order to support multiple architectures . A main characteristics of this notion of views is that a component in one view may correspond to an aspect in another view, thus enabling intricate relationships between components and functionality to be made explicit. A corresponding weaving algorithm generates the complete system and enables checking of protocol properties with the model checker UPPAAL.
The Ascola team has provided results mainly in two different fields: advanced composition models and model transformations.
We have produced several results on the dynamic reconfiguration of component-based systems and service compositions.
Reliable Dynamic Reconfigurations.We have proposed a definition of consistency for (re)configurations in Fractal component architectures with a model based on integrity constraints (e.g., structural invariants). Reliability of reconfigurations is ensured thanks to a transactional approach which allows us both to deal with error recovery and to manage distributed and concurrent reconfigurations in Fractal applications .
Service composition.In the context of Service-Oriented Computing, we have proposed a pivot architecture built around a universal language for manipulating resources . It aims at solving composition problems related to adaptation, integration and coordination of services.
Invasive distributed patterns.We have developed a more structured approach to the composition of complex software systems using invasive patterns for distributed programming and applied it to a service-based application , see for details.
Systems-of-systems.With partners from Lancaster University, we have started to consider composition issues in systems-of-systems . Concretely, we have studied three integration problems of such systems: managerial independence, interface incompatibility, and component system complexity. We have provided a high-level aspect-based approach to address these problems.
Composition of aspects and components.Together with partners from industry and academia we have published an overview article on the current state of AOSD in practice , see Sec. for details. We have also investigated AOP in a component based context , see Sec. for details.
We have also tackled several composition problems of other software artifacts or dynamical systems.
Compositional control for constraint solvers.We are investigating how to compose a search strategy and a constraint solver. This work shows how to build a monadic program in Haskell to control constraint propagators in C++ for the state estimation of multi-model (hybrid) dynamical systems, subject to partial and uncertain measurements.
Fixed Point Combinator.We have proposed a new method to characterize the fixed points described in order-theoretic fixed point theorems (Tarski, Bourbaki-Witt) and used in semantics. The method is deductive: the fixed points are “proved” in some inference system defined from deduction rules. It is a first step towards a formalization of the connection between the traditional iterative method resorting to ordinals and the original impredicative method used by Tarski.
Synchronization of stochastic systems.The functional role of synchronization has attracted much interest and debate: in particular, synchronization may allow distant sites in the brain to communicate and cooperate with each other, and therefore may play a role in temporal binding, in attention or in sensory-motor integration mechanisms. In , we study another role for synchronization: the so-called “collective enhancement of precision.” We argue, in a full nonlinear dynamical context, that synchronization may help protect interconnected neurons from the influence of random perturbations (intrinsic neuronal noise) which affect all neurons in the nervous system.
We have produced several results on the application of model-driven techniques to software product lines and on the problem of model matching.
Fine-grained configuration of software product lines.We have introduced the Fiesta toolkit , a set of tools to assist product-line architects and product designers in the creation of fine-grained configurations of products in model-driven software product lines.
Constraints for product line derivation.We have shown how to use constraint programming to derive model-driven software product lines .
Model matching.We have proposed a mechanism to adapt matching algorithms to the ontology context, for example, to the Ontology Alignment Evaluation Initiative .
Evolution of models.We have also provided a detailed comparison of a representative sample of model migration tools - AML, COPE, Ecore2Ecore and Epsilon Flock - using common migration examples .
Kelly Garcés PhD thesis has provided new results on heuristics-based model matching based on underlying quality measures. Her approach extracts a large set of modeling test cases from model repositories, and uses megamodels to automate the evaluation of strategies over them. To validate the approach, she has developed an AML DSL on top of the AmmA model transformation platform. She also has contributed three use cases that show the applicability of matching to interesting MDE topics: model co-evolution, pivot metamodel evaluation, and model synchronization.
Our main results concern the management and the execution of the applications leveraging virtualization capabilities on cluster, grid and cloud infrastructures.
Moreover, we have continued to analyze how energy concerns can be addressed in large scale distributed infrastructures.
With respect to virtualization and job management, the originality of our work is twofold:
The use of several control loops to manage both applications and physical resources in an autonomic way.
A strong synergy between applications and resources management systems to improve the decision processes of each loop.
Concretely, we have achieved the following results:
Context switch.We have extended the Entropy framework and proposed the concept of “cluster-wide context switch” , a building block leveraging virtualization capabilities to facilitate advanced scheduling implementations. Such a context switch relies on the manipulation of virtualized-jobs (vjobs), i.e. jobs composed of VMs, through their life cycle.
Resource management.In cooperation with the Myriads project-team from INRIA Rennes-Bretagne Atlantique, we have addressed resource-management issues using virtualization . We have proposed a way to improve best-effort management in grids through the Saline framework and extended this work through the integration of Entropy within the Saline framework. This integration allows us to manage VMs through several sites in an efficient way Finally, we have suggested a new approach aiming at automatically adapt both hardware and software resources to the applications' needs through a unique method. For each application, scientists describe the requirements in terms of both hardware and software expectations through the definition of a Virtual Platform (VP)and a Virtual System Environment (VSE) .
VMScript.In the context of the Entropy platform for task consolidation in clusters, we have developed VMScript, a domain specific language for the administration of virtualized grid infrastructures . This language relies on set manipulation and is used to introspect physical and virtual grid architectures thanks to query expressions and to modify the placement of VMs.
Invasive patterns.We have shown how invasive patterns for distributed programming can be used to more declaratively define and implement evolution problems of grids , see Sec. for details.
We have published three results on the energy consumption on the application level.
Resource arbitration.We have extended the Entropy framework to address the trade-off between application performance and energy consumption and to enable arbitration of resource allocations in the case of contention.
Energy-aware service compositions.We have proposed an approach for energy-aware self-adaptation of SOA-based applications . The energy efficiency properties of services are defined by means of Quality of Service criteria and a set of event-condition-actions is defined to enable the application to react to environmental changes and optimize its energy consumption.
Energy-aware software.We have presented a position paper to the French community of Software Engineering. The objective of this work was to raise discussions around the interest of reifying the energy at the software level.
PhD about Virtualisation in data centers (Cifre Hien Van Nguyen with Orange Labs)
To satisfy QoS properties in data centers (such as the expected request rates), a standard data center statically allocates resources according to the worst-case conditions defined in the contract formally negotiated by both parties. As a result, the data center must be oversized and is most of the time underused. From the point of view of the hosting provider (who hosts multiple client applications), the problem is to define an optimal resource allocation, which maximizes client benefits but minimizes the costs of the provider.
By using our current results around Entropy, Hien Nguyen Van's PhD work defines relations between QoS rules and resources needs (CPU, memory) by designing a specific domain-specific language for managing data centers, in particular their energy consumption .
This work is supported by Orange Lab for an amount of 27 KEUR.
The project CESSA is an (industrial) ANR project running for 36 months. It was accepted in June 2009 for funding amounting to 290 KEUR for ASCOLA from December 2009 on. Three other partners collaborate within the project that is coordinated by ASCOLA: a security research team from Eurecom, Sophia-Antipolis, the Security and Trust team from SAP Labs, also located at Sophia-Antipolis, and IS2T, an innovative start-up company developing middleware technologies located at Nantes. The project deals with security in service-oriented architectures.
This year our group has contributed several scientific publications as part of the project. All partners have been involved in the publication of two surveys on models for service-oriented architectures and security properties, and set up an SAP community blog.
All information is available from the CESSA web site:
http://
The Entropy project is an (industrial) ANR/Emergence project running for 18 months. It was accepted in December 2010 for funding amounting to 242 KEUR (ASCOLA only).
The objective of this project is to conduct studies on economic feasibility (market, status, intellectual property, website) for creating a industrial business on the Entropy software.
Some task must complete the Entropy core solution with a graphical unit interface to produce convincing demonstrators and consolidate our actual and future results. At the end of the project, the goal is to create a company whose objective is to sell the service, support and software building blocks developed by this ANR Emergence project.
FLFS involved three INRIA research teams ASCOLA, AtlanMod, and Phoenix until January 2010. Its purpose was to place domain expertise at the center of software development process. FLFS addressed the current limitations of software engineering with regarding large-scale software production, robustness, reliability, maintenance, and evolution. Our main contribution was to parametrize software development process with a specific domain of expertise.
Several domain specific languages have been modeled and implemented in the fields of Internet telephony services and pervasive computing. FLFS has applied the DSL approach to model driven engineering itself. Following the works on the ATL transformation language and on model weaving, FLFS allowed the design and implementation of the AML DSL to manage software evolution. The AML presentation, its integration in the Eclipse/AMMA platform dedicated to models transformation, several use cases has been developed in Kelly Garcés PhD defended in September 2010 . FLFS results have also been presented at the Grand Colloque STIC.
The Cool-IT project is an (industrial) FUI project running for 24 months. It was accepted in September 2010 for funding amounting to 130 KEUR (ASCOLA only).
The objective of this project is to design systems adapted to new standards of "Green IT" to reduce the data centers electrical consumption.
To this end, the COOL IT project aims at developping processes for cooling computer servers, optimizing the servers' power chain supply, implementing tools and methods of collecting energy data in real time, specifying methods for controlling the data centers consumption as a tradeoff between the computational power needed, the availability, and the energy consumption.
The technology development action (ADT) Galaxy (
http://
Galaxy makes it possible to design, deploy, run, monitor systems, following concepts and paradigms inherited from service-oriented, business process and dynamic architectures, and to offer a set of management functions for agile and dynamic systems. Most of the Galaxy technologies are compliant with the Eclipse and the SCA standards. The INRIA technologies Fractal, FraSCAti and GCM-ProActive are the technological drivers of this ADT.
The ASCOLA project-team provides the DSL FScript and the
monitoring framework WildCAT as sub-components for building
the target agile platform. For the last year, in
cooperation with the Adam project-team, we have proposed an
extension of FScript for FraSCAti, an implementation of the
SCA standard. We have also proposed a major revision of
WildCAT with several use cases and documentation at
http://
The duration of the project was 28 months, ending October 2010. Contributors to this ADT were mainly research project-teams, including ADAM, ECOO, OASIS, ASCOLA, TUVALU, SARDES and TRISKELL.
The SelfXL project is an (industrial) ANR/ARPEGE project running for 36 months. It was accepted in July 2008 for funding amounting to 315 KEUR (ASCOLA only)from January 2009 on.
The SelfXL project aims at investigating abstractions and implementation techniques (language mechanisms, runtime structures...) for complex and large-scale autonomic systems. The scope of this project encompasses any system that has a high software complexity (distributed, size of code etc.) and is large-scale in terms of size and heterogeneity of resources and software. Systems to be targeted range from cluster computing to embedded systems, including legacy software.
Two main issues will be addressed by SelfXL: How to implement administration policies for complex system and how to coordinate administration policies in a complex system? Regarding the first issue, SelfXL proposes to explore the DSL programming approach, i.e., designing specific languages for defining specific kinds of administration policies (self-repair, self-optimization, self-protection). The general use of DSLs would ensure the correctness of the policies.
We propose to design a decision module based on Constraint Programming (CP). As the Rules Based Systems (RBS) or the Event Condition Action (ECA) approach, CP belongs to the declarative paradigm but does not share the major drawback of the other approaches when some rules are simultaneously asserted. This is the case when there is an overlap between the domain or the target of rules.
Finally, we propose to extend the Jasmine autonomic
administration platform (
http://
The vision of the Scalus Marie Curie international training network (MC ITN) is to deliver the foundation for ubiquitous storage systems, which can be scaled with respect to multiple characteristics (capacity, performance, distance, security, ...).
Providing ubiquitous storage will become a major demand for future IT systems and leadership in this area can have significant impact on European competitiveness in IT technology. To get this leadership, it is necessary to invest into storage education and research and to bridge the current gap between local storage, cluster storage, grid storage, and cloud storage. The consortium will proceed into the direction by building the first interdisciplinary teaching and research network on storage issues. It consists of top European institutes and companies in storage and cluster technology, building a demanding but rewarding interdisciplinary environment for young researchers.
The network involves the following partners: University of Paderborn (Germany, coordinator), Barcelona Super Computing (Spain), University of Durham (England), University of Frankfurt (Germany), ICS-FORTH (Greece), Universidad Polytecnica de Madrid (Spain), EMNantes/ARMINES (France), INRIA Rennes Bretagne Atlantique (France), XLAB (Slovenia), University of Hamburg (Germany), Fujistu Technology Systems (Germany).
The overall funding of the project by the European Union is closed to 3,3 MEUR. ASCOLA's share amounts to 200 KEUR. ..
The COST IC 0840 Action will propose realistic
energy-efficient alternate solutions to share IT
distributed resources. As large scale distributed systems
gather and share more and more computing nodes and storage
resources, their energy consumption is drastically
increasing. While much effort is nowadays put into hardware
specific solutions to lower energy consumptions, the need
for a complementary approach is necessary at the
distributed system level, i.e. middleware, networks and
applications. The action will characterize the energy
consumption and energy efficiencies of distributed
applications.
http://
RAPIDS is an INRIA Associated Team started in January
with the PLEAID Laboratory at the University of Chile, with
a kickoff meeting in March in Nantes. RAPIDS stands for
Reasoning about Aspect-oriented Programs and securIty in
Distributed Systems. While Aspect-Oriented Programming
offers promising mechanisms for enhancing the modularity of
software, this increased modularity raises new challenges
for systematic reasoning. This project studies means to
address fundamental and practical issues in understanding
distributed aspect-oriented programs by focusing on the
issue of security. Some initial results of the project are
reported in Sec.
and more details are available
on the RAPIDS website
http://
ACM/SIGOPS:Jean-Marc Menaud has been the vice-chair of the French ACM/SIGOPS Chapter (ASF) since March 2008.
AOSD:M. Südholt was program chair of the international conference AOSD'10 and helped organizing it in Rennes and St. Malo.
CNRS GDR ASR:Jean-Marc Menaud is a member of the scientific committee of the CNRS GDR ASR (Architectures, Systèmes, Réseaux) and in charge of the System action.
DSAL:Jacques Noyé has co-organized the 5th international workshop on “Domain-Specific Aspect Languages” (DSAL 2010) co-located with AOSD 2010 in Rennes.
EuroSys:J.-M. Menaud is a member of the EuroSys 2010 organization committee.
JTE-Virtualization:Adrien Lèbre has organized a
“Journée Thèmes Emergents” on the Virtualization in
Distributed Architectures, on June 17-18, at the Ecole des
Mines in Nantes,
http://
LMO:Jean-Claude Royer was program chair of LMO 2010
in Pau,
http://
SPL:Jean-Claude Royer was program chair of the
“Journée lignes de produits logiciels”, October 20 in
Paris,
https://
P. Cointewas a member of the NOTERE 2010 conference and of the 2010 Dynamic Languages Symposium (DLS).
A. Lèbrewas a member of the program committee of the 5th IEEE International Conference on Networking, Architecture, and Storage (NAS 2010), the 4th Workshop on System-level Virtualization for High Performance Computing (HPCVirt 2010, co-located with the ACM SIGOPS EuroSys conference) and the 2nd Workshop on Energy Efficient Grids, Clouds and Clusters (E2GC2 2010). He has been invited to the 4th Workshop on Virtualization Technologies in Distributed Computing (VTDC 2010, colocated with the ACM HPDC conference) to deliver a keynote on virtualization concerns in the Grid'5000 infrastructure.
T. Ledouxwas a member of program committees of the 1st International Workshop on Green Computing Middleware (GCM'10) and the 9th International Workshop on Adaptive and Reflective Middleware (ARM'10).
J.-M. Menaud:He is a member of the (RenPar/CFSE/Sympa) steering committees. He has served on the program committee of the IEEE/ACM International Conference on Green Computing and Communications (GreenCom2010), the 5th Workshop on Virtualization in High-Performance Cluster and Grid Computing (VHPC'10) as part of Euro-Par 2010 and 4th Workshop on System-level Virtualization for High Performance Computing (HPCVirt 2010) as part of EuroSys 2010, and the first International Workshop on Autonomic Systems enabling Green Computing (ASGC 2011) as part of The Tenth International Conference on Networks (ICN 2011).
J-C. Royer:He is a member of the editorial board of the journal TSI. He was a member of the program committee of CAL 2010 and the workshop MDPLE.
M. Südholtis a member of the steering committees of the international conferences AOSD and Software composition. He is also member of the editorial board of the international journal “Transactions of AOSD”, which is published by Springer Verlag.
P. Cointehas taken part in Benoit Baudry HDR (Rennes, 10 Dec.) and Kelly Garcès PhD (Nantes, 28 Sept.) committees.
J-C. Royerwas reviewer of three PhDs: Idrissa Abdoulaye Dieng (Université de Grenoble, May 31), Fabien Bonnefoy (Université Pierre et Marie Curie, September 27), Mario Sànchez Puccini (Bruxelles VUB, December 15).
M. Südholthas taken part in three PhD evaluation committees: Oscar Gonzales (VU Brussel, Belgium and U. Los Andes, Colombia; 17 July), Fan Yan (TU Denmark, 25 Oct.), Laurent Huber (Irisa, 17 Dec.).
P. Cointewas a member of the AERES visiting committee for LIRMM and IRCAM. He served in four selection/hiring committees (EMN, Polytech'Nantes and University of Nantes) for associate and full professor positions.
He acted as an expert for the ANR International White Program 2010 call.
T. Ledouxwas a member of selection committees for hiring new assistant professors in Computer Science at University of Rennes and University of Nantes. He was member of the selection committee for hiring new post-docs in INRIA Rennes-Bretagne Atlantique. Finally, he acted as an expert for the ANR Arpege 2010 call.
J.-M. Menaudacted as an expert for the ANR ARPEGE 2010 and ANR International White Program 2010 call.
J-C. Royer:acted as an expert for the ANR Blanc 2010 call.
MSc ALMA:Jean-Claude Royer did a lecture to students of the ALMA master on software product lines.
M. Südholt was responsible for the AOSD specialization module (2nd year). He as well as Thomas Ledoux, J.-M. Menaud et J. Noyé taught in this module.
MSc MRI-IFSIC:Adrien Lèbre did lectures to students of the MRI master (University of Rennes).
P. Cointe: He is the head of the LINA computer
science laboratory (UMR 6241)
http://
T. Ledoux: He is a member of the board of the Regional Doctoral School STIM. He is a member of the board of Follow-up committee of the PhDs thesis at LINA. Finally, he is member of the administrative committee of the INRIA Rennes-Bretagne Atlantique.
J.-M. Menaudis the deputy of the computer science department at Ecole des Mines de Nantes, in charge of the scholarship program.
M. Südholt: He has served on the CR hiring committee of INRIA Rennes, Bretagne Atlantique. Furthermore, he is a member of the council of the Laboratoire Informatique de Nantes Atlantique(LINA, UMR 6241). He also serves on the selection and evaluation committee of the competitiveness cluster Images & Réseaux. Finally, he is a member of the governing board of the European Network of Excellence in AOSD.