Solutions temps réel sous Linux

Solutions temps réel sous Linux

Ce livre est disponible depuis mai 2012, une seconde édition est parue en novembre 2015. Il traite des solutions libres permettant d’obtenir un comportement temps réel souple (soft real time) ou strict (hard real time) avec Linux. Les thèmes abordés recouvrent : le multitâche, l’ordonnancement temps partagé et temps réel souple du noyau Linux standard, le patch PREEMPT_RT qui permet d’améliorer le comportement du noyau standard et l’extension Xenomai pour accéder aux performances temps réel strict. Un rapide aperçu du fonctionnement d’un driver et de la gestion des interruptions est proposé pour étendre les fonctionnalités temps-réel.

Dans la seconde édition, les exemples manipulant des signaux d’entrée-sortie sont construits sur Raspberry Pi.

Exemples

Il existe une soixantaine d’exemples dans le livre, dont les codes sources se trouvent ici, les exemples de la première édition  sont ici.

Corrigés des exercices

Une cinquantaine d’exercices sont proposés pour valider les concepts abordés. Les solutions sont disponibles ici.

Commander sur Amazon

 

Solutions temps réel sous Linux

Version PDF sur iziBook

Solutions temps réel sous Linux De Christophe Blaess - Eyrolles
Solutions temps réel sous Linux

Sommaire

  • Chapitre 1 – Multitâche et commutation
    • Multitâche sous Linux
      • Création de processus
      • Parallélisme multithreads
    • Systèmes multiprocesseurs
      • Multiprocesseurs, multicœurs et hyperthreading
      • Affinité d’une tâche
    • États des tâches
      • Ordonnancement
      • Préemption
  • Chapitre 2 – Interruptions, exceptions et appels système
    • Mode noyau
    • Interruptions
      • Principe
      • Entrées-sorties sans interruptions
      • Entrées-sorties avec interruptions
      • Interruptions sous Linux
      • Routage des interruptions
    • Exceptions
      • Principe
      • Fichier core
    • Appels système
      • Suivi d’un appel système
    • Threads du noyau
  • Chapitre 3 – Ordonnancement temps partagé et priorités
    • Temps partagé
      • Principes
      • Ordonnanceur historique
      • Ordonnanceurs du noyau 2.6
      • Ordonnanceur CFS
      • Groupes de processus
      • Autres ordonnanceurs
    • Configuration des priorités
      • Courtoisie des processus
      • Priorités entre threads
  • Chapitre 4 – Limitations de l’ordonnancement temps partagé
    • Mesure du temps
      • Heure Unix avec gettimeofday()
      • Précision des mesures
      • Horloges Posix
    • Tâches périodiques
      • Timers Unix classiques
      • Timers Posix
      • Granularité
      • Précision
    • Préemption des tâches
  • Chapitre 5 – Principes du temps réel
    • Définitions
      • Temps réel
      • Temps réel strict
      • Temps réel souple
      • Rôles respectifs
    • Traitement direct dans le noyau
      • Traitement des interruptions
    • Temps réel sous Linux
      • Échelle des priorités
      • Configuration de l’ordonnancement
      • Processus temps réel
      • Garde-fou temps réel
      • Threads temps réel
      • Threads en Round Robin
      • Rotation sans Round Robin
      • Temps réel depuis le shell
  • Chapitre 6 – Performances du temps réel souple
    • Timers temps réel
      • Précisions et fluctuations
      • Granularité des timers
      • Conclusion sur les timers
    • Temps de commutation
      • Commutation entre threads
      • Commutations entre processus
      • Comparaison processus et threads
      • Imprévisibilités dues à la mémoire virtuelle
    • Préemptibilité du noyau
      • Principes
      • Préemptibilité du noyau standard
      • Connaître la configuration d’un noyau
      • Expériences sur la préemptibilité
  • Chapitre 7 – Problèmes temps réel classiques
    • Démarrage en Round Robin
      • Barrières Posix
    • Inversion de priorité
      • Principe
      • Héritage de priorité
    • Prise de mutex
      • Comportement en temps réel
      • Reprise de mutex en temps réel
      • Solutions
      • Appel explicite à l’ordonnanceur
  • Chapitre 8 – Limites et améliorations du temps réel Linux
    • Traitement des interruptions
    • Linux-rt
      • Threaded interrupts
      • Fully preemptible kernel
    • Outils de mesure des performances
      • Cyclictest
      • Hwlatdetect, Hackbench…
    • Économies d’énergie
      • Variation de fréquence d’horloge
      • Heuristique performance
      • Heuristique powersave
      • Heuristique ondemand
  • Chapitre 9 – Extensions temps réel de Linux
    • Les nanokernels temps réel
      • Principes
      • RTLinux
      • RTAI et Adeos
      • Xenomai
      • Interface de programmation
    • Installation de Xenomai
      • Modification du noyau Linux
      • Compilation de Linux modifié
      • Compilation de Xenomai
    • Expériences avec Xenomai
      • Première exploration
      • Programmes de tests
  • Chapitre 10 – Programmer avec Xenomai
    • Programmation de tâches simples
      • Principes
      • Initialisation du processus
      • Création de tâche
      • Compilation et exécution
      • Processus unithread
      • Recherche des changements de modes
    • Alarmes et tâches périodiques
      • Réveils périodiques
      • Alarmes
      • Watchdog
    • Synchronisation des tâches
      • Sémaphores
      • Mutex
  • Chapitre 11 – Traitement des interruptions
    • Programmation d’un driver
      • Squelette d’un module
      • Structure d’un driver
      • Traitement des interruptions
      • Traitement en threaded interrupt
    • Interruptions avec Xenomai
      • Real Time Driver Model
      • Interruptions avec RTDM
  • Conclusion – État des lieux et perspectives
    • Situation actuelle
      • Linux « vanilla »
      • Patch Linux-rt
      • Xenomai
      • Mesures
    • Perspectives
  • Annexe A – Compilation d’un noyau
    • Préparation des sources
    • Configuration de la compilation
      • Principes
      • Interfaces utilisateur
      • Options de compilation
    • Compilation et installation
      • Compilation croisée
      • Compilation native
  • Annexe B – Bibliographie
    • Livres
    • Articles
    • Sites web

