1 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Gestion des interruptions, des signaux et du temps

2 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Exceptions et interruptions ● exception : n'importe quel événement qui interrompt l'exécution normale du processeur et l'oblige à exécuter un ensemble d'instructions spéciales dans un état privilégié. ● Les exceptions peuvent être synchrones ou asynchrones ➢ les exceptions générées par des événements internes sont des exceptions synchrones ✔ exemple : division par zéro, non alignement des données ➢ les exceptions générées par des événements externes sont des exceptions asynchrones ✔ exemple : pression sur le bouton de reset, arrivée de données sur le module de communication du processeur

3 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Exceptions et interruptions ● interruption : classe particulière d'exceptions externes (asynchrones) provoquées par un événement déclenché par du matériel extérieur au processeur ➢ se distinguent des exceptions synchrones par la source (le processeur lui-même pour les exceptions synchrones, un matériel externe pour les interruptions) ● exceptions et interruptions sont utilisées pour communiquer entre le processeur et le matériel extérieur : ➢ erreurs internes et gestion de conditions spéciales ➢ utilisation concurrente du matériel ➢ gestion des demandes de service

4 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Contrôleur programmable d'interruptions ● la plupart des applications ont de multiples sources d'interruptions ● le contrôleur programmable d'interruptions (PIC) a deux fonctions essentielles ➢ établir des priorités entre les différentes sources ➢ décharger la CPU de la détermination de la source d'une interruption, quand celle-ci se présente ● utilise une ou des "lignes d'interruptions" (IRQ :Interrupt ReQuest), chacune étant associée avec un niveau de priorité ● connaît l'adresse des instructions à charger (ISR : Interrupt Service Routine) quand l'interruption est détectée (vecteur d'interruption)

5 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Contrôleur programmable d'interruptions

6 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Contrôleur programmable d'interruptions ● utilise une table de descripteurs d'interruption (interrupt table) contenant : ➢ niveau de priorité ➢ vecteur d'interruption ➢ numéro d'IRQ correspondant ➢ fréquence maximale Périph 1 Périph 2 Périph 3 Périph 4 Priorité maximum haute medium basse PIC Processeur interruption vecteur ISR

7 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Contrôleur programmable d'interruptions airbag freins jauge essence horloge TR Priorité maximum haute medium basse PIC Processeur interruption vecteur ISR SourcePrioritéAdresseIRQ vecteur Fréq. maxi Description capteur airbagmaxi14h8N/A déclenche l'airbag capteur freinshaute18h7N/A déclenche le freinage capteur jaugemedium1Bh620 Hz mesure le niveau horloge TRbasse1Dh5100 Hzhorloge précise à 10 ms

8 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps classification des interruptions et exceptions ● interruptions masquables (par le software) ● interruptions non masquables ➢ traitées immédiatement ➢ possèdent généralement une ligne de requête dédiée et un numéro de vecteur fixe ● exceptions précises ➢ quand on peut déterminer l'instruction sur laquelle pointait le compteur de programme quand l'exception a été levée ● exceptions imprécises ➢ par exemple dans certains cas où l'on pratique le préchargement des instructions (Pentium)

9 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps classification des interruptions et exceptions ● les exceptions précises sont souvent divisées en 2 catégories selon qu'elles sont : ➢ détectées par le processeur ✔ fautes ✔ trappes ✔ abandons ➢ programmées ● généralement l'ordre des priorité est (par ordre décroissant) : ➢ interruptions non masquables ➢ exceptions précises ➢ exceptions imprécises ➢ interruptions masquables

10 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion des exceptions ● scenario ➢ sauvegarde de l'information sur l'état du processeur ➢ chargement de la fonction en charge de gérer l'interruption ou l'exception (handler) dans le compteur de programme ➢ exécution du handler ➢ restauration des données du processeur à la fin de l'exécution du handler ➢ reprise du déroulement des tâches

11 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion des exceptions ● actions typiques du handler ➢ changer de contexte pour une pile dédiée (exception frame ou interrupt stack) ➢ masquer les interruptions de niveau plus bas ➢ faire un minimum de travail pour préparer la gestion complète par une tâche dédiée qui sera mise en concurrence avec les autres tâches du système

12 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps installation des handlers ● à l'initialisation du système (exceptions) ou des périphériques (interruptions) ● à l'aide de la table d'interruptions ● le vecteur d'interruption va pointer vers l'adresse de l'Interrupt Service routine (ISR) ou de l'Exception Service Routine (ESR) correspondant ● la plupart des OS Temps Réel proposent ➢ des handlers par défaut ➢ des procédures pour sur-écrire ces procédures par défaut et/ou exécuter des traitements préalables ou subséquents

13 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps sauvegarde des états du processeur ● la procédure de sauvegarde des états du processeur est beaucoup plus légère que celle d'un changement de contexte de process ➢ on ne va pas exécuter un nouveau process mais un chemin de contrôle (simple séquence d'instructions exécutée en mode noyau) exécuté au nom du process qui s'exécutait quand l'interruption est arrivée ● généralement, on utilise la pile du process courant pour sauvegarder l'information relative au processeur ➢ au minimum : registres d'état et compteur de programme ➢ peut poser des problèmes de place disponible quand plusieurs interruptions imbriquées se produisent

