Exécutif temps réel Pierre-Yves Duval (cppm)

Transcription

1 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

2 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 horloge lanceur ordonnanceur communication agence événements agence tâches agence Exécutif temps agence ressources agence interruptions Monde matériel 2

3 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

4 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 Supprimer Créer Inexistant Supprimer Hors Services Lancer Arrêter Arrêter Créer Actif Prêt Sélection En Cours Opération d attente Préemption Arrivée événement Supprimer Continuer En Attente 4

5 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

6 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 Lire data Copie mémoire Signaler(evt) Créer (evt) Boucle Attendre(evt) Traiter data 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

7 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

8 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() Créer(sem) Boucle Prendre(sem) Insérer(elem,liste) Libérer(sem) Fin boucle Détruire(sem) sem liste Boucle Prendre(sem) exploiter(liste) sortir(elem,liste) Libérer(sem) Fin boucle 8

9 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

10 Communication entre tâches Boite au lettres: Queue de message POSIX Tâche réceptrice dans processus 2 #define MQ "/monrep/mesgq" mqd_t qfd; struct mq_attr qattr; char message_lu[20]; /* nb max msg en queue */ qattr.mq_maxmsg = 32; /* taille maxi d un message */ qattr.mq_msgsize = 20; void recepteur(){ qfd = mq_open (MQ,, &qattr); mq_receive (qfd, message_lu, sizeof (message_lu), ); print(" %s ", message_lu); mq_close(mq); Tâche émettrice dans processus 1 #define MQ "/monrep/mesgq" mqd_t qfd; struct mq_attr qattr; /* nb max msg en queue */ qattr.mq_maxmsg = 32; /* taille maxi d un message */ qattr.mq_msgsize = 20; void émetteur(){ qfd = mq_open (MQ,, &qattr); mq_send (qfd, "tout va bien", ); 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

11 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

12 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

13 Gestion du temps Services génériques: Initialiser_date Lire_date/Lire_heure Attendre_date(date) Signaler_a_date(date) Attendre_délai(delai) suspend la tâche jusqu à la date signaler un événement à une date 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

14 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

15 POSIX Depuis 1984 à l IEEE P 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

16 OS temps réel du marché Tornado,VxW orks Blue CatLinux and LynxO s QNX Neutrino Hard HatLinux 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