Formal specification and verification of distributed component systems
Institution:
NiceDisciplines:
Directors:
Abstract EN:
Components are self-contained building blocks. They communicate through well-defined interfaces, that set some kind of contract. This contract must guarantee the behavioural compatibility of bound interfaces. This is particularly true when components are distributed and communicate through asynchronous method calls. This thesis addresses the behavioural specification of distributed components. We develop a formal framework that allows us to build behavioural models. After abstraction, these models are a suitable input for state-of-the-art verification tools. The main objective is to specify, to verify, and to generate safe distributed components. To this aim, we develop a specification language close to Java. This language is built on top of our behavioural model, and provides a powerful high-level abstraction of the system. The benefits are twofold: (i) we can interface with verification tools, so we are able to verify various kinds of properties; and (ii), the specification is complete enough to generate code-skeletons defining the control part of the components. Finally, we validate our approach with a Point-Of-Sale case-study under the Common Component Model Example (CoCoME). The specificities of the specification language proposed in this thesis are: to deal with hierarchical components that communicate by asynchronous method calls; to give the component behaviour as a set of services; and to provide semantics close to a programming language by dealing with abstractions of user-code.
Abstract FR:
Les composants sont des blocs logiciels qui communiquent par des interfaces bien définies. Ces interfaces définissent un contrat avec l'environnement. Ce contrat doit garantir la compatibilité comportementale des interfaces. Cette compatibilité est en particulier importante quand des composants sont distribués et communiquent par des méthodes asynchrones. Cette thèse se base sur les spécifications comportementales des composants distribués. Nous développons un cadre formel qui nous permet de construire des modèles comportementaux pour ces composants. Après une phase d'abstraction, ces modèles peuvent être utilisés en entrée pour des outils de vérification modernes. L'objectif principal est de spécifier, vérifier et au final de produire des composants distribués avec un comportement garanti. Pour ce faire, nous développons une langage de spécifications proche de Java. Ce langage est établi sur notre modèle comportemental, et fournit une abstraction puissante de haut niveau du système. Les avantages sont les suivants: (i) nous pouvons nous connecter avec des outils de vérification: ainsi nous sommes capables de vérifier plusieurs sortes de propriétés ; et (ii), les spécifications sont assez complètes pour produire des squelettes de code de contrôle des composants. Finalement, nous validons notre approche avec un cas d'étude à l'aide d'un exemple commun de système à composants (``Common Component Model Example (CoCoME)''). Les particularités du langage proposé sont : traiter des composants hiérarchiques qui communiquent par des appels de méthodes asynchrones; donner le comportement d'un composant comme l'ensemble de services; utiliser une sémantique proche d'un langage de programmation; et traiter des abstractions de code utilisateur.