14 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps chargement et invocation des handlers ● comportements différents pour les ESR et ISR ● des interruptions peuvent être activées ou désactivées par le software : ➢ registre de contrôle du processeur qui détermine le comportement du PIC ➢ toutes les interruptions externes vont être passées au PIC qui va vérifier si elles sont masquées ou non ➢ le PIC va ignorer les interruptions masquées ➢ les interruptions de moindre priorité vont être mises en suspens (pending) : reconnues, puis mises en attente ➢ l'interruption active est passée au processeur pour rechercher le vecteur qui lui correspond

15 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps chargement et invocation des handlers ➢ pour les exceptions synchrones le processeur doit d'abord déterminer l'origine de l'exception, puis calculer l'index dans la table de correspondance pour retrouver l'ESR ➢ pour les exceptions asynchrones, le PIC vérifie d'abord si elles sont masquées Vérificatio n par le PIC Calcul du vecteur par la CPU Exceptions asynchrones Exceptions synchrones Vecteur Mémoire Table de correspondance exécution interrompue reprise de l'exécution routine de service (ISR ou ESR)

16 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps structure des handlers ● utilisent le plus souvent une "pile d'exception" (interrupt stack ou exception frame) ➢ pour gérer plus facilement l'imbrication des interruptions ➢ pour pouvoir utiliser des fonctions C qui ont besoin d'une pile pour passer les paramètres ● pile allouée par l'ESR ou l'ISR à son installation Sauvegarde minimale Handler 1. Sauvegarde du pointeur de pile dans une variable temporaire 2. Redéfinition du pointeur de pile vers l'espace privé 3.Exécution du handler 4.restauration du pointeur de pile à la valeur sauvegardée Pointeur de pile sauvegardé Nouveau pointeur de pile Pile d'exception

17 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps quelques considérations sur le temps ● le temps de latence dépend ➢ du processeur ➢ des interuptions de plus haute priorité en cours ➢ du masquage ● le temps de traitement ne dépend que du programmeur Temps de latence Temps de traitement Temps de réponse intervalle entre deux interruptions Temps

18 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps quelques considérations sur le temps ● traitement souvent séparé en ➢ un traitement minimal dans l'ISR ➢ un traitement reporté effectué par une autre tâche (éventuellement un démon) Temps de latence Temps de réponse intervalle entre deux interruptions Temps Temps de traitement dans l'ISR Suspend u En Cours délai dû à l'ordonnancement Démon ➢ gestion optimale des interruptions de basse priorité ➢ diminue les risques de manquer des interruptions ➢ au détriment du temps de réponse

