Cet article s'intéresse à la spécification formelle, à la conception et à l'implantation des composants comportementaux des interfaces graphiques utilisateurs. Les séquences plus ou moins complexes des événements et des actions constituant le dialogue entre l'utilisateur et l'interface sont spécifiés sous forme de grammaires attribuées et plus précisemment de grammaires de communications VEG (Visual Event Grammar). La spécification en VEG est complètement indépendante de l'apparence de l'interface ce qui permet de l'intégrer avec différentes apparences (Gtk, Swing, AWT, ...) mais aussi du langage de programmation de l'application (C, C++, Java, ...). De plus cette spécification peut être vérifié avec le vérificateur de modèle SPIN afin de tester sa consistance mais aussi sa correction et ainsi de détecter les interblocages ou les états qui sont inatteignables, mais aussi pour générer des tests afin de valider certains comportements. En utilisant des analyseurs syntaxiques, du code efficace est généré et des applications de tailles importantes (application médicale, librairie de construction de graphe, ...) peuvent être développées et ne souffrent pas de la comparaison avec des applications développées à la main. A l'aide de l'ensemble de ces outils, des gains importants sont réalisés concernant la détection des erreurs et leur correction (fourniture de contre exemples par SPIN), généricité vis à vis de l'apparence de l'application, etc.

Cet article présente un nouvel outil de manipulation de classes Java conçu pour la génération et la manipulation dynamiques du code. Ces deux techniques sont très utiles pour la réalisation de systèmes adaptables. Contrairement aux différentes approches existantes (SERP, BCEL, etc), ASM utilise une approche originale en exploitant le patron de conception Visiteur sans représenter explicitement l'arborescence visitée sous forme d'objets. Les performances obtenues grâce à cette technique sont bien supérieures à celles des outils existants. Néanmoins, l'idée principale d'ASM est d'optimiser au maximum les opérations les plus souvent effectuées, et de fait certaines opérations restent coûteuse en temps.

De nombreux styles architecturaux ont été formalisés afin de répondre à des contraintes de stabilité et de coût de développement d'applications (notamment les applications réseaux). Certains définissent un ensemble de règles permettant de composer un système à partir de composants et de connecteurs. L'un des styles les plus courants pour des applications distribuées à monté en charge importante est l'approche dîte événementielle. Dans cette approche, les composants vont communiquer en publiant ou en réceptionnant de façon asynchrone des notifications d'événements. Une notification étant propagée à l'ensemble des composants déclarés intéressé par celle-ci. Cette approche est très intéressante car un composant peut opérer dans le système sans avoir de connaissance sur les autres composants, et il est très facile d'ajouter ou de supprimer un composant (il n'y a aucune conséquence pour les autres composants). Cet article identifie les variations au style événementiel introduit par différentes implantations et met en avant leurs avantages et leurs inconvénients.

Il existe deux approches différentes pour arriver à implanter un protocole suffisament performant pour des réseaux haut débit. La première est l'optimisation manuelle du code (prédiction de branches, l'inline de fonctions, etc). La seconde est la configuration du protocole, c'est-à-dire l'implantation du protocole selon des paramètres dépendant de l'application, du matériel ou de la technologie du réseau sous-jacent. Il est intéressant de remarquer que les performances d'un protocole obtenu à partir d'une configuration peut être amélioré par les techniques manuelles (décrites auparavant), mais il est inutile de le faire du fait d'une variété importante des configurations possibles (multiplication du temps et de l'effort fourni). Il est donc intéressant de pouvoir automatiser l'application des optimisations sur le code obtenue par configuration du protocole.

Un compilateur de protocole prend en entré une spécification abstraite et génére une implantation de celui-ci. Généralement le code ainsi produit est inefficace en terme de vitesse et de taille. Cet article présente la combinaison de deux techniques permettant de générer du code efficace. La première est la génération d'un automate unique au lieu de plusieurs automates indépendants, et la seconde applique des techniques d'optimisation sur cet automate (plus exactement sur les différentes branches le constituant).

A l'heure actuelle, les implantations des différents protocoles sont des goulets d'étranglements pour les réseaux. Cet article présente une technique permettant d'améliorer leurs performances, il s'agit de la prédiction d'en-tête. Celle-ci correspond à l'optimisation du chemin commun en rajoutant une copie du code lui correspondant. Mais en réalisant cette optimisation manuellement des problèmes de coûts apparaissent (augmentation de la taille du code, difficulté de générer un code correct, ...). Cet article propose donc une approche automatique de la prédiction d'ent-tête en utilisant un compilateur de protocole. Le but étant de réorganiser le code généré afin d'obtenir les bénéfices de la prédiction sans augmentation des coûts.

Cet article réalise un résumé des techniques mathématiques utilisées pour la spécification et la vérification de systèmes complexes (matériels ou applications). L'un des problèmes majeurs auquel doit faire face ces techniques provient de la taille et de la complexité sans cesse croissantes des applications. De plus, il faut que les spécifications formelles, c'est-à-dire la description d'un système et de ces propriétés souhaitées, doivent être accessibles aux concepteurs d'applications (idéalement le plus proche possible du langage de développement). De plus, il faut que cette spécification reflète réellement le système, et pour se faire il faut utiliser des techniques automatiques permettant d'obtenir une spécification à partir d'une application (raffinage) ou une application à partir d'une spécification (génération). Une seconde étape est de vérifier les propriétés en utilisant deux techniques bien distinctes (que l'on peut combiner ?) : la vérification de modèles et la preuve de théorêmes. L'illustration des différentes techniques et des différents utilitaires existants est réalisée au travers quelques utilisations dans l'industrie. Enfin, cet article présente quelques voies possibles de recherches dans le domaine des méthodes formelles passant nécessairement par la définition de nouveaux langages de spécification et de nouvelles techniques de vérification.

