Systèmes d Exploitation temps réel. Programmation des STR. Gabriel FREY 2013 freyg.it@gmail.com

Transcription

1 Systèmes d Exploitation temps réel 1

2 2 Plan de l intervention 1. Introduction aux Systèmes Temps Réel 2. Programmation concurrente Synchronisation et communication Besoin en facultés temporelles 3. Ordonnancement 4. FreeRTOS

3 3 Programmation concurrente

4 4 Programmation concurrente Réfère à un système décomposé en tâches pouvant être exécutées dans un ordre quelconque. Certaines tâches sont exécutées avant d autres, et certaines le sont en parallèle. Ne pas confondre avec programmation parallèle (exécution simultanée de tâches sur différents processeurs).

5 5 Programmation concurrente Pourquoi? Le système agit avec des parties concurrentes de son environnement. Reconnaître le parallélisme dans le programme mène à une structure plus naturelle.

6 6 Notion de tâche Un système est une collection de tâches autonomes s exécutant en parallèle. Une tâche : (Statiquement) est décrite par un programme séquentiel. (A l exécution) a son propre fil de contrôle. peut communiquer et partager des ressources avec d autres tâches.

7 7 Notion de tâche Interprétation de la tâche varie au cours du cycle de développement : Analyse/conception : une tâche est une série d actions déclenchées par un stimulus provenant d un capteur ou l arrivée d une échéance temporelle. Implémentation : une tâche est un processus, un thread, une co-routine,

8 8 Processus et thread Processus : fil de contrôle exécuté dans sa propre machine virtuelle (espace mémoire, handle de fichiers, ). Tous les OS fournissent la notion de processus. Thread : fil de contrôle exécuté en parallèle d autres threads dans un même processus (partage de l espace mémoire, ). Certains langages fournissent cette notion (Ada, Java : oui / C, C++ : non).

9 9 Permet d exprimer : Constructions L existence ou la création de tâches concurrentes. La communication entre tâches. La synchronisation entre tâches. Les tâches peuvent être : Indépendantes. Coopérantes (besoin de communication). En compétition (besoin de synchronisation).

10 10 Modèles de concurrence

11 11 Création d une tâche Statique : toutes les tâches sont créées dès le démarrage du système. Elles ne changent pas au cours de l exécution. Dynamique : on peut créer des tâches en cours d exécution.

12 12 Création d une tâche // déclaration de tâche public class TacheA extends java.lang.thread { public void run(){ // prog séquentiel pour TacheA } } // création explicite TacheA a = new TacheA (); a.start();

13 13 Modèle fork / join Fork : spécifie qu une tâche commence à s exécuter en parallèle avec l appelant (parent). Join : permet à l appelant d attendre (état suspendu) la fin de la tâche créée. pid_t pid; pid = fork(); if(pid == (pid_t)-1) { /* Traitement d'erreur */ } else if(0 == pid) { /* Processus fils */ } else { /* Processus parent */ }

14 14 Synchronisation et communication

15 15 Synchronisation et communication Le comportement d un programme concurrent dépend de la synchronisation et de la communication entre ses différentes tâches.

16 16 Synchronisation et communication Synchronisation : satisfaction de contraintes sur l entrelacement des actions de plusieurs tâches (ex.: action A de la tâche P s exécute uniquement après action B de la tâche R).

17 17 Synchronisation et communication Communication : Passage d informations d une tâche à une autre. Le mécanisme est basé sur le partage d une mémoire commune ou le passage de messages. Les deux concepts sont liés.

18 18 Synchronisation

19 19 Interférence or not interférence? Thread 1 Thread 2 x = 5 mov AX, x mov AX, x inc AX inc AX mov x, AX mov x, AX x =?

20 20 Interférence or not interférence? Thread 1 Thread 2 x = 5 mov AX, x mov AX, x inc AX inc AX mov x, AX mov x, AX x =?

21 21 Interférence or not interférence? Thread 1 Thread 2 x = 5 mov AX, x mov AX, x inc AX inc AX mov x, AX mov x, AX x =?

22 22 Éviter les interférences! L exécution indivisible des séquences d instructions qui accèdent à des variables partagées est nécessaire. Mécanismes de synchronisation autour des sections critiques.

23 23 Éviter les interférences! Thread 1 Thread 2 x = 5 mov AX, x mov AX, x Section critique inc AX inc AX Section critique mov x, AX mov x, AX x = 7

24 24 Deux types de synchronisation Exclusion mutuelle : Assurance pour une tâche que l exécution d une séquence d instructions se fait sans interférences. Cette séquence d instruction s appelle section critique. Attente conditionnelle : Une tâche doit exécuter une action uniquement après une autre action d une autre tâche. Ex.: tampon fini. Consommateur Producteur

