Solutions en temps réel sous Linux

Auteur(s) :

Blaess, Christophe Découvrir l'auteur

Résumé

Comment tirer parti du noyau Linux et de ses extensions libres pour constituer un système capable de répondre à des contraintes temps réel, avec des exemples, des conseils et des astuces pour comprendre les mécanismes d'ordonnancement de Linux et obtenir les meilleures performances. A jour de la nouvelle version de Xenomai. Site compagnon avec les codes source et les corrigés des exercices. ©Electre 2019

Éditeur(s)
- Éditions Eyrolles
Date
- DL 2019
Autre(s) forme(s) de titre
- Solutions en temps réel sous Linux : : cas pratique : le Raspberry Pi 3
Notes
- La couv. porte en plus : "cas pratique : le Raspberry Pi 3"
- La 4ème de couv. porte en plus : Sur le site www.blaess.fr/christophe : téléchargez le code des exemples, consultez les corrigés des exercices et de nombreux documents complémentaires, dialoguez avec l'auteur"
Langues
- Français
Description matérielle
- 1 vol. (XV-302 p.) : ill. ; 23 cm
Sujet(s)
ISBN
- 978-2-212-67711-9
Indice
- 681.44(07) Systèmes d'exploitation Unix, Linux. Manuels
Quatrième de couverture
- 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 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. Augmentée et mise à jour, notamment avec la nouvelle version de Xenomai, la troisième édition a pour support d'expérimentation le nano-ordinateur Raspberry Pi 3.
  À 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