Les événements sont meilleurs que les threads pour la gestion concurrente des différentes entrées / sorties, mais ils offrent aussi une plus grande stabilité de performance sous une forte charge. Néanmoins, ceux-ci présentent quelques désavantages dont notamment un nombre important d'allocation dynamique, une difficulté de programmation et une incapacité de tirer avantage des architectures multi-processeurs. Ce papier présente une librairie d'entrées / sorties non bloquantes permettant de faciliter la programmation d'applications événementielles, mais aussi de tirer avantage des architectures SMP. Ainsi les événements fournissent pratiquement tous les avantages proposés par les threads avec une plus grande robustesse (abscence entre autre des data races ou des interblocages).

Ce livre constitue le principal manuel de référence de l'utilitaire SPIN. Il couvre notamment la spécification du langage Promela qui permet de décrire un modèle représentant une application concurrente et de vérifier des propriétés de vivacité, d'atteignabilité, ... (à l'aide entre autre de logiques temporelles linéaires). Il présente aussi les bases théoriques de la vérification de modèle (recherche en largeur et en profondeur, optimisation de la recherche, extraction d'un modèle à partir du code source, réduction de l'espace des états, ...) qui est l'une des techniques utilisables pour la vérification d'une application (les deux autres étant le test de l'application ou la preuve de théorèmes). La technique du « model checking » est complètement automatique (il faut tout de même élaborer un modèle représentant l'application ainsi que de formaliser les propriétés que l'on souhaite vérifier) tandis que la preuve de théorème nécessite la construction de la preuve et les tests interviennent après la phase de conception de l'application. Il faut tout de même noter que la construction d'un modèle est une étape difficile à formaliser et de plus le modèle obtenue n'est pas fortement lié à l'application qu'il doit représenter (ce n'est qu'une « interprétation » formelle d'une application).

Cet article émet comme postulat qu'il existe une dualité entre les deux structures (orienté procédures ou orienté messages) possibles des systèmes d'exploitation modernes. La première catégorie est caractérisée par un nombre important de petit processus qui varie très rapidemment dans le temps, accompagné d'un mécanisme de synchronisation basé sur des données partagées. La seconde quant à elle est caractérisée par un petit nombre statique de gros processus qui communiquent entre eux par des messages explicites. A partir de modèle abstrait tiré de chacune de ces catégories, il est montré qu'un programme respectant strictement l'une ou l'autre des deux catégories à une contrepartie directe dans l'autre. La transformation utilisée afin d'obtenir le dual d'un programme va conserver la structure et les performances du programme source. Il faut noter tout de même que pour conserver les performances, les opérations primitives d'une catégorie doivent être aussi efficaces que les primitives de l'autre (les auteurs considérent ainsi sans preuve qu'il est possible de développer les primitives des deux catégories de manière efficace).

