Implémentation rigoureuse des systèmes temps-réels

Rigorous Implementation of Real-Time Systems

• Auteur / Autrice : Tesnim Abdellatif
• Direction : Joseph Sifakis
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 05/06/2012
• Etablissement(s) : Grenoble
• Ecole(s) doctorale(s) : École doctorale mathématiques, sciences et technologies de l'information, informatique (Grenoble ; 199.-....)
• Partenaire(s) de recherche : Equipe de recherche : VERIMAG
• Jury : Président / Présidente : Roland Groz
• Jury : Examinateurs / Examinatrices : Joseph Sifakis, François felix Ingrand, Wang Yi, Jacques Combaz
• Jury : Rapporteurs / Rapporteuses : Sanjoy Baruah, Eugene Asarin

Mots clés

Mots clés libres

Systèmes à base de composants

Vérification

Programmation temps-rée

Ordonnancement

Systèmes adaptatifs

Systèmes temps-réel

Component-based systems

Verification

Real-time programming

Scheduling

Adaptive systems

Real-time operating systems

Résumé

Les systèmes temps-réels sont des systèmes qui sont soumis à "des contraintes de temps", comme par exemple le délais de réponse d'un système à un événement physique. Souvent les temps de réponse sont de l'ordre du milliseconde et parfois même du microseconde. Construire des systèmes temps-réels nécessite l'utilisation de méthodologies de conception et de mise en œuvre qui garantissent la propriété de respect des contraintes de temps, par exemple un système doit réagir dans les limites définies par l'utilisateur tels que les délais et la périodicité. Un délai non respecté dans systèmes temps-réel critique est catastrophique, comme par exemple dans les systèmes automobiles. Si un airbag se déclanche tard dans un accident de voiture, même quelques millisecondes trop tard peuvent conduire à des répercussions graves. Dans les systèmes temps-réels non critiques, une perte significative de performance et de QoS peuvent se produire, comme par exemple dans les réseaux de systèmes multimédia. Contribution: Nous fournissons une méthode de conception rigoureuse des systèmes temps-réel. L'implèmentation est générée à partir d'une application logicielle temps-réel et une plate-forme cible, en utilisant les deux modèles suivants: * Un modèle abstrait représentant le comportement de l'application logicielle en temps réel sous forme d' un automate temporisé. Celui-ci décrit des contraintes temporelles définies par l'utilisateur qui sont indépendantes de la plateforme. Ses transitions sont intemporelles et correspondent à l'exécution des différentes instructions de l'application. * Un modèle physique représentant le comportement du logiciel en temps réel s'exécutant sur une plate-forme donnée. Il est obtenu par l'attribution des temps d'exécution aux transitions du modèle abstrait. Une condition nécessaire pour garantir l'implémentabilité dy système est la "time-safety", c'est à dire, toute séquence d'exécution du modèle physique est également une séquence d'exécution du modèle abstrait. "Time-safety" signifie que la plate-forme est assez rapide pour répondre aux exigences de synchronisation de l'application. Comme les temps d'exécution des actions ne sont pas connus avec exactitude, "time-safety" est vérifiée pour les temps d'exécution pire cas es actions en faisant l' hypothèse de la robustesse. La robustesse signifie que la "time-safety" est préservée lorsqu'on augmente la vitesse de la plate-forme d'exécution. Pour des logiciels et plate-forme d'exécution correspondant à un modèle robuste, nous définissons un moteur d'exécution qui coordonne l'exécution du logiciel d'application afin de répondre à ses contraintes temporelles. En outre, en cas de non-robustesse, le moteur d'exécution permet de détecter les violations de contraintes temporelles en arrêtant l'exécution. Nous avons mis en place le moteur d'exécution pour les programmes BIP. Nous avons validé la méthode pour la conception et la mise en œuvre du robot Dala. Nous montrons les avantages obtenus en termes d'utilisation du processeur et l'amélioration de la latence de la réaction.

Context: Real-time systems are systems that are subject to "real-time constraints"— e.g. operational deadlines from event to system response. Often real-time response times are understood to be in the order of milliseconds and sometimes microseconds. Building real-time systems requires the use of design and implementation methodologies that ensure the property of meeting timing constraints e.g. a system has to react within user-defined bounds such as deadlines and periodicity. A missed deadline in hard real-time systems is catastrophic, like for example in automotive systems, for example if an airbag is fined too late in a car accident, even one ms too late leads to serious repercussions. In soft real-time systems it can lead to a significant loss of performance and QoS like for example in networked multimedia systems. Contribution: We provide a rigorous design and implementation method for the implementation of real-time systems. The implementation is generated from a given real-time application software and a target platform by using two models: * An abstract model representing the behavior of real-time software as a timed automaton. The latter describes user-defined platform-independent timing constraints. Its transitions are timeless and correspond to the execution of statements of the real-time software. * A physical model representing the behavior of the real-time software running on a given platform. It is obtained by assigning execution times to the transitions of the abstract model. A necessary condition for implementability is time-safety, that is, any (timed) execution sequence of the physical model is also an execution sequence of the abstract model. Time-safety means that the platform is fast enough to meet the timing requirements. As execution times of actions are not known exactly, time-safety is checked for worst-case execution times of actions by making an assumption of time-robustness: time-safety is preserved when speed of the execution platform increases. For given real-time software and execution platform corresponding to a time-robust model, we define an execution Engine that coordinates the execution of the application software so as to meet its timing constraints. Furthermore, in case of non-robustness, the execution Engine can detect violations of time-safety and stop execution. We have implemented the execution Engine for BIP programs with real-time constraints. We have validated the method for the design and implementation of the Dala rover robot. We show the benefits obtained in terms of CPU utilization and amelioration in the latency of reaction.