18 Réponses

  1. Albert-Paul Bouillot dit :

    Le commentaire sur amazon.fr est pertinent : “Livre tout à fait remarquable…etc.”
    Je viens signaler un petit “bug” dans le programme pages 6/7 “exemple-threads.c” :
    3! n’est pas égal à 2 mais à 6
    5! = 120 et non 24 ainsi que 7! = 5040.

    Dans la ligne 18 il faut remplacer :
    for (i = 2; i < n; i ++) {
    par
    for (i = 2; i <= n; i ++) {

  2. Richard Besset dit :

    Bonjour,

    j’ai découvert votre livre tout récemment dans une librairie à Orléans, je précise que je ne suis pas développeur mais jeune technicien son actuellement en session de formation supérieur en audiovisuel. Cela fait 2ans que je me forme seul à la compréhension de l’administration des systèmes linux, en particulier sur les distributions ubuntu studio 10.04 (où basé sur celles-ci) pour des applications strictement audio/vidéo ou les performances par rapport à des systèmes propriétaires sont vraiment très très intéressante, et notamment grâce au linux-rt.
    C’est donc simplement en utilisateur curieux plus où moins “avancé” mais désireux d’aller plus loin peut-être pourquoi pas dans un but professionnel dans mon domaine que j’ai commencé à le lire.
    Je le trouve très clair, très abordable et me donne tout simplement envie de le continuer

  3. Sam dit :

    Bonjour M. Blaess,
    Existe-t-il une version ebook payante de vos ouvrages ?
    Merci d’avance

  4. Mohamed dit :

    Bonjour M Blaess,

    Je voulais vous remercier pour ce remarquable livre qu’on a tous attendu. Etant responsable dans une société d’ingénierie des systèmes embarqués, je vous assure que le contenu de votre livre est très précieux et est très intéressant surtout le mariage réussi entre la théorie et la pratique dans l’exposition des différents concepts. Des livres comme ça en Français nous manque tellement si vous le savez.
    Bon courage et j’espère qu’il y aura d’autres oeuvres pareils dans le futur.

    /mohamed

  5. Gorgonite dit :

    Bonjour,

    Félicitations pour cet ouvrage d’une grande qualité tant technique que pédagogique… c’est si rare d’avoir un ouvrage francophone qui puisse servir de référence. Encore bravo 😀

    Une remarque en passant, pourquoi toujours partir sur une notion de mesure pour l’aspect temps réel pour le “pire cas”. Souvent cette notion de pire cas n’est-elle justement pas mesurable en pratique ? N’est-ce pas la raison d’être de tous les travaux autour des WCET en analyse statique ?

    • cpb dit :

      Effectivement, il est nécessaire dans certains cas de déterminer, de calculer, statiquement le Worst-Case Execution Time. Par exemple des environnements où la criticité du domaine d’application est très élevée (aéronautique, nucléaire, etc.)

      Ceci peut se faire sur des systèmes que l’on contrôle parfaitement (micro-contrôleur, systèmes embarqués très restreints, etc.) On procède dans ce cas en déroulant toutes les boucles, en vérifiant tous les cas de fonctionnement, en prenant la durée d’exécution de chaque instruction assembleur…

      Ceci devient difficilement imaginable pour un système d’exploitation complet comme Linux, où cohabitent des tâches du kernel, des gestionnaires d’interruption, des services réseau, des entrées-sorties asynchrones sur les périphériques bloc, sans compter la gestion de la mémoire virtuelle, les migrations entre les cœurs ou les processeurs, etc. Il devient impossible de prouver le WCET d’une tâche comme l’exigeraient les contraintes de temps réel strict (hard realtime).

      En pratique, lorsque les contraintes d’application ne sont pas aussi strictes, on effectue généralement des mesures sous très forte charge, pendant des durées prolongées, et l’on applique souvent une marge de sécurité permettant de garantir un fonctionnement correct dans un environnement normalement chargé. C’est ce que l’on définit habituellement comme temps réel souple (soft realtime).

      Avec Linux seul ou Linux PREEMPT_RT, on ne peut pas prétendre à mieux que du temps réel souple. Avec Xenomai on accède au niveau de performances des systèmes temps réel stricts mais sans vraiment calculer le pire temps d’exécution (à cause de la complexité du noyau Linux sous-jacent), plutôt en le mesurant.

  6. Gorgonite dit :

    Effectivement, ma question concernait surtout Xenomai… 🙂
    Serait-ce dû à une habitude issue du monde Linux standard ou est-ce qu’il n’y a pas d’application assez critique ?

  7. Mouha dit :

    Bonjour,

    Pour ma part j’ai consulté ce livre chez Eyrolles et il m’a effectivement semblé clair. Cependant avant de l’acheter j’aimerai savoir 3 choses :
    – va-t-il y avoir une nouvelle édition bientôt ? .Etant donné qué j’ai eut ce cas avec votre livre sur la prog Linux et celui de P.Ficheux où j’ai du racheter la nouvelle édition.
    – Développeur PC et embarqué Arm j’ai besoin d’apprendre le temps réèl pour m’adapter au monde du travail, qui lui est sous VxWorks. Puis je considérer qu’en apprenant à développer sous Xenomai j’aurai peu ( voire pas) d’adaptation pour les appels sous VxWorks ?
    – Consjointement avec ce livre, quelle carte conseillez-vous actuellement ? (je possè la Pi, mini2440, TS-7260, I.mx53 QSB)

    Merci de vos réponses et de vos articles (ici et sur GLM)

    • cpb dit :

      Bonjour,

      Il n’y a pas de nouvelle édition prévue pour le moment, peut-être faudra-t-il quelques mises à jour lorsque Xenomai 3 sortira, mais rien n’est programmé actuellement.

      Il y a quand même des différences entre la programmation sous Linux/Xenomai et celle sous VxWorks. Je pense qu’il y a plus de travail pour passer de Xenomai à VxWorks que le contraire. Néanmoins grâce aux skins de Xenomai il est possible de se familiariser avec l’API d’autres systèmes dont VxMorks.

      Enfin, il est tout à fait possible de s’initier au temps réel avec de nombreuses cartes ARM dont celles que vous citez. Il est possible de réaliser beaucoup d’expériences sur PC. Lorsqu’on veut gérer des entrées/sorties (par GPIO par exemple) et des interruptions, le Raspberry Pi est un bon outil d’étude.

      • Mouha dit :

        Je vous remercie pour ces précisions qui me sont utiles. La commande est donc lancée pour mon initiation à Xenomai.

        Si je peux me permettre une autre question : je suis très intrigué que le projet Quantum Leaps (http://www.state-machine.com/index.php) ne soit jamais évoqué dans le monde libre GNU alors qu’il est sous license GPL.
        Pourtant comme Xenomai il s’intègre dans la plupart des OS/RTOS: de Linux à Windows, en passant par QNX, VxWorks,uC/OS-II, etc et pour quantité de cibles, même la PI http://www.state-machine.com/rasppi/index.php.
        Je suis donc surpris que ce projet n’est évoqué nulle part, même dans GNU/MF.

  8. David dit :

    Bonjour,

    Je souhaite compiler exemple-periodique-01.c depuis le makefile fourni mais que j’ai modifié pour utiliser des fonctions définies dans 2 autres fichiers utils.c et utils.h . A chaque fois que j’ai tenté de les ajouter au Makefile j’ai des erreurs, pouvez m’indiquer comment faire pour les ajouter svp ?

  9. David dit :

    Christophe,

    le but étant de pouvoir apprendre Xenomai en mesurant la latence de ma Beaglebone Black. J’ai donc pris exemple-periodique-01.c pour lui intégrer l’exemple du cours de Mark A. Yorder : https://github.com/MarkAYoder/BeagleBoard-exercises/tree/master/gpio/togglegpio.c qui fonctionne bien seul. Je l’ai renommé swith_GPIO.C
    Cette modification se trouve ici http://pastebin.com/b5mKPm6W et le makefile http://pastebin.com/jsgjSSLQ j’ai copié les 2 fichiers gpio-utils .c et .h dans le repertoire /home/Xenomai/CBLaess/chapitre-10/gpio-utils.

    Tout cela me donne l’erreur :
    gcc -lnative -L/usr/xenomai/lib -lxenomai -lpthread -lrt -l/home/Xenomai/CBLaess/chapitre-10/gpio-utils -lnative switch_GPIO.o -lnative -lxenomai -o switch_GPIO
    /usr/bin/ld: cannot find -l/home/Xenomai/CBLaess/chapitre-10/gpio-utils
    collect2: ld returned 1 exit status
    make: *** [switch_GPIO] Error 1

    • cpb dit :

      Avec gcc, l’option -l indique un nom de bibliothèque à utiliser lors de l’édition des liens (par exemple -lrt pour librt.so) donc il ne faut pas mettre l’argument -l/home/Xenomai/CBLaess/chapitre-10/gpio-utils
      Si le but est d’indiquer où se trouve le fichier objet à linker, on peut le précéder de son chemin.

      • David dit :

        Voici les quelques mesures sur la Beaglebone Black qui pourraient être intéressantes : http://flic.kr/ps/2LwUC9
        Dans mesures 1 j’ai mon Toggle_gpio sur GPIO 60 avec une tache périodique à 2000 uS tout en lançant une charge avec : ping -f localhost -s 65000 >/dev/null

        Dans mesures 2 j’ai mon Toggle_gpio sur GPIO 60 avec une tache périodique à 2000 uS tout en lançant une charge avec : ping -f localhost -s 65000 >/dev/null + latency_test -p 100 -T 240.

        Par ailleurs, pour comparer j’ai relancé pendant 1h un autre mesure latency seule mais en ayant précédemment fait un echo 0 > /proc/latency (au lieu de 4999 ) :
        lat min|—-lat avg|—-lat max|-overrun|—msw|—lat best|–lat worst
        11.083| 13.874| 24.416| 0| 0| 6.374| 32.791
        pourtant pas si mal.

        Je suis donc assez surpris des écarts entre les 2 mesures cela dit, même si elles sont en user-space.

  10. fabrice dit :

    Le livre est interessant mais quand meme,
    le principal manque !!!
    pourquoi ne pas avoir ajouté une toute petite page expliquant la compilation sous GCC,
    la ligne de commande necessaire, sa structure, sa syntaxe.

    dommage cet absence va faire fuir certain lecteurs.

URL de trackback pour cette page