A l'heure actuelle, les serveurs Internet doivent faire face à une extrème variabilité de la charge et notamment évaluer le pic de charge potentiellement atteignable. Les architectures doivent prendre en compte ce phénomène de variation et proposer un contrôle et donc une adaptation de la concurrence interne au serveur. Ainsi, il est nécessaire de développer des architectures à composant permettant de faciliter le développement de tels serveurs. Cet article propose DMonA, une architecture basée sur DiPS, qui sépare les fonctionnalités du serveur des autres aspects, tels que la concurrence, la communication inter-composant, etc. Elle propose ainsi un observateur et un gestionnaire permettant de détecter les goulets d'étranglements (plus particulièrement le plus gros goulets d'étranglements) propose des solutions à ce problème en fonction de stratégies définies et les déploient « à la volée ». Les résultats obtenus montrent que cette adaptation offre de meilleurs résultats que ceux d'une approche traditionnelle, c'est-à-dire sans adaptation.

Keywords: component architecture, concurrency, self-adaptation

Cet article présente un utilitaire pour mesurer les performances de serveurs Web. Il présente une forte flexibilité dans la génération du traffic HTTP et dans les techniques utilisées pour mesurer les performances des serveurs. Ainsi, le but principal de cet utilitaire n'est pas d'implanter un utilitaire de « benchmark » particulier mais plutôt de fournir un outils robuste, performant facilitant la construction de « benchmarks » à différents niveaux. Httperf s'illustre notamment par sa robustesse (car il génére et soutient une charge importante), supporte le protocol HTTP/1.1 et enfin par son extensibilité (plus particulièrement, dans la génération du traffic Web et dans les techniques utilisées pour mesurer les performances du ou des serveurs). Cet outil est de plus très intéressant par son architecture événementielle entre ces différents composants (on citera pour exemple la partie traitant du protocol HTTP, celle générant le traffic et enfin la partie s'occupant de collecter et de traiter les différentes mesures).

Cet article présente une nouvelle architecture de serveur Web nommée Asymemetric Multi-Process Event-Driven ainsi que des architectures plus classiques utilisant plusieurs processus (Multi Process) ou plusieurs threads (Multi Threads) ou bien utilisant un seul processus de traitement événementiel (Single Process Event-Driven). Dans un second temps, différentes techniques d'optimisation sont présentées, plus spécifiquement différents caches pour la translation de chemin, les en-têtes des réponses et les fichiers mappés en mémoires. Dans ce dernier cas, les fichiers sont inclus dans des blocs de tailles fixes, il y a donc division en plusieurs blocs des fichiers trop gros. Enfin, une évaluation et une comparaison de cette nouvelles architecture est donnée, celle-ci montrant qu'il y a une amélioration des performances de 30% en comparaison avec Zeus et de 50% en comparaison avec Apache.

L'exécution d'un programme sur une ou plusieurs machines nécessitent des espaces d'adressage. En utilisant une technique par compilation, ce papier présente une approche permettant de réduire de tel coût. Plus particulièrement, en réduisant le nombre d'appels systèmes sur une unique machine, en introduisant la notion de multi appel. Les résultats obtenus montrent que cette approche permet d'améliorer les performances d'un programme.

Le but de ce rapport technique est de contribuer aux techniques permettant de prendre en compte l'évolution des protocoles de communication au sein d'applications. C'est-à-dire, permettre aux applications de supporter des modifications apportées dynamiquement à un protocole. Pour se faire, il est nécessaire d'isoler les détails syntaxiques du protocole de ses concepts sémantiques, qui vont être manipulés à l'intérieur des différents composants. La syntaxe d'un protocole va être spécifiée formellement en 4 parties : les tokens, la structure des messages, le mode d'envoie des messages et la séquence des messages.

Le but de rapport technique est de proposer un framework pour le développement de service Internet hautement concurrent. Ces services nécessitent de gérer des informations sur les flots d'informations mais aussi de maintenir un pic de bande passante même lorsque que les demandes excédent les possibilités des resources disponibles. Beaucoup d'approches pour le développement de tels systèmes ont été proposées et se divisent pour la plupart en deux catégories distinctes : les architectures événementielles et celles utilisant des processus légers. Dans ce rapport, il est considéré que ces deux catégories sont aux extrémités d'un large spectre et que la meilleure implantation se situe entre les deux. Pour faciliter le développement d'une telle architecture, trois composants (atomiques pour l'architecture) sont pris en considération : les tâches, les files et les pools de processus légers. De plus, afin de transformer une application en une implantation utilisant ces composants, un ensemble de patrons de conception est présenté. Enfin, une analyse de différents systèmes construits en utilisant ce framework est présenté et permet d'illustrer les bénéfices obtenus lors de l'élaboration d'une application concurrente.

Le but de cet article est de proposer une nouvelle architecture pour le développement de service Internet hautement concurrent, nommée Staged Event-Driven Architecture. Cette architecture peut supporter des demandes massivement concurrentes et simplifier le développement de services Internet. Ainsi, SEDA utilise l'approche événementielle qui permet de représenter une application comme étant un réseau d'états connectés explicitement par des files des événements en attentes. Du fait d'une variation importante de la charge (dépendant de différents paramètres), SEDA utilise des contrôleurs afin de gérer dynamiquement les resources et plus particulièrement les processus légers utilisés (adaptation du modèle de concurrence en fonction de la charge). Afin de montrer les avantages de SEDA, deux services Internent sont développés, le premier est un serveur HTTP tandis que le second est un servent Gnutella. Les résultats ainsi obtenus montrent que SEDA présente de meilleurs performances que les services plus traditionnels et supporte bien les variations de la charge.