systèmes & programmations temps réelle
DESCRIPTION
Systèmes & Programmations Temps Réelle. Master MSRS [email protected]. Programmations temps Réelle. Problématique des RTOS Quelqu'un pose des questions concernant la température extérieure actuelle. Laquelle est la meilleure réponse ? - PowerPoint PPT PresentationTRANSCRIPT
Systèmes & Programmations Systèmes & Programmations Temps RéelleTemps Réelle
Master [email protected]
1
Programmations temps Réelle
Problématique des RTOSQuelqu'un pose des questions concernant la température extérieure actuelle. Laquelle est la meilleure réponse ?
• Une réponse correcte de 20 ° C mais livré 12 heures plus tard; • ou Une lecture erronée de 10 ° C livré immédiatement;
Dans un système temps réel, une réponse tardive est tout aussi mauvais qu'une réponse fausse
ObjectifsDans ce cours, nous allons introduire des méthodes et des modèles pour contrôler le comportement temporel des programmes, en outre leur fonctionnalité
2
Définition
• Les systèmes informatiques temps réel se différencient des autres systèmes informatiques par la prise en compte de contraintes temporelles dont le respect est aussi important que l'exactitude du résultat
système TR ne doit pas simplement délivrer des résultats exacts, il doit les délivrer dans des délais imposés.
3
4
Domaine d'utilisation
• Les systèmes informatiques temps réel sont aujourd'hui présents dans de nombreux secteurs d'activités
• Industrie de production par exemple, au travers des systèmes de contrôle de procédé (usines, centrales nucléaires),
• Marché Boursier au travers du traitement des données boursières en « temps réel »
• Aéronautique au travers des systèmes de pilotage embarqués (avions, satellites),
• Médecine -- Robots
5
RTOS
• Le développement de systèmes temps réel nécessite donc que chacun des éléments du système soit lui-même temps réel (prendre en compte des contraintes temporelles)
• système d'exploitation conçu pour prendre en compte ces contraintes est appelé système d'exploitation temps réel « RTOS »
6
Exemple : Impact du temps réel sur les systèmes
7
Le but de l'expérience est de générer un signal périodique sortant du port parallèle du PC.
•Le temps qui sépare deux émissions du signal sera mesuré à l'aide d'un compteur. •Le but est de visualiser l'évolution de ce délai en fonction de la charge du système. • La fréquence initiale du signal est de 25 Hz (Hertz) ce qui donne une demi-période T/2 de 20 ms.
8
Sur un système classique, cette demi-période varie de 17 à 23 ms, ce qui donne une variation de fréquence entre 22 Hz et 29 Hz. La figure ci-dessous donne la représentation graphique de la mesure sur un système non chargé puis à pleine charge
9
Sur un système temps réel, la demi-période varie entre 19,990 ms et 20,015 ms, ce qui donne une variation de fréquence de 24,98 Hz à 25,01 Hz. La variation est donc beaucoup plus faible. La figure donne la représentation graphique de la mesureLorsque la charge est maximale, le système temps réel assure donc une variation de +/- 0,2 Hz alors que la variation est de +/- 4 Hz dans le cas d'un système classique.
10
CPU sans Charge
On remarque que l'on n'a pas une période de 100 ms mais de 119,6 ms dû au temps supplémentaire d'exécution des appels système.
CPU avec Charge
On stresse le système (écriture répétitive sur disque d'un fichier de 50 Mo), on observe Effet de Jitter(gigue). La gigue maximale sur la durée de l'expérience est de 17,6 ms. La forme du signal varie maintenant au cours du temps, n'est pas de forme carrée mais rectangulaire. LINUX n'est donc plus capable de générer correctement ce signal
Rappel OS
11
• Système d'exploitation se présente donc comme une couche logicielle placée entre la machine matérielle et les applications
• OS s'interface avec la couche matérielle, notamment par le biais du mécanisme des interruptions
• OS peut être découpé en plusieurs grandes fonctions
12
• Gestion du processeur – algorithme d'ordonnancement qui planifie l'exécution
des programmes.• Gestion de la mémoire
– Allocation de mémoire• Gestion des entrées/sorties• Gestion de la concurrence
– synchroniser l'accès aux données partagées afin de maintenir leur cohérence
• Gestion des objets externes– Système de gestion de fichiers (SGF)
• Gestion de la protection
13
RTOS
14
RTOS1- Task management and scheduling
– Gestionnaire des Taches est la tâche principale du système d'exploitation
• les tâches doivent être créés et supprimés alors que le système est en cours d'exécution;
• les tâches peuvent modifier leurs niveaux de priorité, leurs contraintes de temps, leurs besoins en mémoire; etc
15
RTOS Gestion des tâche est plus dangereuse Gestion des tâche est plus dangereuse que pour un usage général OSque pour un usage général OSExemple : Si une tâche temps réel est créée, il doit
obtenir la mémoire dont il a besoin sans délai, et que la mémoire doit être verrouillée pour éviter:
1. les temps d'accès en raison de permutation,2. l'évolution des priorités d'exécution influe sur le
comportement à l'exécution de l'ensemble du système
la prévisibilité qui est très important la prévisibilité qui est très important pour RTOSpour RTOS
16
2- Services des Interruptions
• Un système d'exploitation ne doit pas seulement être en mesure de planifier des tâches selon un algorithme déterministe, mais elle a aussi la tache de servir le matériel périphérique via interruption
17
3- Communication & synchronisation
• IPC (Inter-Process Communication )recueille un grand nombre de primitives de programmation que l’OS met à la disposition des tâches qui ont besoin d'échanger des informations avec d'autres tâches, ou de synchroniser leurs actions;
• RTOS doit s'assurer que cette communication et la synchronisation se déroulent de manière déterministe;
• Cette communication peut être effectuer avec d'autres ordinateurs, ou avec le matériel périphérique.
18
4 -Gestion mémoire
• Donner à chacun la tâche de la mémoire dont il a besoin (allocation de mémoire)
• Prendre les « mesures appropriées » lorsqu'une tâche utilise la mémoire qu’elle ne lui a pas été attribué. – Exemple : pointeurs non connecté et d'indexation de
tableau au-delà des limites du tableau"mesures appropriées« : dépend de l'application, souvent
cela se résume à la solution la plus simple: tuer la tâche et avertir l'utilisateur
19
Trade-offs (compromis)
20
noyau monolithiquenoyau monolithiquemicro-noyaumicro-noyau
Espace noyau vis-à-vis espace utilisateurEspace noyau vis-à-vis espace utilisateur
• Un noyau monolithique possède tous les services de l'OS (y compris les pilotes de périphérique, piles de réseau, les systèmes de fichiers, etc) en cours d'exécution en mode privilégié du processeur.
• Un micro-noyau, d'autre part, utilise le mode privilégié uniquement pour les services vraiment de base (gestion des tâches et ordonnancement, communication inter-processus, la gestion des interruptions, et de la mémoire gestion), et possède la plupart des pilotes de périphériques et de services de l'OS en tant que des tâches «normales»
21
Noyau préemptif ou non
• Linux a été initialement un noyau non-préemptif– une tâche "espace noyau" ne peut pas être interrompu ne peut pas être interrompu par d'autres tâches de
"l'espace noyau", ou par des tâches de « l'espace utilisateur »
22
•Le noyau est "verrouillé " tant qu’il est en exécution. •Utilisation de serrures permet la conception de la plus simple du noyauInconvénient : il introduit des latences déterministes latences déterministes qui ne sont pas tolérables dans un RTOS.
Contrainte de temps
• " Un système d'exploitation temps réel est capable d'exécuter toutes ses Un système d'exploitation temps réel est capable d'exécuter toutes ses tâches sans tâches sans violer les contraintes de temps violer les contraintes de temps spécifié spécifié «
• « Temps au cours de laquelle les tâches exécutera peut être « Temps au cours de laquelle les tâches exécutera peut être prédit de façon prédit de façon déterministe déterministe sur la base des connaissances sur le coté matériel et logiciel du sur la base des connaissances sur le coté matériel et logiciel du systèmesystème «
• On distingue le temps réel strict strict ou durdur (de l'anglais hard real-time) et le temps réel souplesouple ou moumou (soft real-time) suivant l'importance accordée aux contraintes temporelles.
• Le temps réel strict ne tolère aucun dépassement de ces contraintes, – tels dépassements peuvent conduire à des situations critiques, voire
catastrophiques :• Exemple : pilote automatique d'avion, système de surveillance de centrale nucléaire, etc.
• À l'inverse le temps réel souple s'accommode de dépassements des contraintes temporelles dans certaines limites au-delà desquelles le système devient inutilisable : visioconférence, jeux en réseau, etc.
23
Le temps de latence • Le temps de latence (ou retard) d'une tâche = différence
entre l'instant de temps sur laquelle la tâche doit commencer (ou terminer) et l'instant à laquelle il est effectivement en exécution – le temps écoulé entre la génération d'un événement, et sa
perception
24
r : date de réveil c'est le moment du déclenchement de la 1ere requête d'exécutionC : durée d'exécution maximale (capacité)D : délai critique c'est le délai maximum acceptable pour son exécutionP : période si la tâche est périodique
Le temps de latenceLe temps de latence est du à plusieurs facteurs: (i) les propriétés de synchronisation du processeur, bus, la mémoire
(mémoire cache, RAM hors puce et ROM) et périphérique dispositifs;(ii) les propriétés de la programmation du système d'exploitation;(iii) le caractère préemptif ou non du noyau;(iv) la charge sur le système ( le nombre de tâches qui veulent être
programmées en même temps);(v) le temps du au changement de contexte. Ce dernier est le temps
nécessaire que le processeur a besoin pour sauvegarder les données de la tâche en cours d'exécution (par exemple, les registres, la pile et pointeur d'instruction), et de le remplacer par les données locales de la tâche nouvellement prévue.
Conséquence:Conséquence:– Ces facteurs ne sont pas constants au fil du temps et introduisent
l'indéterminisme dans le comportement temporel du système
25
Ordonnancement temps-réel
Problème– Calculs à exécuter + contraintes de temps = dans quel
ordre exécuter ?DéfinitionDéfinition
Ensemble des règles définissant l’ordre d’exécution des calculs sur le processeur
Pourquoi ordonnancerPourquoi ordonnancer ?Parce que ça a un impact sur le respect des contraintes
de tempsExemple• Tâche T1 : arrivée en r=0, durée C=4, échéance D=7• Tâche T2 : arrivée en r=2, durée C=2, échéance D=5• Ordonnancement O1Ordonnancement O1: premier arrivé, premier servi,
on n’interrompt jamais une tâche• Ordonnancement O2Ordonnancement O2: priorité, T2 plus prioritaire
que T126
C’est quoi une Thread?
27
•Une thread peut être vue comme étant la plus petite unité d'exécution. •Chaque thread a :
• sa pile, •son pointeur de programme • ses registres.
•Processus définit le contextecontexte dans lequel les threads s'exécuteront.
Le contexte contient les threads, le code exécutable, les données, les descripteurs de fichiers, les outils de synchronisation, etc.
Processus = = conteneur de threads(processus est décomposé en tâches ).•tâche est une sorte de processus léger plus ou moins indépendamment des autres
28
Classification des ordonnancements
• Instant ou l’ordre d’exécution est décidé : hors-ligne /en-ligne
• Possibilité d’interruption d’une tâche par une autre: préemptif / non préemptif
• Optimalité : quel est le « meilleur » ordonnancement
29
Buts de l'ordonnancement
Piloter l'application avec 2 objectifs majeurs :➢ en fonctionnement nominal : respect des contraintesrespect des contraintes
temporellestemporelles➢ en fonctionnement anormal (par exemple pannes
matérielles) : atténuer les effets des surcharges atténuer les effets des surcharges et maintenir un état cohérent et sécuritaire
ordonnancer = planifier l'exécution des requêtes de façon à respecter les contraintes de temps
➢ de toutes les requêtes en fonctionnement nominal➢ d'au moins les requêtes les plus importantes (c'est-a-dire
celles nécessaires a la sécurité du procède) en fonctionnement anormal
(RT dure)
30
Ordonnancement « hors-ligne » / « enligne"
Ordonnancements "en-ligne "– Les décisions d’ordonnancement sont prise au
cours de l’exécution– A l’exécution, l’ordonnanceur implante un
algorithme d’ordonnancement permettant de savoir à tout instant quel tâche exécuter : besoin d’un exécutif multitâche
– Généralement, ordonnancements conduits par la priorité
31
Ordonnancement non préemptif / préeemptif
• Non préemptif: On n’interrompt jamais l’exécution d’une tâche en cours au profit d’une autre tâche
• Préemptif: La tâche en cours peut perdre involontairement le processeur au profit d’une autre tâche (jugée plus urgente)
Remarques : orthogonal par rapport à la classification en-ligne / hors-ligne
32
Exemple d’ordonnancement préemptif : conduit par la priorité
33
• Algorithme d’ordonnancement : sélectionner la tâche la plus prioritaire• priorité(T3) > priorité(T2) > priorité(T1) (ici, priorités fixes)T1, T2 et T3 arrivent respectivement aux dates 1, 2,et 3
Caractéristiques des tâches
• r : date de réveil c'est le moment du déclenchement de la 1ere requête d'exécution
• C : durée d'exécution maximale (capacité)• D : délai critique c'est le délai maximum acceptable pour son exécution• P : période si la tâche est périodique• d = r+D : échéance (si tâche a contraintes strictes)
• Pour les tâches périodiques : rk = r0 + k*P
– Si D = P, tâche est une tâche à échéance sur requête
34
paramètres statiquesparamètres statiques ➢ Ui = Ci/Pi : facteur d'utilisation du processeur c-à-d pourcentage de l’activité du processeur dédiée à la tâche Ti
➢ CH = C/D : facteur de charge du processeurparamètres dynamiquesparamètres dynamiques
➢ s : date du début de l'exécution ➢ e : date de la fin de l'exécution ➢ D(t) = d-t : délai critique résiduel a la date t (0 ≤ D(t) ≤ D) ➢ C(t) : durée d'exécution résiduelle a la date t (0 ≤ C(t) ≤ C) ➢ L = D-C : laxité nominale de la tâche
• ✔ Retard maximum pour son début d'exécution s (si elle est seule)
• ➢ L(t) = D(t) - C(t) : laxité nominale résiduelle• ✔ Retard maximum pour reprendre l'exécution• ➢ TR = e - r : temps de réponse de la tâche• ➢ CH(t) = C(t)/D(t) : charge résiduelle (0 ≤ CH(t) ≤ C/P)
35
Etat d'une tâche
Les diverses états d’une tâche:– Prêtes (ready) : la tâche n'a pas encore commencé à s'exécuter ou à
être interrompue par préemption– en cours d'exécution (running) : la tâche est en cours d'exécution et
utilise le processeur– bloquées (blocked) : de manière générale, la tâche est en attente de
la ressource– endormie (sleeping) : la tâche n'est pas encore terminée et est en
attente d'un réveil.
36
Définition
configuration : ensemble de n taches mises en jeu par l'application➢ Facteur d'utilisation du processeur ➢ Facteur de chargePour tout système de n tâches, la condition suivante est nécessaire mais pas
suffisante à sa faisabilité :U<1
Avec Ci le temps de calcul de la tâche n° i et Pi sa période. Une valeur supérieure à 1 signifierait que le système nécessite plus de temps d'exécution que le processeur ne peut en fournir.
Intervalle d'etude Intervalle d'etude : intervalle de temps minimum pour prouver l'ordonnançabilite d'une configuration
➢ Le PPCM des périodes dans le cas d'une configuration de tâches périodiqueslaxité du processeur LP(t) laxité du processeur LP(t) = intervalle de temps pendant lequel le processeur peut
rester inactif tout en respectant les échéances• ✔ laxité conditionnelle: (somme sur les taches déclenchées a la date t et qui
sont devant i du point de vue de l'ordonnancement)• ✔ LP(t) = min(LCi(t))
37
Ordonnancement des tâches independents
tâches périodiques
1. A priorités statiques
• Rate monotonic : fondé sur les périodes• Deadline monotonic : fondé sur les délais critiques
2 A priorités dynamiques
• Earliest deadline : fondé sur les échéances• Least laxity : fondé sur la marge de manœuvre restante
38
Rate Monotonic Analysis (RMA)Rate Monotonic Analysis (RMA)
• Algorithme a priorité constante• Condition d’ordonnançabilité (pour Pi = Di) • se base sur la période (taches à échéance sur requête) :
la tâche de plus petite période est la plus prioritaire
• test d'acceptabilités (condition suffisante) : théoriquement, le concepteur d'un système temps réel prétendu strict devrait être capable de prouver que les limites temporelles ne seront jamais dépassées quelle que soit la situation. Cette vérification est appelée "test d'acceptabilité", "analyse de faisabilité" ou encore "contrôle d'admission.
– Elle dépend de l'ordonnanceur utilisé et des caractéristiques des tâches du système.
39
quand nn est très grand : n (2n (21/n1/n – 1) ~ ln 2 = 0,69 – 1) ~ ln 2 = 0,69
Exemple :T1 (r0=0, C=3, P=20), T2 (r0=0, C=2, P=5), T3 (r0=0, C=2, P=10) ΣCi/Pi = 3/20+2/5+2/10 = 0,75 n(21/n−1) =3(21/2−1)= 0,77 Le test d'acceptabilités est validéPriorité2 > Priorité3 > Priorité1 (le classement s'effectue sur la période la plus petite)
40
Deadline Monotonic Analysis (DMA)
• Algorithme a priorité constante• base sur le délai critique D:• ➢ La tâche de plus petit délai critique est la plus
prioritaire
• test d'acceptabilités (condition suffisante)
• Équivalent à RMA dans le cas des taches à échéance sur requête, meilleur dans les autres cas
41
Exemple: T1(r0 = 0, C=3, D=7, P=20), T2 (r0 = 0, C=2,
D=4, P=5),T3 (r0 = 0, C=2, D=9, P=10)ΣCi/Pi= 3/7+ 2/4+ 2/9 = 1,14 ≥ n(21/n−1) = 0,77Priorité2 > Priorité1 > Priorité3 (le classement
s'effectue sur le plus petit délai critique D)
42
Tâches apériodiques
Tâches apériodiques : elles correspondent aux événements; elles se réveillent de manière aléatoire.– Apériodiques strictes : contraintes temporelles
dures à respecter absolument.– Apériodiques relatives : contraintes temporelles
molles qui peuvent être ou non respectées de temps à autre (sans échéance).
43
Model Tâche apériodique Stricter: date aléatoire de réveil de la tâcheC: durée d ’exécution maximaleD : délai critique dk : échéance = rk + RR(t): délai critique dynamique (temps restant à t jusqu’à d)Tap( r, C, R)Tap (t, C(t), R(t)) Diagramme temporel d ’exécution
44
Modèle canonique d'une tâche apériodique temps réel Tap (t, C(t), Dt)) C(t): temps d’exécution restant à t
Traitement d'arrière-plan
• taches apériodiques ordonnancées quand le processeur est oisif
• ➢ les tâches périodiques restent les plus prioritaires
• ordonnancement relatif des taches apériodiques en mode FIFO
• traitement le plus simple, mais le moins performant
45
• exemple• Tp1 (r0=0, C=2, P=5), Tp2 (r0=0, C=2, P=10)• Ta3 (r=3, C=2), Ta4 (r=10, C=1), Ta5 (r=11, C=2)• ➢ ordonnancement RMA des taches periodiques
46
Serveur des Tâches apériodique
•Serveur de scrutation :• A chacun de ses réveils, le serveur sert les tâches
apériodiques en attentedepuis son réveil précédent- jusqu’à épuisement des tâches apériodiques- jusqu’à épuisement de sa capacité• L’ordre de service des tâches apériodiques est
quelconque• La capacité non utilisée est perdue
47
48
49
Exemple de tâche Serveur Scrutation
Thread Thread POSIXPOSIX : Pthread : Pthread
Qu'est ce qu'est un thread?– Techniquement, un thread est défini comme un
flux d'instructions indépendant qui peut être programmé pour s'exécuter en tant que tels par le système d'exploitation.
Mais qu'est-ce que cela signifie?• Pour le développeur du logiciel, le concept d'une
«procédure» qui s'exécute indépendamment de son programme principal peut le mieux décrire un thread.
50
AnalogiePour aller plus loin, imaginez un programme
principal (a.out) qui contient un certain nombre de procédures.
Alors imaginez toutes ces procédures pouvant être programmé pour s'exécuter simultanément et / ou de façon indépendante par le système d'exploitation.
ça serait de décrire un programme «multi-thread».
51
Avant de pouvoir comprendre le fonctionnent d’un thread, il faut d'abord comprendre le fonctionnent d’un processus UNIX.
Un processus est créé par le système d'exploitation, et exigeant « Overhead » en terme d'exploitation de ressources en particulier des informations sur les ressources du programme et l'état d'exécution du programme, notamment:– Process ID, process group ID, user ID, and group ID – Registers – Stack – Heap – File descriptors – Inter-process communication tools (such as message
queues, pipes, semaphores, or shared memory)… etc.
52
Threads utilisent et existent au sein même des ressources de processus;
Threads fonctionnent en grande partie comme des entités indépendantes parce qu'ils reproduire uniquement les ressources dont ils auraient besoin et qui leur permettraient d'exister en tant que code exécutable.
Thread gère ses propres ressources(indépendance) :– Stack pointer – Registers – Scheduling properties (such as policy or priority) – Set of pending and blocked signals – Thread specific data.
53
54
En résumé, dans l'environnement UNIX un threadEn résumé, dans l'environnement UNIX un thread:– Existe au sein d'un processus et utilise les ressources de
processus– A son propre flux de contrôle est indépendant aussi longtemps
que son processus parent existe et le système d'exploitation qu'il supporte
– Duplique seulement les ressources essentielles dont il a besoin d'être ordonnancés indépendamment
– Peuvent partager les ressources de processus avec les autres threads qui agissent aussi de façon indépendante (et dépendante)
– Détruit si le processus parent meurt - ou quelque chose de semblable
– Thread est"léger" car la plupart des coûts d'exploitation a déjà été accompli par la création de son processus.
– Comparé au coût de création et de gestion d'un processus, un thread peut être créé avec des « Overhead » du système d'exploitation beaucoup moins élevé.
55
56
Applications multitâches offrent des gains de performance potentiels et des avantages pratiques par rapport aux applications n'utilisant pas les threads
par exemple :• Le chevauchement de travail CPU avec les opérations d'
E/S: Par exemple, un thread peut effectuer des traitements des données reçus de la dernière opération E / S alors qu'un autre thread est en attente d'une nouvelle opération d'E/S et ne pas bloquer l'opération de E/S jusqu'a la fin de traitement.
• Priorité / ordonnancement temps-réel: les tâches qui sont plus importantes peuvent être prévues pour remplacer ou interrompre des tâches de moindre priorité.
• La gestion des événements asynchrones: Par exemple, un serveur web peut à la fois le transfert de données de demandes précédentes et à gérer l'arrivée de nouvelles demandes.
57
Thread-safeThread-safe
• Si la routine n'emploie pas une sorte de synchronisation des actions pour empêcher la corruption de données, alors il n'est pas thread-safe.
58
Pthreads API Pthreads API Création de threadCréation de threadint pthread_create(pthread_t *tid, const pthread_attr_t *tattr,void*(*start_routine)(void *),
void *arg); – Id du thread– Les attributs du thread– La fonction à executer– Le premier argument de la function à executer
#include <pthread.h>//fonction effectuant un traitementvoid *thr_f (void* param){int * t = (int *) param;printf ("parametre : %d", *t);}int main (){pthread_t thr1;pthread_create(&thr1,NULL,thr_f,arg);return 0;}
59
Les attributs d’un thread :– le type d'ordonnancement– la priorité– la taille de la pile– Par défaut– SCHED OTHER : toutes les threads se partagent le– processeur en fonction de leur priorité.– Hérite de la priorité des parents (priorité=12, héritage=0)– Taille de la pile par défaut : 61440
Modifier les attributs d'un thread
– Modifier l'ordonnancement :• int pthread_attr_setsched(pthread_attr_t *attr_pt, int
scheduler);– Modifier la priorité :
• int pthread_attr_setprio(pthread_attr_t *attr_pt, int prio);– Modifier la taille de la pile :
• int pthread_attr_setstacksize(pthread_attr_t *attr_pt, long size);
60
Valeur du thread• pthread_t pthread_self(void); Renvoie la valeur du thread
appelant. Attendre qu'un thread se termine• int pthread_join(thread_t tid, void **status);
Suspend l'activité de la thread appelante tant que la thread tid n'est pas terminée.
status contient la valeur de retour du thread tid lors de sa terminaison.
Rendre la main• int sched_yield(void);
Demander explicitement au cours de son ex_ecution de render la main
Terminer une thread• void pthread_exit(void *status);
Termine l'exécution la thread courante avec une valeur de retour particulière
61
Pthread condition variable
• Une thread mutex permet de synchroniser le contrôle des accès aux données critiques(section critique)
• Une thread variable de condition permet de synchroniser la valeur de ces données.
Autrement dit “Faire coopérer les threads et attendre que les données atteingnent un état particulier ou jusqu'à ce qu'un certain événement se produise.
Exemple :le thread du magasin doit attendre que le stock ne suffise plus aux clients pour le renflouer
62
Créer une condition repose sur le même principe que les mutex à savoir, la création et initialisation d'une variable de type pthread_cond_t soit par exemple :static pthread_cond_t cond_stock = PTHREAD_COND_INITIALIZER ;
Les conditions reposent essentiellement sur deux fonctions : 1. Une permet de mettre en attente un thread 2. La seconde permet de signaler que la condition est remplie ce qui
réveille alors le thread qui est en attente de cette condition. pthread_cond_wait
int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex);• L'adresse de la variable condition de type pthread_cond_t. • L'adresse d'un mutex. Une condition est en effet, toujours associée à un Une condition est en effet, toujours associée à un
mutex. mutex. pthread_cond_signal
int pthread_cond_signal (pthread_cond_t * cond); • pthread_cond_signal : la fonction qui permet de signaler la condition au thread qui
l'attend. Elle prend en paramètre l'adresse de la variable-condition surveillée. Cette fonction ne
permet de réveiller qu'un seul thread. Pour en réveiller d'avantage, il faut utiliser la fonction:
int pthread_cond_broadcast (pthread_cond_t * cond);
63
Exercices :Pthread Condition Variable
Considérons deux variables globales partagées x et y=30, protégées par le mutex mt, et une variable condition cd pour signaler que x devient plus grand que y.
Soient deux threads : le thread Alarme qui se déclenche lorsque x > y et le thread X_inc qui incremente x.
1. Proposez le code du thread Alarme2. Proposez le code du thread X_inc3. Implémentez ce programme
64
#include <stdlib.h>#include <stdio.h>#include <pthread.h>void* maFonction(void* data);int main(){ int i; // On crée un thread pthread_t thread; // Permet d'exécuter le fonction maFonction en parallèle
pthread_create(&thread, NULL, maFonction, NULL);
// Affiche 50 fois 1 for(i=0 ; i<50 ; i++) printf("1");
// Attend la fin du thread créé pthread_join(thread, NULL); return 0;}
void* maFonction(void* data){ int i; // Affiche 50 fois 2 for(i=0 ; i<50 ; i++) printf("2");
return NULL;}
65