25 25 Exigences pour les sections critiques Exclusion mutuelle. Compétition constructive : Les tâches ne s'empêchent pas réciproquement d'entrer. Les tâches ne s'invitent pas réciproquement à entrer à l'infini. Indépendance : Si une tâche est plus lente cela n'a pas d'effet sur l'entrée des autres tâches dans leurs sections critiques Équité : Une tâche ne peut être retardée à l'infini à l'entrée de sa section critique

26 26 Synchronisation avec attente active Utiliser une variable partagée comme flag. Consommateur : while(flag){} // consommation flag = true; Attente active Producteur : // production flag = false; Fonctionne avec l attente active mais difficile à mettre en place dans le cas de l exclusion mutuelle.

27 27 Exclusion mutuelle avec attente active Fausse solution n 1 : Thread 1: while(1){ flag1 = true; while(flag2){} /* section critique */ flag1 = false; } Thread 2: while(1){ flag2 = true; while(flag1){} /* section critique */ flag2 = false; } Possibilité d interblocage.

28 28 Exclusion mutuelle avec attente active Fausse solution n 2 : Thread 1: while(1){ while(flag2){} flag1 = true; /* section critique */ flag1 = false; } Thread 2: while(1){ while(flag1){} flag2 = true; /* section critique */ flag2 = false; } Pas d exclusion mutuelle.

29 29 Exclusion mutuelle avec attente active Fausse solution n 3 : Thread 1: Thread 2: while(1){ while(2 == tour){} /* section critique */ tour = 2; /* section non critique */ } while(1){ while(1 == tour){} /* section critique */ tour = 1; /* section non critique */ } Les tâches doivent revenir à la section critique au même rythme.

30 30 Exclusion mutuelle avec attente active Algorithme de Peterson (1981) : Thread 1: Thread 2: while(1){ flag1 = true; tour = 2; while(2 == tour && flag2){} /* section critique */ flag1 = false; } while(1){ flag2 = true; tour = 1; while(1 == tour && flag1){} /* section critique */ flag2 = false; }

31 31 Exclusion mutuelle avec test_and_set Suppose une opération atomique test_and_set(b). Si b==0 alors (b=1, return 0) sinon (return 1) Thread 1: Thread 2: while(1){ while(test_and_set(b)){}; /* section critique */ b = 0; } Disponible sur certains processeurs. while(1){ while(test_and_set(b)){}; /* section critique */ b = 0; }

32 32 Éviter l attente active : sémaphores Sémaphore : mécanisme de synchronisation composé de : Une variable entière n. Si n > 0, alors n est le nombre de tâches qui peuvent passer par le sémaphore avant que ce dernier ne soit plein. Si n = 0, alors les tâches qui veulent passer par le sémaphore se rangent dans la file f et deviennent suspendues (attente passive). Une file d attente f.

33 33 Éviter l attente active : sémaphores n et f sont accessibles via deux opérations : P (WAIT) : la tâche courante souhaite obtenir le semaphore. Si n > 0, alors n = n -1 et retour immédiat Sinon suspension dans f V (SIGNAL) : la tâche courante libère le sémaphore. Si f non vide, choix d une tâche suspendue pour reprise Si f vide, n = n + 1

34 34 Éviter l attente active : sémaphores Il y a toujours une attente active pour l exclusion mutuelle entre P et V. mais la durée d attente est très courte et ne dépend pas des tâches utilisateur.

35 35 Conclusion sur les sémaphores Mécanisme puissant mais de bas niveau. Si une des tâche «oublie» une opération de sémaphore, cela peut mener tout le système à l interblocage. Mécanismes plus structurés existants.

36 36 Régions critiques conditionnelles (CCR) Grouper les données partagées dans une ressource. Une CCR est une portion de code en exclusion mutuelle sur une ressource. L entrée dans une CCR peut être gardée par une condition sur la ressource.

37 37 Moniteurs L objectif du moniteur est de grouper les régions critiques (pour une ressource) dans un seul endroit du code. Les régions critiques : Moniteur met à disposition des procédures. Variables partagées : Masquées par le moniteur. Accessibles uniquement par des procédures.

38 38 Moniteurs POSIX int pthread_mutex_init (pthread_mutex_t *mutex,...); int pthread_cond_init (pthread_cond_t *cond,...); int pthread_mutex_lock (pthread_mutex_t *mutex); int pthread_mutex_trylock (pthread_mutex_t *mutex); int pthread_mutex_timedlock (pthread_mutex_t *mutex, const struct timespec *abstime); int pthread_mutex_unlock (pthread_mutex_t *mutex); int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex); int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); int pthread_cond_signal (pthread_cond_t *cond); int pthread_cond_broadcast (pthread_cond_t *cond);

