O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Solutions temps réel sous Linux

Book Description

Présentation
Comprendre le fonctionnement de l'ordonnanceur et du noyau

Pour concevoir un système équilibré, stable et réactif aux événements externes, il est indispensable de bien comprendre le rôle et l'organisation de ses divers composants. C'est l'un des premiers buts de ce livre, qui détaille et commente les interactions, les activations et les commutations des tâches. De très nombreux exemples illustrant le propos permettront au lecteur de réaliser ses propres expériences sur son poste Linux.

Bâtir un système temps réel sous contraintes temporelles fortes

Pour construire une application temps réel sous Linux, l'architecte logiciel doit choisir entre différentes solutions, un choix crucial qui influera sensiblement sur les limites de fonctionnement de son application. Dans cet ouvrage, l'auteur étudie les environnements libres pouvant répondre à des contraintes temporelles plus ou moins fortes et propose des outils pour valider le comportement des tâches face à des charges logicielles ou interruptives importantes.

À qui s'adresse cet ouvrage ?
  • Aux développeurs, architectes logiciels et ingénieurs devant mettre en oeuvre des applications temps réel sous Linux
  • Aux décideurs et industriels souhaitant installer un système temps réel sous Linux
  • Aux étudiants en informatique

Sur le site http://christophe.blaess.fr

  • Téléchargez le code source des exemples
  • Consultez les corrigés des exercices et de nombreux documents complémentaires
  • Dialoguez avec l'auteur
Au sommaire
  • Multitâche et commutation
  • Interruptions, exceptions et appels système
  • Ordonnancement temps partagé et priorités
  • Limitations de l'ordonnancement temps partagé
  • Principes du temps réel
  • Performances du temps réel souple
  • Problèmes temps réel classiques
  • Limites et améliorations du temps réel Linux
  • Extensions temps réel de Linux
  • Programmer avec Xenomai
  • Traitement des interruptions
  • Conclusion - Etat des lieux et perspectives
  • A - Compilation d'un noyau
  • B - Bibliographie

Table of Contents

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