ELE-542 Systèmes ordinés en temps réels Cours # 8 Système d

Transcription

ELE-542
Systèmes ordinés en temps réels
Cours # 8
Système d’exploitation Temps Réel
Jean-Marc Beaulieu et Bruno De Kelper
Site internet: http://www.ele.etsmtl.ca/academique/ele542/
Systèmes ordinés en temps réel
Cours 8
1
Systèmes d’exploitation en temps réel complet
- Augmente les fonctionnalités des noyaux temps réel en ajoutant des
fonctionnalités tels que des interfaces réseaux, des pilotes compliqués, des
outils de déverminage, …
- Utilise un ordonnanceur de type Round-Robin, priorité préemptive ou les deux.
- Le répartiteur s’appuie habituellement sur le modèle des “blocs de contrôle de
tâche” car le nombre de tâches à gérer est indéterminé et dynamique.
- Deux catégories de OS :
- Les systèmes multitâches permettent l’exécution concurrente de
plusieurs tâches (multiprocessus ou multifils)
Ex. : µC/OS-II, Linux, QNX, VXworks, IRIX, UNIX
- Les systèmes plus simples permettent l’exécution d’une seule tâche.
Ex. : DOS, CPU32BUG
Système d'exploitation temps réel
Cours 8
cours 8
2
1
Définitions : Tâches, processus et fil d’exécution
Un fil d’exécution (« thread ») comprend 2 éléments :
• Une séquence d’instructions en exécution (ou exécutable)
• Un « état du processeur » et une pile ; ceci inclut un locus (ou point) de
contrôle dans la séquence d’instructions (compteur de programme).
Note : Deux ou plusieurs fils peuvent avoir le même code; cependant,
ils contrôlent leur « point d’exécution » indépendamment.
• Pour nous, tâche et fil d’exécution sont synonymes.
Un processus comprend :
• Un ou plusieurs fils d’exécutions
• Un espace mémoire
Cours 8
3
Définitions : Section critique, ressource, ressource partagée
Section (de code) critique ou atomique
• Une partie de code (séquence d’instructions) qui doit être exécutée
sans interruption
Ressource
• Une entité utilisée par une tâche
Ex. : périphérique tel que imprimante, clavier, écran
variable, structure de données, vecteur
Ressource partagée (« shared resource »)
• Ressource utilisée par plusieurs tâches
• Généralement, l’accès à une ressource partagée doit être contrôlé
afin d’éviter les conflits
Ex. : 2 tâches écrivant dans une variable en même temps
Réf. : Labrosse,
chap. ordinés
2
Systèmes
en temps réel
Cours 8
cours 8
4
2
Modèle des “blocs de contrôle de tâche” : (Task-Control Blocks)
- Utile dans les systèmes d’exploitation complet car il permet de gérer
efficacement un nombre variable de tâches.
- Associe à chaque tâche une structure de donnée appelée TCB (Task-Control
Block) qui contient toute l’information nécessaire pour exécuter la tâche:
TCB
Contexte
- Compteur de programme
- Pointeur de pile
- Registre de statut
- Adresses des données
-…
Code d’identification
Niveau de priorité
Cours 8
5
Processus avec 1 fil
Réf: Grehan, Moote et Cyliax
Real-time programming
Processus avec 2 fils
Cours 8
cours 8
6
3
États d’une tâche :
1 - En exécution : La tâche est
exécutée par le processeur.
En
exécution
Prête
Suspendue
Dormante
2 – Prête : Dans la file d’attente
pour être exécutée.
3 – Suspendue : En attente d’une
ressource/d’un évènement.
4 – Dormante/Inactive : État utilisé
seulement lorsque le nombre de
tâches est fixe et permet de
conserver une tâche dans le système
sans avoir à la gérer.
Cours 8
7
Gestionnaire de tâches :
- Le système d’exploitation gère les tâches (ne devrait pas utiliser plus de 2% à 5%
du temps du processeur).
- Le système d’exploitation est la tâche de priorité la plus élevée.
- Chaque interruption matérielle et chaque appel système, tels que les requêtes à
une ressource, invoque le système d’exploitation.
- L’OS possède au moins 2 listes :
- Liste des tâches prêtes
→ gérée en Round-Robin ou préemption
- Liste des tâches suspendues → gérée en priorité préemptive
- L’OS possède aussi au moins 2 tables :
- Tables des ressources
- Tables des requêtes aux ressources
Cours 8
cours 8
8
4
Gestion des tâches – Notion de préemption
OS multitâches préemptif :
• La tâche/interruption qui est la plus prioritaire interrompt les
tâches/interruptions de plus basse priorité.
• Déjà vue dans le cas des interruptions hiérarchiques
OS multitâches coopératif (sans préemption) :
• Chaque tâche doit libérer explicitement (par une instruction) le processeur..
• Chaque tâche doit « relâcher » le processeur fréquemment.
• Évènements asynchrones sont toujours traités par les interruptions mais sont
traitées seulement lorsque le processeur est « libéré » par la tâche courante.
• Avantages :
Pas besoin de fonctions réentrantes, sauf pour les ISR.
Moins de protection des données partagées.
• Inconvénient :
Temps de réponse est plus long.
Réf. : Labrosse, chap. 2
Cours 8
9
Exécution – Système coopératif
1) Une tâche est
interrompue (IRQ).
2) Saut vers ISR
3) ISR traite
l’événement et
rend une tâche plus
prioritaire prête
pour l’exécution
4) Retour de ISR
5) Continuation de la
tâche interrompue
6) La tâche de basse
priorité relâche le
CPU
7) La tâche de haute
priorité exécute
Tâche de priorité
basse
ISR rend la tâche de
priorité haute « prête »
Tâche de priorité
haute
Tâche de priorité
basse libère le CPU
Temps
Cours 8
cours 8
10
5
Exécution – Système préemptif
Tâche de priorité
basse
1) Une tâche de basse
priorité est
interrompue (IRQ)
2) Saut vers ISR
3) ISR traite
l’événement et rend
une tâche plus
prioritaire prête pour
l’exécution.
4) Retour de ISR
5) Exécution immédiate
de la tâche de haute
priorité exécute
6) Retour à la tâche de
plus basse priorité
(1)
(2)
(3)
(4)
ISR rend la tâche
de priorité
haute « prête »
(6)
(5)
Temps
Tâche de priorité
haute
Note : Une interruption périodique de la
minuterie est utilisée pour déclencher
régulièrement le séquenceur.
(7)
11
Cours 8
Représentation structurelle :
ISR
Tâches dormantes :
MEM Tâches
0
1
2
Priorité 7
6
5
4
3
2
1
0
Tâche active
Tâches en attente :
PC
SP
Priorité
7
6
5
4
3
2
1
Autres
registres
Tâches prêtes :
0
3
4
CODE
CPU
5
6
7
0
1
Liste de tâches
ID
État
Priorité
3
Autres
registres
Autres
registres
ID
État
Priorité
PC
SP
Autres
registres
PC
SP
4
ID
État
Priorité
ID
État
Priorité
6
PILE
PC
SP
Autres
registres
2
PC
SP
5
Cours 8
cours 8
7
12
6
µC/OS-II – Les états d’une tâche
Cours 8
13
Noyaux en temps réel – Services offerts
Il est possible de regrouper les principaux services offerts par les
noyaux en temps réel.
Nous utiliserons le cas de µC/OS-II :
Gestion des interruptions Æ Activation, désactivation et traitement
Gestion des tâches
Æ Création, …
Communication intertâches Æ Sémaphores, boîte à courrier, queue
Séquenceur
Gestion du temps
ÆHorloge et délais
Gestion de la mémoire
Æ Mémoire partagée, …
Cours 8
cours 8
14
7
Noyaux en temps réel – Gestion des tâches
Les fonctions nécessaires à la gestion des tâches dans
µC/OS-II sont :
Création d’une tâche
Élimination d’une tâche
Suspendre/reprendre une tâche
Retardement d’une tâche
Requête d’information
ISR
Tâches dormantes :
Priorité 7
6
5
4
CPU
3
2
1
0
Tâche active
PC
SP
Priorité
7
6
5
4
3
2
1
Autres
registres
•
•
•
•
•
0
Tâches prêtes :
Sujets connexes
• Les fonctions internes du noyau (répartiteur, séquenceur)
• Les tâches systèmes (Ex : fonctions « Idle », « statistique »)
15
Cours 8
Création d’une tâche
Allocation de mémoire pour la pile et TCB
Initialisation de la pile : configuration de départ
Initialisation de la table de contrôle de la tâche (TCB)
Rendre la tâche active (prête pour exécution)
Appeler le séquenceur
ACTION
Tâches dormantes :
Priorité
7
6
Liste des tâches
Quelles sont les informations nécessaires dans le TCB?
• Un compteur ordinal (numéro ou ID de la tâche)
• État et priorité
• Pointeur vers la pile
• Durée de retard fixée par une minuterie
• Copie des registres : SP (stack pointer), registres généraux,
registres du coprocesseur mathématique
Cours 8
cours 8
5
4
3
2
1
0
Tâches prêtes :
Nouvelle tâche
PC
SP
Autres
registres
•
•
•
•
ID
État
Priorité
16
8
Création d’une tâche : uC/OS-II
- 2 fonctions de création d’une tâche :
ErrCode OSTaskCreate(maTâche, &paramètre, &pile, priorité)
Code de retour Code de la tâche Pointeur vers Pointeur vers
OS_NO_ERR
(nom de la fonction) paramètre la pile de la tâche
OS_PRIO_EXIST
(début de la pile)
(optionnel)
OS_PRIO_INVALID
OS_NO_MORE_TCB
Niveau de
priorité
de la tâche
(code d’identité)
ErrCode OSTaskCreateExt(maTâche, &paramètre, &pile, priorité,
ID, &pileFin, pileTaille, &TCBextension, options)
Code d’identité
(optionnel)
Pointeur vers le
bas de la pile
Options de la tâche
Pointeur vers une
Taille de la pile extension du TCB
OS_TASK_OPT_STK_CHK
OS_TASK_OPT_STK_CLR
OS_TASK_OPT_SAVE_FP
17
Cours 8
Création de tâche dans uC/OS-II
• Une tâche est constituée de 3 choses :
exemple
- Code de la tâche : fournit par le programmeur (vous !).
- Bloc de contrôle de tâche (TCB) : créé lorsque la tâche est créée.
- Pile de la tâche : statique ou dynamique créé avant de créer la tâche.
Déclaration d’une pile :
Code d’une tâche :
Pointeur vers paramètres
Boucle infinie
void Task (void *pdata)
{ déclarations de variables locales
Statique
#define TASK_STK_SIZE
512
OS_STK TaskStk [TASK_STK_SIZE];
Code d’initialisation (optionnel)
for (;;) {
Code d’exécution de la tâche
(contient des appels au système)
}
Dynamique
512
OS_STK *pStk;
}
pStk = (OS_STK *)malloc(TASK_STK_SIZE);
Cours 8
cours 8
18
9
Création d’une tâche (suite)
Problème : Comment estimer la taille de la pile de façon à
éviter les débordements?
• Changer la taille de la pile de façon dynamique
Æ Pas recommandé parce que l’allocation dynamique est lente et il
n’y a pas de garantie de succès
• Estimer la taille de la pile (variables locales, récursivité, niveau
d’interruptions imbriqués, …). Une bonne marge de sécurité (1,5 à
2 fois la taille estimée) est à prévoir
• Tester le code plusieurs fois, dans des conditions critiques, pour
établir une taille sécuritaire
Problème : La création d’une tâche peut consommer
beaucoup de temps. Comment en minimiser l’impact?
• Créer toutes les tâches au départ (initialisation). Si elles ne sont pas
utilisées au départ, les mettre en attente (suspension)
19
Cours 8
Élimination d’une tâche
µC/OS-II procède en deux (2) étapes :
ACTION