39 39 Moniteurs JAVA Java fournit le concept de moniteur dans le contexte d objets ou de classes. Chaque objet ou classe a par défaut un mutex(lock) : Non accessible directement. Bloqué/débloqué par le mot clé «synchronized». Bloqué/débloqué par l entrée dans un bloc : synchronized(obj){ } Les méthodes synchronisées ont un accès exclusif à leurs objets.

40 40 Communication et synchronisation par messages

41 41 Message asynchrone Thread 1 Thread 2 Envoi message Reception message Nécessite un buffer pour stocker les messages.

42 42 Message synchrone Thread 1 Thread 2 Thread 1 suspendu Envoi message Reception message Pas besoin de buffer -> «rendez-vous».

43 43 Appel de procédure distante (RPC) Thread 1 Thread 2 Envoi message Thread 1 suspendu Reception message Exécution procédure Return

44 44 Résumé : communication et synchronisation Principaux types de synchronisation : Attente conditionnelle. Exclusion mutuelle. Section critique : groupe d instructions qui doit s exécuter en exclusion mutuelle.

45 45 Résumé : communication et synchronisation Mécanismes de synchronisation : Algos basés sur l attente active. Sémaphores. Régions critiques conditionnelles. Moniteurs. Formes de communication par message : Message asynchrone (pas d attente à l envoi). Message synchrone (attente, synchronisation). Appel de procédure distante.

46 46 Besoins en facultés temporelles

47 47 Besoin en facultés temporelles Notions liées au temps : Accéder à des horloges pour mesurer le passage du temps. Retarder un processus à un moment ultérieur. Programmer une temporisation pour traiter l absence d un évènement (timeout). Représenter les exigences temporelles : Spécification des échéances (deadline).

48 48 Notion de temps Mêmes propriétés que les nombres réels : Ordre strict : x, y, z : (x < y y < z) => x < z x, y : x < y y < x x = y x : not(x < x) Dense : x, y : x < y => z : (x < z y) (x z < y)

49 49 Types de données et opération Temps absolu : Identifie de manière unique chaque instant. Ex: Date : Heure Durée relative : Désigne la distance entre deux moments.

50 50 Le temps RT en Java Nombre de secondes depuis le 1er Janvier 1970, 00:00 GMT public abstract class Clock { public Clock(); public static Clock getrealtimeclock(); public abstract RelativeTime getresolution(); public AbsoluteTime gettime(); public abstract void settime(absolutetime time); public abstract void setresolution(relativetime resolution); }

51 51 Type clockid_t : Le temps RT en POSIX Constante CLOCK_REALTIME donne le temps relatif au 1 er Janvier 1970, 00:00 GMT. struct timespec : temps relatif ou absolu. Quelques fonctions : int clock_gettime(clockid_t clock_id, struct timespec *tp); int clock_settime(clockid_t clock_id, struct timespec *tp); int clock_getres(clockid_t clock_id, struct timespec *res); int nanosleep(struct timespec *rqtp, struct timespec *rmt);

52 52 Retarder un processus But : retarder sans occuper le processeur. Java / POSIX : fonction sleep(). Un délai est un minimum, pas un maximum. Granularité de l horloge En attente d ordonnancement Temps Appel à Sleep() Délai passé Processus reprend son activité

53 53 Programmer une temporisation But : limiter la durée d une tâche bloquée en attente d une communication / synchronisation. Ex: si les données du capteur de température ne sont pas disponibles au bout de 100ms, signaler la panne. Ex: si le consommateur ne libère pas une place dans le buffer au bout de 100ms, annuler l écriture. Lié aux primitives de synchronisation.

54 54 Temporisation des actions But : limiter la durée d exécution d une action. Ex: calcul par un algorithme itératif la valeur approximative d une variable V. Arrêt après 10ms. C est une sorte d interruption. Exemple d action interruptible en Java RT. interface javax.realtime.interruptible{ void run(asynchronouslyinterruptedexception e) throws AsynchronouslyInterruptedException; void interruptaction(asynchronouslyinterruptedexception e) }

55 55 Représenter les exigences temporelles Identifier les éléments à caractériser : Bloc de code, fonction, tâche, scénario impliquant plusieurs tâches, Caractériser finement l aspect temporel : Temps minimum entre arrivées, temps d exécution au pire cas, échéance relative ou absolue, temps d attente maximum pour une ressource, Associer une action au cas ou une exigence n est pas respectée.

56 56 Besoins : Résumé : facultés temporelles Accéder à des horloges. Retarder une tâche. Temporisation. Spécifier les caractéristiques temporelles des tâches. Tolérance aux fautes : Détection du dépassement d échéance, détection du dépassement du temps CPU, détection du non respect des lois d arrivée,