Exécutif temps réel

Pierre-Yves Duval (cppm)

Ecole d’informatique temps réel - La Londes les Maures 7-11 Octobre 2002

Plan

Exécutif
Tâches
Evénements et synchronisation
Partage de ressources
Communications entre taches
Gestion de la mémoire
Gestion du temps
Interruptions
Fichiers temps réel
POSIX et le temps réel

1
 Rôle d’un exécutif
Principal :
- ordonnancer les exécutions des tâches
mais aussi:
- protéger l’accès aux ressources partagées
- recevoir et transmettre les signaux de synchronisations

Composé d’agences spécialisées dans un type de fonction

- gestion des tâches
- gestion des événements matériels et logiciels (de synchronisation)
- gestion communications entre tâches
- gestion du temps
- gestion des ressources partagées
- gestion de la mémoire
- gestion des exceptions

Structure d’un exécutif

Tâches applicatives

activation Appels de service

lanceur communication Exécutif

horloge agence
événements temps
agence agence
tâches ressources
ordonnanceur agence agence

interruptions
Monde matériel

2
 Exécutif ou noyau temps réel
C’est d’abord un système d’exploitation.

La principale différence entre un OS généraliste et un OS temps

réel est le comportement très déterministe.

Ensuite on trouvera quelques différences dans l’API (voir POSIX à la fin):

-politique d’ordonnancement plus élaborée
-gestion plus précise de plus de réveils (timers) à la résolution plus fine
-plus d’ouverture sur le hardware sous-jacent en particulier les connexions aux IT matérielles
-plus de modularité dans la construction du noyau

Tâche

Agent actif d’une application avec 4 attributs:

-contexte d’exécution
registres du processeur,
pile exécution,
ressources détenues
- priorité
-état d’exécution
-état de protection (préemptible ou pas)

3
 Tâche
Dans les OS d’aujourd’hui les tâches sont implantées comme des
fils d’exécution (thread).

L’ordonnanceur de l’OS gère les threads/tâches.

La notion de processus définie un espace d’adressage protégé dans

lequel s’exécute au moins une tâche (le main thread) qui est activé
quand le processus est lancé. Le processus se termine quand la dernière
tâche qu’il contient se termine.

Dans certains OS simples il n’y a pas d’espace mémoire protégé, il

y a identité entre les termes:
processus = thread = tâche

Etats d’exécution SCEPTRE

Inexistant
Supprimer
Créer

Supprimer

Hors Services
Supprimer
Lancer
Arrêter Arrêter
Créer
Continuer
Actif Sélection
Opération d’attente
Prêt En Cours En Attente
Arrivée événement
Préemption

4
 Synchronisation par événements
synchrones
Phases temporelles de l’occurrence d’un événement:
apparition production prise en compte consommation

Code d’IT jusqu’à l’appel du service de signalisation

Délai de réveil tâche destinataire
Traitements avant effacement

Les événements sont dits synchrones si l’application consommatrice

va les lire de façon explicite.

Synchronisation par événements

synchrones
Types d’événements:

Fugace: Si aucune tâche est en attente à son occurrence il est perdu

Mémorisé: L’occurrence est mémorisée mais aucune autre ne sera

prise en compte avant sa consommation

A compte: Mémorisé avec incrémentation du compteur à chaque

occurrence et décrémentation chaque consommation

5
 Synchronisation par événements
synchrones
Services génériques événements
Créer (événement)
Supprimer(événement)
Attendre_occurrence( événement )
Signaler_occurrence( événement )

IT Créer (evt)
Boucle
Lire data Attendre(evt)
Copie mémoire Traiter data
Signaler(evt) Fin boucle

Synchronisation par événements

synchrones: exemple
/* variable condition POSIX utilisable avec rtlinux */
/*-----------------------------------------------------------*/
pthread_cond_t cond;
void coureur(){
int ret;
ret = pthread_cond_timedwait(&cond, …, délai );
courrir();
}
void arbitre(){
int ret;
decompte();
ret = pthread_cond_signal(&cond);
}
main(){
int ret;
ret = pthread_cond_init(&cond, NULL);
ret = pthread_create( …, coureur, …);
ret = pthread_create( …, arbitre, …);
attente_fin();
}

6
 Signalisation asynchrone
Une tâche est associée à un signal et elle sera automatiquement activée
quand l’événement associé au signal arrivera. La tâche est appelée
pilote (handler) du signal.