19 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Signaux et événements

20 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux ● équivalent software d’une interruption ou d’une exception ● peuvent être générés par ➢ une exception (pagination, division par zéro,...) ➢ une interruption (CTRL-C, CTRL-Z, terminaison d'une opération d'entrée / sortie, expiration d'un timer,...) ➢ une signalisation explicite (kill)

21 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux ● autorisent une gestion asynchrone ➢ notification immédiate ➢ gestion de la concurrence (signalisation de la fin de l'exécution de l'autre tâche) ● mais ➢ complexes à gérer ➢ non déterministes ➢ moins efficaces que les communications synchrones en termes de performances

22 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux POSIX.1 ● envoi : kill(pid_t pid, int SIGNAL) ● comportements à la réception d'un signal donné : ➢ blocage, en attendant de le traiter ultérieurement ➢ ignorance : aucune action spécifique n'est prise ➢ gestion par l'établissement d'une fonction (handler) qui va être appelée à chaque fois que le signal va être reçu

23 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux POSIX.1

24 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion du comportement à la réception ● primitive sigaction ● précise les détails du comportement du process à la réception du signal ● utilise une structure struct sigaction { void (*sa_handler)(); sigset_t sa_mask; int sa_flags; void (*sa_sigaction)(int siginfo_t *, void *); } ● int sigaction(SIGNAL, struct sigaction *p_action, struct sigaction *p_action_anc)

25 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion du comportement à la réception ● sa_handler ➢ pointeur sur une fonction qui sera appelée à chaque fois que le process recevra un signal void handler_pour_SIGNAL(int signum) ➢ peut être remplacé par SIG_IGN ou SIG_DFL ➢ attention à la définition d’autres handlers (cachés) pour le même signal

26 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion du comportement à la réception sa_mask ➢ liste des signaux bloqués pendant l’exécution du handler ➢ constituée des signaux normalement bloqués, du signal reçu et de la liste donnée ● SIGKILL et SIGSTOP ne peuvent être bloqués sa_flags ➢ pour indiquer la façon de gérer les signaux ➢ pratiquement non utilisé (bloquer SIGCHLD)

27 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps blocage des signaux ● pendant l'exécution d'un handler ● pendant toute une partie du programme ● ensemble des signaux bloqués défini par un masque de type sigset_t sigprocmask(int opération, struct sigset_t *p_masque, struct sigset_t *p_masque_anc) ➢ opérations : ✔ SIG_BLOCK : ajout d'un signal ✔ SIG_UNBLOCK : retrait d'un signal ✔ SIG_SETMASK : établissement du masque

28 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion du masque des signaux sigemptyset(sigset_t *p_m) sigfillset(sigset_t *p_m) sigaddset(sigset_t *p_m, int sn) sigdelset(sigset_t *p_m, int sn) sigismember(sigset_t *p_m, int sn)

29 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps synchronisation sur les signaux sigsuspend(sigset_t *p_m) ➢ prend le masque de signaux qui lui est passé et l’installe temporairement comme masque des signaux bloqués du processus ➢ met le processus en hibernation jusqu’à l’arrivée d’un signal non bloqué ➢ exécute le handler du signal reçu ➢ retourne à l’instruction suivante quand l’exécution du handler est terminée

30 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps exemple processus attendant une interaction du monde extérieur void interaction_terminee (int sig_num) {... } main (int argc, char **argv) { struct sigaction sa; sigset_t signaux_en_attente, signaux_bloques; sigemptyset(&signaux_en_attente); sigaddset(&signaux_en_attente, SIGUSR1); sigprocmask(SIG_BLOCK, &signaux_en_attente, NULL); sa.sa_handler = interaction_terminee; sigemptyset(sa.sa_mask); sa.sa_flags = 0; if (sigaction(SIGUSR1,&sa,NULL)) { perror("sigaction"); exit(1); }... sigemptyset(&signaux_bloques); while (1) { /* sequence d'instruction */ sigsuspend(&signaux_bloques);... }... }

31 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps limitations des signaux POSIX.1 ● ne sont pas suffisamment nombreux ➢ ne peuvent pas être mis en queue ➢ ne respectent pas l’ordre d’arrivée dans le traitement ➢ ne transportent pas d’information autre que leur identité ➢ sont lents ● POSIX.4 fournit une extension de la notion de signal : événements, ou signaux temps réel qui solutionnent la plupart de ces limitations ● Les signaux POSIX.4 sont identiques aux signaux POSIX.1

32 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps primitives obsolètes

33 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux "Temps Réel" (événemants) ● signaux “Temps Réels” ou "événements POSIX.4" définis par leur numéro, compris entre RTMIN et RTMAX ● Linux, Solaris : RTMIN =37, RTMAX=44 ● peuvent être mis en queue et transporter de l'information ➢ bit SA_SIGINFO dans sa_flags

34 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps utilisation des événements POSIX.4 ● la déclaration d'un handler se fait de la même façon que les signaux classiques par la primitive sigaction, mais on utilise sa_sigaction au lieu de sa_handler sigemptyset(&sa.sa_mask); sa.sa_flags = SA_SIGINFO; sa.sa_sigaction = my_handler; if (sigaction(SIGRTMIN, &sa, NULL) < 0){ perror("sigaction SIGRTMIN"); exit(1); }

35 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps passage de l'information void my_handler (int sig_num, siginfo_t *data, void *extra) typedef struct { int si_signo /* signal number */ int si_errno /* error number */ int si_code /* signal code */ union sigval si_value /* signal value */ } siginfo_t; union sigval {... int sigval_int; void *sival_ptr;... }; si_code SI_QUEUE SI_TIMER SI_ASYNCIO SI_MESGQ SI_USER

36 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps gestion des événements POSIX.4 ● Envoi d'un signal temps réel int sigqueue(pid_t pid,int signo, const union sigval value); ➢ mise en queue du signal (remplace kill ) ➢ consommation de ressources système ● Réception des signaux ➢ en commençant par les plus petits numéros

37 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps autres mécanismes de génération de signaux POSIX.4 ● des signaux peuvent être générés par d'autres mécanismes que sigqueue ➢ notification d'écriture dans une file vide ➢ timers POSIX.4 ➢ entrées/sorties asynchrones ● utilisent la structure sigevent struct sigevent{... int sigev_notify; /* type de notification */... int sigev_signo; /* numéro du signal */... union sigval sigev_value; /* valeur */... }

38 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps synchronisation sur les signaux POSIX.4 int sigwaitinfo (const sigset_t *set, siginfo_t *info); int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout);

