Accueil > Manifestations > Thèses et HDR > Thèses > Jurgen Van Ham

Jurgen Van Ham

Directeur de thèse

Mira Mezini
Pierre Cointe
Jacques Noyé

Résumé

L’utilisation de concepts avancés de programmation concurrente permet de dépasser les inconvénients de l’utilisation de techniques de bas niveau à base de verrous ou de moniteurs. Elle augmente le niveau d’abstraction, libérant les programmeurs d’applications concurrentes d’une focalisation excessive sur des détails. Cependant, avec les approches actuelles, la logique nécessaire à la mise en place de schémas de coordinations complexes est fragmentées en plusieurs points de l’application sous forme de « join patterns », de notifcations et de la logique applicative qui crée implicitement des dépendances entre les canaux de communication et donc, indirectement, les « join patterns » (qui défnissent ces canaux). Nous présentons JESCALA, un langage qui capture les schémas de coordination (d’une application concurrente) d’une manière plus expressive et modulaire, en s’appuyant sur l’intégration fne d’un système d’évènements avancé et des « join patterns ». Nous implémentons des machines à états fnies à partir de « joins » à l’aide de JESCALA et introduisons un langage dédié à la défnition de ces machines à états permettant d’en obtenir des implémentations plus effcaces. Nous validons notre approche avec des études de cas et évaluons l’effcacité de son exécution. Nous comparons la performance de trois implémentations d’une machine à états. Nous validons enfn l’idée d’un moniteur d’évènements en créant un programme JESCALA concurrent à partir d’un découpage d’un programme séquentiel.

Mots clés : Scala, programmation par évènements, concurrence, « Join Patterns »

Abstract :

The advanced concurrency abstractions provided by the Join calculus overcome the drawbacks of low- level techniques such as locks and monitors. They rise the level of abstraction, freeing programmers that implement concurrent applications from the burden of concentrating on low-level details. However, with current approaches the coordination logic involved in complex coordination schemas is fragmented into several pieces including join patterns, data emissions triggered in different places of the application, and the application logic that implicitly creates dependencies among channels, hence indirectly among join patterns. We present JESCALA, a language that captures coordination schemas in a more expressive and modular way by leveraging a seamless integration of an advanced event system with join abstractions. We implement Joins-based state machines using JESCALA and introduce a domain specifc language for fnite state machines that make faster alternative implementations possible. We validate our approach with case studies and we provide a frst performance assessment. We compare the performance of three different implementations of a fnite state machine. Finally, we validate the idea of constructing a concurrent JESCALA program by using the parts of a sequential Event-Based program in combination with an events-monitor, a component that synchronizes handling of multiple events.

Keywords : Scala, Event-driven Programming, Concurrency, Join Patterns

Composition du jury :

  • Wolfgang DE MEUTER, Professeur, Vrije Universiteit Brussel, Rapporteur
  • Christophe DONY, Professeur, Université de Montpellier-II, Rapporteur
  • Ulf BREFELD, Professeur, Technische Universität Darmstadt, Examinateur
  • Patrick EUGSTER, Professeur, Technische Universität Darmstadt, Examinateur
  • Reiner HÄHNLE, Professeur, Technische Universität Darmstadt, Examinateur
  • Pierre COINTE, Professeur, École des Mines de Nantes, Directeur de thèse
  • Mira MEZINI, Professeur, Technische Universität Darmstadt, Co-directrice de thèse
  • Jacques NOYÉ, Maître-Assistant, École des Mines de Nantes, Co-encadrant

Dernière modification : jeudi 12 mars 2015