La tâche n’a donc pas besoin de se mettre en attente du signal.

Exemple: signaux UNIX (lent), attachement à une IT matérielle

Services génériques signaux asynchrone:
Créer( signal )/ Détruire( signal )
Connecter( pilote, signal )
Envoyer( signal )

Il peut exister des masques qui permettent d’empêcher temporairement

la réception de signaux (avec perte, mémorisation ou comptage)

Signalisation asynchrone:
exemple
/* signal POSIX simple */
/*---------------------------*/
int stopbit;

void signalled(){
stopbit = 1;
}

main(){
stopbit = 0;
signal( SIGINT, signalled);
while( !stopbit)
{ … faire un travail qui sera arrêté par CtrlC …}
terminer_proprement();
}

7
 Partage de ressources
Problème:
- gérer un nombre limité de ressources ( de 1 à n ) entre plusieurs
tâches
- assurer la modification cohérente de données partagées

Objet:
Sémaphore binaire (mutex) un utilisateur à la fois
Sémaphore à compte pour n utilisateurs maxi

Autres possibilités déconseillées en temps réel:

masquage des IT ou interdiction de préemption

Partage de ressources
Services génériques sémaphores:
Créer(sem)/Détruire(sem)
Prendre_ressource(sem) parfois appelée P()
Libérer_ressource(sem) parfois appelée V()
sem
Boucle
Créer(sem) …
Boucle Prendre(sem)
… exploiter(liste)
Prendre(sem) …
Insérer(elem,liste)
Libérer(sem)
liste sortir(elem,liste)
Libérer(sem)
… Fin boucle
Fin boucle
Détruire(sem)

8
 Partage de ressources: exemple
/* sémaphore à compte POSIX */
/*------------------------------------*/
sem_t sem;

void consommateur(){
ret = sem_wait(&sem);
manipuler_ressource();
sem_post(&sem);
}

main(){
sem_init(&sem, …, nombre_utilisateurs);
for ( i=0; i<10; i++)
{ pthread_create( …, consommateur, …); }
attente_fin();
sem_destroy(&sem);
}

Communication entre tâches

Boite aux lettres

Service de base permettant les échanges asynchrones de données entre

des tâches concurrentes et non synchronisées

Services génériques (c’est un buffer)

Créer(boite)/Supprimer(boite)
Déposer(mesg)
Lire(mesg)
Test(mesg)

Exemple: FIFOs, tubes UNIX,

queues de messages (POSIX ou system V) (étendues au réseau QNX),
mailbox

9
 Communication entre tâches
Boite au lettres: Queue de message POSIX

Tâche réceptrice dans processus 2

Tâche émettrice dans processus 1
#define MQ "/monrep/mesgq"
mqd_t qfd; #define MQ "/monrep/mesgq"
struct mq_attr qattr; mqd_t qfd;
char message_lu[20]; struct mq_attr qattr;
/* nb max msg en queue */
qattr.mq_maxmsg = 32; /* nb max msg en queue */
/* taille maxi d’un message */ qattr.mq_maxmsg = 32;
qattr.mq_msgsize = 20; /* taille maxi d’un message */
qattr.mq_msgsize = 20;
void recepteur(){
qfd = mq_open (MQ, … , &qattr); void émetteur(){
mq_receive (qfd, message_lu, qfd = mq_open (MQ, … , &qattr);
sizeof (message_lu),…); mq_send (qfd, "tout va bien", … );
print(" %s " , message_lu); mq_close(MQ);
mq_close(MQ); mq_unlink(MQ);
} }

Communication entre tâches

Socket: programmation répartie

Objet de communication applicatif (BSD UNIX) qui permet un

échange point à point de type boite aux lettres entre deux tâches
sur deux sites différents (sorte de queue de messages).

Ces points sont reliés aux couches réseaux de l’OS qui assurent
le transfert (TCP ou UDP pour Internet).

Intérêt: Base de la programmation distribuée

- indépendante de l’OS
- utilisables en local avec des sockets du domaine UNIX.

10
 Communication entre tâches
Tableau noir

Publication de données dans un espace accessible en lecture par

tous les consommateurs.

Exemples: mémoire partagée entre processus (shared memory),

données globales entre thread d’un même processus

Services génériques:
Créer/Détruire
Afficher/Lire

Communication entre tâches

Rendez-vous

Modèle de communication très synchrone ou producteur et consommateur

doivent être présents lors de l’échange de donnée.