39 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps POSIX.1 vs POSIX.4 ● Problèmes rémanents : ➢ vitesse ✔ changements de contexte ➢ asynchronisme ✔ protection du code ✔ peu d'information transportée ● mais il y a des avantages : ➢ asynchronisme ! ➢ mise en place légère ➢ UN process donné peut être visé ➢ peu consommateur de ressources système

40 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux et threads

41 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps signaux et threads ● envoi d'un signal pthread_kill(pthread_t tid, int signo); ➢ uniquement à l'intérieur d'un process donné ● Gestion du masque pthread_sigmask(int op, const sigset_t *set, sigset_t *oldset); ➢ op : SIG_SETMASK, SIG_BLOCK, SIG_UNBLOCK ● Attente sigwait(const sigset_t *set, int *sig); ➢ attente d'un des signaux contenus dans set, stockage du numéro du signal reçu dans signo et retour

42 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Gestion du temps

43 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps Horloges et chronomètres ● Exécution d’une tâche à un moment donné ➢ horloge absolue (clock) ● ou à intervalles réguliers ➢ chronomètres (timers) ✔ à un coup ✔ à répétition ● UNIX (POSIX.1) fournit déjà plusieurs outils ● POSIX.4 rajoute de la précision et des fonctionnalités souvent associées à une horloge "temps réel", externe ou non