Tables des matières
- - Solutions en temps réel sous Linux
  - Christophe Blaess
  - Eyrolles
  - Avant-proposV
  - Chapitre 1
    Multitâche et commutation1
  - Multitâche sous Linux 1
  - Création de processus3
  - Parallélisme multithreads5
  - Systèmes multiprocesseurs 8
  - Multiprocesseurs, multicoeurs et hyperthreading8
  - Affinité d'une tâche11
  - États des tâches 18
  - Ordonnancement20
  - Préemption21
  - Conclusion 21
  - Points clés 22
  - Exercices 22
  - Exercice 1 (*)22
  - Exercice 2 (**)22
  - Exercice 3 (**)23
  - Exercice 4 (***)23
  - Chapitre 2
    Interruptions, exceptions et appels système25
  - Mode noyau 25
  - Interruptions 26
  - Principe26
  - Entrées-sorties sans interruptions27
  - Entrées-sorties avec interruptions28
  - Interruptions sous Linux29
  - Routage des interruptions30
  - Exceptions 32
  - Principe32
  - Fichier core33
  - Appels système 36
  - Suivi d'un appel système36
  - Threads du noyau 40
  - Conclusion 41
  - Points clés 41
  - Exercices 42
  - Exercice 1 (*)42
  - Exercice 2 (*)42
  - Exercice 3 (*)42
  - Exercice 4 (**)42
  - Exercice 5 (***)42
  - Chapitre 3
    Ordonnancement temps partagé et priorités43
  - Temps partagé 43
  - Principes43
  - Ordonnanceur historique46
  - Ordonnanceurs du noyau 2.647
  - Ordonnanceur CFS48
  - Groupes de processus49
  - Autres ordonnanceurs53
  - Configuration des priorités 53
  - Courtoisie des processus53
  - Priorités entre threads55
  - Conclusion 57
  - Points clés 57
  - Exercices 57
  - Exercice 1 (*)57
  - Exercice 2 (*)58
  - Exercice 3 (**)58
  - Exercice 4 (***)58
  - Exercice 5(***)58
  - Chapitre 4
    Limitations de l'ordonnancement temps partagé59
  - Mesure du temps 59
  - Heure Unix avec gettimeofday()60
  - Précision des mesures60
  - Horloges Posix62
  - Tâches périodiques 65
  - Timers Unix classiques66
  - Timers Posix67
  - Granularité70
  - Précision72
  - Préemption des tâches 81
  - Conclusion 84
  - Points clés 84
  - Exercices 84
  - Exercice 1 (*)84
  - Exercice 2 (**)84
  - Exercice 3 (**)85
  - Exercice 4 (***)85
  - Exercice 5 (***)85
  - Chapitre 5
    Principes du temps réel87
  - Définitions 87
  - Temps réel87
  - Classes de temps réel88
  - Temps réel absolu88
  - Temps réel strict89
  - Temps réel strict certifiable89
  - Temps réel strict non certifiable90
  - Temps réel souple90
  - Rôles respectifs92
  - Traitement direct dans le noyau 92
  - Traitement des interruptions95
  - Temps réel sous Linux 96
  - Échelle des priorités96
  - Configuration de l'ordonnancement98
  - Processus temps réel100
  - Garde-fou temps réel102
  - Threads temps réel103
  - Threads en Round Robin107
  - Rotation sans Round Robin111
  - Temps réel depuis le shell111
  - Ordonnancement EDF (Earliest Deadline First)113
  - Conclusion 119
  - Points clés 119
  - Exercices 119
  - Exercice 1 (*)119
  - Exercice 2 (*)120
  - Exercice 3 (**)120
  - Exercice 4 (**)120
  - Exercice 5 (***)120
  - Chapitre 6
    Performances du temps réel souple121
  - Timers temps réel 121
  - Précisions et fluctuations121
  - Granularité des timers124
  - Conclusion sur les timers124
  - Temps de commutation 125
  - Commutation entre threads125
  - Commutations entre processus129
  - Comparaison processus et threads130
  - Imprévisibilités dues à la mémoire virtuelle132
  - Préemptibilité du noyau 134
  - Principes134
  - Préemptibilité du noyau standard136
  - Connaître la configuration d'un noyau137
  - Expériences sur la préemptibilité138
  - Conclusion 147
  - Points clés 147
  - Exercices 148
  - Exercice 1 (*)148
  - Exercice 2 (**)148
  - Exercice 3 (**)148
  - Exercice 4 (**)148
  - Exercice 5 (***)148
  - Chapitre 7
    Problèmes temps réel classiques149
  - Démarrage en Round Robin 149
  - Barrières Posix151
  - Inversion de priorité 152
  - Principe152
  - Héritage de priorité156
  - Prise de mutex 158
  - Comportement en temps réel161
  - Reprise de mutex en temps réel163
  - Solutions166
  - Appel explicite à l'ordonnanceur168
  - Conclusion169
  - Points clés 170
  - Exercices 170
  - Exercice 1 (*)170
  - Exercice 2 (**)170
  - Exercice 3 (**)170
  - Exercice 4 (***)170
  - Exercice 5 (***)170
  - Chapitre 8
    Limites et améliorations du temps réel Linux171
  - Traitement des interruptions 171
  - PREEMPT_RT 178
  - Threaded interrupts183
  - Fully preemptible kernel184
  - Conclusion sur PREEMPT_RT185
  - Outils de mesure des performances 185
  - Cyclictest185
  - Hwlatdetect, Hackbench187
  - Économies d'énergie 187
  - Variation de fréquence d'horloge188
  - Heuristique performance190
  - Heuristique powersave191
  - Heuristique ondemand192
  - Conclusion 192
  - Points clés 193
  - Exercices 193
  - Exercice 1 (**)193
  - Exercice 2 (**)193
  - Exercice 3 (**)193
  - Exercice 4 (***)193
  - Exercice 5 (***)194
  - Chapitre 9
    Extensions temps réel de Linux195
  - Les nanokernels temps réel 195
  - Principes195
  - RTLinux197
  - RTAI et Adeos197
  - Xenomai200
  - Interface de programmation202
  - Xenomai 3 203
  - Installation de Xenomai203
  - Modification du noyau Linux203
  - Configuration de Xenomai Cobalt206
  - Compilation de Xenomai208
  - Expériences avec Xenomai 209
  - Première exploration209
  - Programmes de tests211
  - Conclusion 213
  - Points clés 213
  - Exercices 214
  - Exercice 1 (*)214
  - Exercice 2 (**)214
  - Exercice 3 (**)214
  - Exercice 4 (***)214
  - Chapitre 10
    Programmer avec Xenomai215
  - Programmation de tâches simples 215
  - Principes215
  - Initialisation du processus217
  - Création de tâche218
  - Compilation et exécution220
  - Processus unithread222
  - Recherche des changements de modes223
  - Alarmes et tâches périodiques 226
  - Réveils périodiques226
  - Alarmes235
  - Watchdog237
  - Synchronisation des tâches 239
  - Sémaphores239
  - Mutex242
  - Conclusion 247
  - Points clés 247
  - Exercices 248
  - Exercice 1 (*)248
  - Exercice 2 (**)248
  - Exercice 3 (**)248
  - Exercice 4 (***)248
  - Chapitre 11
    Traitement des interruptions249
  - Programmation d'un driver 249
  - Squelette d'un module249
  - Structure d'un driver251
  - Traitement des interruptions255
  - Traitement en threaded interrupt260
  - Interruptions avec Xenomai 268
  - Real Time Driver Model268
  - Interruption avec RTDM274
  - Conclusion 276
  - Points clés 276
  - Exercices 277
  - Exercice 1 (*)277
  - Exercice 2 (**)277
  - Exercice 3 (**)277
  - Exercice 4 (***)277
  - Conclusion
    État des lieux et perspectives279
  - Situation actuelle 279
  - Linux « vanilla »279
  - Patch PREEMPT_RT280
  - Xenomai280
  - Mesures280
  - Perspectives 281
  - Annexe A
    Compilation d'un noyau283
  - Préparation des sources 283
  - Configuration de la compilation 285
  - Principes285
  - Interfaces utilisateur287
  - Options de compilation288
  - Compilation et installation 289
  - Compilation croisée289
  - Compilation native290
  - Annexe B
    Bibliographie293
  - Livres 294
  - Articles 294
  - Sites web 295
  - Index297
Origine de la notice:
- FR-751131015 ;
- Electre