Exemple: support d’exécution du langage ADA

Services génériques:
Appeler_entrée demande de rendez-vous
Accepter_entrée déclaration de la capacité à recevoir des demandes
de rendez-vous
Terminer_entrée

11
 Gestion de la mémoire
Selon les possibilité du hardware sous jacent on peut avoir 3 type de
gestion de la mémoire.

-espace plat ou toute la mémoire est visible et accessible par n’importe

quelle tâche
-séparation entre les espace système/noyaux et les tâches applicatives
-mémoire virtuelle séparée et protégée associée à chaque processus

L’allocation de la mémoire peut être statique (à la création) ou

dynamique (automatique) en fonction des besoins

Gestion du temps
La précision dépend du support matériel
- horloge temps réel
- réveils (timer)
disponibles sur la carte.

L’horloge génère un signal périodique qui sert de pulsation à l’activité

de l’exécutif et maintien la date de la machine

Les tâches utilisatrices peuvent:

-obtenir la date
-se synchroniser sur une durée
-se synchroniser sur une heure absolue
-limiter un blocage sur un délai de garde (timeout)

12
 Gestion du temps
Services génériques:

Initialiser_date
Lire_date/Lire_heure
Attendre_date(date) suspend la tâche jusqu’à la date
Signaler_a_date(date) signaler un événement à une date
Attendre_délai(delai) suspendre la tâche pendant un délai

Créer_réveil/Supprimer_réveil réveil=timer
Arrêter_réveil
Signaler_top_horloge permet d’envoyer un signal périodique

Certain OS offrent des possibilités pour une tâche de se déclarer comme

périodique et de se faire activer avec une période donnée.

Gestion des interruptions

Prend en compte les sollicitations matérielles du monde extérieur.

Une routine d’interruption (ISR) doit être aussi courte que possible:
- pendant son exécution la source d’IT est masquée (mais imbrication
d’IT de niveaux de priorités différents possible)
- ce n’est pas un mode d’exécution « normal »

Le temps de latence d’IT est le délai entre arrivée de l’interruption et

le début de l’exécution du code applicatif associé c’est une
caractéristique importante qui différencie un system TR d’un système
généraliste.

13
 Gestion des interruptions:
exemple
/* rtlinux capter le signal d’horloge temps réel */
/*------------------------------------------------------*/
#define RTC_IRQ 8

void intr_handler(int sig){

faire_truc();
rtl_hard_enable_irq(RTC_IRQ);
}

int init_module(void){
struct sigaction act;
act.sa_handler = intr_handler;
sigaction( RTC_IRQ, &act, NULL);
programmer_horloge( fréquence );
rtl_hard_enable_irq(RTC_IRQ);
return(0);
}

Gestion des fichiers

Certains services permettent d’optimiser l’accès aux fichiers
- plus rapides
- plus déterministes
pour des applications temps réel.

Ce sont:
- fichiers projetés en mémoire (évitent les I/O pendant l’usage)
- les fichiers stream ou temps réel (permettent écrire de façon
continues sur des pistes physiquement contiguës d’un disque)
- les écritures/lectures asynchrones

14
 POSIX
Depuis 1984 à l’IEEE

P1003.1 interface de programmation pour UNIX de base

gestion des processus (fork, exec, kill …)
fichiers et terminaux (open, fopen , fgetc, dup ,fcntl ,mkdir …)
information runtime (getpid, cuerid, uname …)
signaux de base (signal, raise, sigaction … )
gestion mémoire (malloc, memcpy, free …)
gestion du temps ( time, clock …)
exécution (setjmp, longjmp …)
communication (pipe, mkfifo (named pipes), setbuf stream, …)

POSIX temps réel

P1003.1b (ex POSIX.4) extensions temps réel
ordonnancement
sémaphores
queues de messages
signaux temps réel (nouveaux, queue, paramètres
horloge haute résolution
entrées sorties synchrones/asynchrones
mémoire partagée
P1003.1c (ex POSIX.4a) extensions multithreadées
thread
mutex
variables conditions
P1003.1d (ex POSIX.4b) gestion des IT

15
 OS temps réel du marché
Tornado,VxW orks
Blue C atLinux and LynxO s
Q N X N eutrino

H ard H atLinux

Lineo,Em bedix

Et beaucoup d’autres … dont certaines solutions pour compléter

Windows NT ou Linux avec des fonctions « temps réel stricte ».

OS temps réel du marché

16