44 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les horloges POSIX.1 time: #include time_t time(time_t *what_time); ➢ retourne le nombre de secondes écoulées depuis le 1er janvier h et le stocke dans what_time gettimeofday: struct timeval { time_t tv_sec; time_t tv_usec;} int gettimeofday(struct timeval *what_time); ➢ la résolution est de toutes façons limitée par l'horloge de la machine (~ 0,1s) ➢ codage sur 32 bits ➩ bug du 15 février 2038 !

45 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les timers POSIX.1 #include int setitimer(int id, const struct itimerval *new_value, struct itimerval *old_value); int getitimer(int id, struct itimerval *current_value); id : ITIMER_REAL  signal  SIGALRM ITIMER_VIRTUAL  signal  SIGVTALRM ITIMER_PROF  signal SIGPROF struct itimerval{struct timeval it_value; struct timeval it_interval;}

46 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les timers POSIX.1 ● problèmes de précision et de dérive : la précision ultime est ~ 1 µs ● ITIMER_VIRTUAL (utilisation de la CPU par le process) et ITIMER_PROF (utilisation de la CPU par le process et le système au nom du process) sont utilisés pour le profilage

47 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps la gestion du temps avec POSIX.4 int clock_settime(clockid_t id, const struct timespec *curr_time); int clock_gettime(clockid_t id, struct timespec *curr_time); int clock_getres(clockid_t id, struct timespec *resolution); int timer_create(clockid_t id, const struct sigevent *signal_spec, timer_t *timer_id); int timer_settime(timer_t timer_id, int flags, const struct itimerspec *new_int, struct itimerspec *old_int); int timer_gettime(timer_t timer_id, struct itimerspec *curr_int); int timer_getoverrun(timer_t timer_id); int timer_delete(timer_t timer_id); int nanosleep(const struct timespec *req, struct timespec *remaining);

48 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les horloges POSIX.4 ● Seule CLOCK_REALTIME existe partout struct timespec { time_t tv_sec; time_t tv_nsec; }; ➢ même définition de l’instant initial que POSIX.1 ➢ clock_settime permet de régler l’horloge ➢ clock_gettime permet de lire l’horloge ✔ il y a des fonctions (comme mktime) pour convertir le résultat en quelque chose de lisible

49 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les horloges POSIX.4 ● clock_getres permet de lire la résolution d'une horloge ➢ POSIX.4 impose que la résolution soit meilleure que 50Hz Solaris 2.7 donne la ms Linux n'implémente pas les timers POSIX.4 ➢ nanosleep agit comme sleep, mais avec une bien meilleure résolution, et retourne EINTR s'il est interrompu avant la fin (le second argument contient le temps qu'il restait)

50 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les timers POSIX.4 ● les primitives timer_settime et timer_gettime fonctionnent de façon assez similaire à setitimer et setitimer ● mais en plus: ➢ la résolution est meilleure ( struct timespec et struct itimerspec ) ➢ les timers sont créés de façon dynamique par timer_create (et détruits par timer_delete ) ✔ jusqu'à 32 timers ✔ associés à une horloge POSIX.4 quelconque

51 F. Touchard Cours Temps Réel ESIL Département d'Informatique 2ème année Gestion des interruptions et du temps les timers POSIX.4 ➢ on peut générer n’importe quel signal POSIX.1 ou événement POSIX.4 (SIGALRM par défaut) ➢ les timers sont stoppés automatiquement quand ils sont détruits (et aussi quand on exécute exit ou exec ) ➢ on a la possibilité de fixer un temps absolu (flag TIMER_ABSTIME) ( ⇒ évite d'être préempté pendant que l'on calcule le temps d’expiration)