Problème : Comment s’assurer que la tâche éliminée
ne possède pas l’accès exclusif à une ressource
partagée qui ne sera jamais relâchée?
•
•
Une tâche ne doit pas éliminer d’autres tâches (sauf
elle-même).
Utilisation d’un mécanisme de « requête d’élimination »
où on demande à une tâche de terminer « proprement ».
Cours 8
cours 8
Tâches dormantes :
Priorité
7
6
5
4
3
2
1
0
Tâches prêtes :
Tâche
PC
SP
Autres
registres
Soustraire la tâche du séquenceur (l’enlever des
différentes tables qu’il utilise).
2. Libère la mémoire occupée par le TCB et la pile.
Note : ceci permet de réactiver les IRQ après la première
étape (p-c-q la tâche à éliminer ne peut plus être
« exécutée ».
Liste des tâches
1.
ID
État
Priorité
20
10
Élimination d’une tâche : uC/OS-II
- 2 fonctions d’élimination d’une tâche :
- Pas sécuritaire.
ErrCode OSTaskDel(priorité)
- Permet à une tâche
Niveau de priorité de la tâche
de s’auto-détruire
(sert en même temps de
Code
de
retour
(préférable).
code d’identification)
OS_TASK_DEL_ERR
OS_TASK_DEL_ISR
OS_NO_ERR
OS_TASK_DEL_IDLE
OS_PRIO_INVALID
(commun au deux)
OS_TASK_NOT_EXIST
OS_TASK_DEL_REQ
- Plus sécuritaire.
ErrCode OSTaskDelReq(priorité)
- Demande à une tâche
de s’auto-détruire.
21
Cours 8
action
Suspendre/reprendre une tâche
•
•
•
•
Il est parfois utile de suspendre l’exécution d’une
tâche.
Ex. : Tâches créées au début mais utiles
seulement à la fin du traitement.
Utile dans le débogage et les tests :
Permet d’isoler l’effet de l’exécution d’une
tâche
µC/OS-II utilise deux (2) fonctions à cette fin :
Code de retour
(commun au deux)
6
5
4
3
2
1
0
Priorité
6
5
4
3
2
1
0
7
Tâches prêtes :
Niveau de priorité
de la tâche
OS_NO_ERR
OS_PRIO_INVALID
OS_TASK_SUSPEND_IDLE
OS_TASK_SUSPEND_PRIO
ErrCode OSTaskSuspend(priorité)
OS_TASK_RESUME_PRIO
OS_TASK_NOT_SUSPENDED
ErrCode OSTaskResume(priorité)
Priorité 7
Cours 8
cours 8
22
11
Ce service permet de retarder une tâche pour un certain nombre de Ticks
d’horloge ou une durée de temps (H.M.S.mS).
Utile pour les tâches cycliques ou pour accorder du temps aux autres tâches.
Un retardement nul est parfois utilisé pour déclencher l’exécution du
séquenceur.
La résolution de la durée d’attente dépend de l’initialisation du Timer.
•
•
•
Délai
Fin du délai
Priorité
7
6
6
5
5
4
4
3
3
CPU
2
2
1
1
Tâches prêtes :
0
0
Priorité 7
Tâche active
6
5
4
CPU
3
2
1
0
Tâche active
PC
PC
SP
SP
Autres
registres
Priorité 7
ISR (Timer)
Priorité
7
6
5
4
3
2
1
Autres
registres
•
0
Tâches prêtes :
23
Cours 8
Retardement d’une tâche :
•
uC/OS-II
uC/OS-II fournit 2 fonctions qui permettent à une tâche de se mettre en
attente pendant un délai déterminé :
Résolution dépend
de l’initialisation
du Timer
void OSTimeDly(Ticks)
Nombre de Ticks d’horloge
(0 à 65535)
void OSTimeDlyHMSM(heures,minutes,secondes,millisecondes)
Max :
•
0 à 255
0 à 59
0 à 59
0 à 999
uC/OS-II fournit aussi 1 fonction qui permet à une tâche de forcer le
retour d’une tâche qui a été mise en attente :
Code de retour
ErrCode OSTimeDlyResume(priorité)
OS_NO_ERR
OS_PRIO_INVALID
OS_TIME_NOT_DLY
OS_TASK_NOT_EXIST
Note : ne peut pas forcer le retour d’une
tâche retardée pour plus de 65535 Ticks.
Cours 8
cours 8
Niveau de priorité
de la tâche
24
12
Autopsie d’un système simple :
uC/OS-II
Les déclarations :
#include (Librairies standards à inclure)
Déclarations des librairies
Déclarations des constantes
Déclarations des
variables globales
(piles, sémaphores,
drapeaux, …)
Déclarations des prototypes
(tâches, fonctions)
#include
#include
#include
#include
"\software\ucos-ii\ix86l\bc45\os_cpu.h"
"os_cfg.h"
"\software\ucos-ii\source\ucos_ii.h"
"\software\blocks\pc\bc45\pc.h“
OS_STK
OS_STK
OS_STK
OS_STK
void
void
void
void
512
TaskStk1 [TASK_STK_SIZE];
TaskStartStk[TASK_STK_SIZE];
Task1(void *data);
Task2(void *data);
Task3(void *data);
TaskStart(void *data);
Cours 8
25
Le démarrage du système :
uC/OS-II
void main (void)
{
OSInit(); Initialise uC/OS-II et crée une tâche “inactive“ (Idle Task)
PC_DOSSaveReturn(); Sauve le contexte du DOS
PC_VectSet(uCOS, OSCtxSw); Installe l’interruption pour les changements de contexte
OSTaskCreate(TaskStart, (void *)0, &TaskStartStk[TASK_STK_SIZE - 1], 0);
OSStart();
Démarre uC/OS-II
}
(Tout ceci est obligatoire et selon cet ordre)
Crée une 1ière tâche de niveau de priorité très élevé (niveau 0).
Cette tâche va servir à démarrer. les autres tâches.
Cours 8
cours 8
26
13
Le démarrage du système :
uC/OS-II
void TaskStart (void *pdata)
{ INT16S key;
pdata = pdata;
OS_ENTER_CRITICAL();
PC_VectSet(0x08, OSTickISR);
PC_SetTickRate(OS_TICKS_PER_SEC);
OS_EXIT_CRITICAL();
Obligatoire pour initialiser
le Timer utilisé par uC/OS-II
et doit être fait après OSStart()
Créer les tâches ici
for (;;) {
if (PC_GetKey(&key) == TRUE) {
if (key == 0x1B) {
PC_DOSReturn();
}
}
OSTimeDlyHMSM(0, 0, 1, 0);
}
Obligatoire sous DOS seulement
pour permettre d’arrêter le système
Permet d’accorder du temps
aux autres tâches
}
Cours 8
cours 8
27
14